1 AtomicInteger+AtomicLong+AtomicBoolean+AtomicReference

（1）AtomicInteger：以原子方式更新int类型变量。
（2）AtomicLong：以原子方式更新loog类型变量。
（3）AtomicBoolean：以原子方式更新boolean类型变量。
（4）AtomicReference：以原子方式更新引用类型变量。

public class AtomicIntegerDemo {

    private AtomicInteger counter = new AtomicInteger();
    private CountDownLatch countDownLatch = new CountDownLatch(10);

    public AtomicInteger getCounter() {
        return counter;
    }

    public CountDownLatch getCountDownLatch() {
        return countDownLatch;
    }

    public void add() {
        for (int i = 0; i < 100; i++) {
            counter.incrementAndGet();
        }
        countDownLatch.countDown();
    }

}

public class AtomicIntegerTest {

    public static void main(String[] args) {
        AtomicIntegerDemo demo = new AtomicIntegerDemo();
        List<Thread> threads = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            threads.add(new Thread(() -> {
                demo.add();
            }));
        }
        for (Thread thread : threads) {
            thread.start();
        }
        try {
            demo.getCountDownLatch().await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 输出1000
        System.out.println(demo.getCounter().get());
    }

}

2 AtomicIntegerArray+AtomicLongArray+AtomicReferenceArray

（1）AtomicIntegerArray：以原子方式更新int类型数组中的元素。
（2）AtomicLongArray：以原子方式更新long类型数组中的元素。
（3）AtomicReferenceArray：以原子方式更新引用类型数组中的元素。

3 AtomicStampedReference

AtomicStampedReference：以原子方式更新引用类型变量，同时解决了ABA问题。

4 AtomicIntegerFieldUpdater+AtomicLongFieldUpdater+AtomicReferenceFieldUpdater

（1）AtomicIntegerFieldUpdater：以原子方式更新指定类中的int类型字段，这个字段必须被volatile修饰。
（2）AtomicLongFieldUpdater：以原子方式更新指定类中的long类型字段，这个字段必须被volatile修饰。
（3）AtomicReferenceFieldUpdater：以原子方式更新指定类中的引用类型字段，这个字段必须被volatile修饰。
示例一：

public class Data {
    public volatile int value1 = 10;
    protected volatile int value2 = 20;
    volatile int value3 = 30;
}

public class AtomicIntegerFieldUpdaterDemo1 {

    public static void main(String[] args) {
        Data data = new Data();
        System.out.println(data.value1);// 输出10
        System.out.println(data.value2);// 输出20
        System.out.println(data.value3);// 输出30
        AtomicIntegerFieldUpdater<Data> updater1 = AtomicIntegerFieldUpdater.newUpdater(Data.class, "value1");
        updater1.compareAndSet(data, 10, 100);// 成功
        updater1.compareAndSet(data, 10, 200);// 失败
        System.out.println(data.value1);// 输出100
        AtomicIntegerFieldUpdater<Data> updater2 = AtomicIntegerFieldUpdater.newUpdater(Data.class, "value2");
        System.out.println(updater2.incrementAndGet(data));// 输出21
        AtomicIntegerFieldUpdater<Data> updater3 = AtomicIntegerFieldUpdater.newUpdater(Data.class, "value3");
        System.out.println(updater3.decrementAndGet(data));// 输出29
    }

}

示例二：

public class AtomicIntegerFieldUpdaterDemo2 {
    
    public volatile int value1 = 1;
    protected volatile int value2 = 2;
    volatile int value3 = 3;
    private volatile int value4 = 4;

    public static void main(String[] args) {
        AtomicIntegerFieldUpdaterDemo2 demo = new AtomicIntegerFieldUpdaterDemo2();
        System.out.println(demo.value1);// 输出1
        System.out.println(demo.value2);// 输出2
        System.out.println(demo.value3);// 输出3
        System.out.println(demo.value4);// 输出4
        AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterDemo2> updater1 = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterDemo2.class, "value1");
        updater1.compareAndSet(demo, 1, 10);// 成功
        updater1.compareAndSet(demo, 1, 20);// 失败
        System.out.println(demo.value1);// 输出10
        AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterDemo2> updater2 = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterDemo2.class, "value2");
        System.out.println(updater2.incrementAndGet(demo));// 输出3
        AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterDemo2> updater3 = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterDemo2.class, "value3");
        System.out.println(updater3.decrementAndGet(demo));// 输出2
        AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterDemo2> updater4 = AtomicIntegerFieldUpdater.newUpdater(AtomicIntegerFieldUpdaterDemo2.class, "value4");
        System.out.println(updater4.getAndSet(demo, 40));// 输出4
        System.out.println(demo.value4);// 输出40
    }
    
}