Atomic应用归纳

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

//原子包装对象处理类
AtomicInteger atomicInteger = new AtomicInteger();
AtomicBoolean atomicBoolean = new AtomicBoolean();
AtomicLong atomicLong = new AtomicLong();
AtomicReference<Object> objectAtomicReference = new AtomicReference<>();

//解决ABA问题处理类
AtomicStampedReference<Integer> objectAtomicStampedReference = new AtomicStampedReference<>(new Integer(1), 1);
AtomicMarkableReference<Integer> objectAtomicMarkableReference = new AtomicMarkableReference<>(new Integer(1), true);

//原子数组对象处理类
AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(1);
AtomicLongArray atomicLongArray = new AtomicLongArray(1);
AtomicReferenceArray<Object> objectAtomicReferenceArray = new AtomicReferenceArray<>(1);

//原子属性修改器处理类
AtomicIntegerFieldUpdater<Score> objectAtomicIntegerFieldUpdater = AtomicIntegerFieldUpdater.newUpdater(Score.class, "num");
AtomicLongFieldUpdater<LongDemo> num = AtomicLongFieldUpdater.newUpdater(LongDemo.class, "num");
AtomicReferenceFieldUpdater<ObjectDemo, String> str = AtomicReferenceFieldUpdater.newUpdater(ObjectDemo.class, String.class, "str");

//高性能的原子整型计算类
//高性能的浮点型计算类
LongAdder longAdder = new LongAdder();
DoubleAdder doubleAdder = new DoubleAdder();

测试类示例代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
package per.guc.gucproject.test;

import java.util.concurrent.atomic.*;

public class Atomic {

    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger();
        AtomicBoolean atomicBoolean = new AtomicBoolean();
        new Double
        AtomicLong atomicLong = new AtomicLong();
        AtomicReference<Object> objectAtomicReference = new AtomicReference<>();

        //读取
        int i = atomicInteger.get();
        boolean b = atomicBoolean.get();
        long l = atomicLong.get();
        Object o = objectAtomicReference.get();


        //写入 不能防止ABA的问题
        boolean b1 = atomicInteger.compareAndSet(i, i + 1);
        boolean b2 = atomicBoolean.compareAndSet(b, !b);
        boolean b3 = atomicLong.compareAndSet(l, l + 1);
        boolean b4 = objectAtomicReference.compareAndSet(o, new Object());

        //写入 解决ABA的问题通过
        AtomicStampedReference<Integer> objectAtomicStampedReference = new AtomicStampedReference<>(new Integer(1), 1);
        Integer reference = objectAtomicStampedReference.getReference();
        int stamp = objectAtomicStampedReference.getStamp();
        boolean b5 = objectAtomicStampedReference.compareAndSet(reference, new Integer(2), stamp, stamp + 1);

        //解决ABA的问题 标记位不一致即可
        AtomicMarkableReference<Integer> objectAtomicMarkableReference = new AtomicMarkableReference<>(new Integer(1), true);
        boolean b6 = objectAtomicMarkableReference.compareAndSet(objectAtomicMarkableReference.getReference(), new Integer(2), objectAtomicMarkableReference.isMarked(), !objectAtomicMarkableReference.isMarked());
        System.out.println(b6);

        //原子数组
        AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(1);
        AtomicLongArray atomicLongArray = new AtomicLongArray(1);
        AtomicReferenceArray<Object> objectAtomicReferenceArray = new AtomicReferenceArray<>(1);
        atomicIntegerArray.set(0, 1);
        boolean b7 = atomicIntegerArray.compareAndSet(0, 2, 2);
        System.out.println(b7);

        //属性修改器
        AtomicIntegerFieldUpdater<Score> objectAtomicIntegerFieldUpdater = AtomicIntegerFieldUpdater.newUpdater(Score.class, "num");
        AtomicLongFieldUpdater<LongDemo> num = AtomicLongFieldUpdater.newUpdater(LongDemo.class, "num");
        AtomicReferenceFieldUpdater<ObjectDemo, String> str = AtomicReferenceFieldUpdater.newUpdater(ObjectDemo.class, String.class, "str");

        //高性能的原子整型计算类
        //高性能的浮点型计算类
        LongAdder longAdder = new LongAdder();
        DoubleAdder doubleAdder = new DoubleAdder();
        for(int j=1; j<=100; j++) {
            int k = j;
            new Thread(() -> {
                longAdder.add(k);
            }).start();
        }

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(longAdder.longValue());


        Score score = new Score();
        System.out.println(score.getNum());
        objectAtomicIntegerFieldUpdater.compareAndSet(score, 0, 1);
        System.out.println(score.getNum());




    }

}

class ObjectDemo {
    public volatile String str = "";

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }
}

class LongDemo{

    public volatile long num = 0;

    public long getNum() {
        return num;
    }

    public void setNum(long num) {
        this.num = num;
    }
}

class Score {
    public volatile int num  = 0;

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }
}