引出

高并发的情况下，i++无法保证原子性，往往会出现问题，所以引入AtomicInteger类。

public class TestAtomicInteger {
    private static final int THREADS_COUNT = 2;

    public static int count = 0;
    public static volatile int countVolatile = 0;
    public static AtomicInteger atomicInteger = new AtomicInteger(0);
    public static CountDownLatch countDownLatch = new CountDownLatch(2);

    public static void increase() {
        count++;
        countVolatile++;
        atomicInteger.incrementAndGet();
    }

    public static void main(String[] args) throws InterruptedException {
        Thread[] threads = new Thread[THREADS_COUNT];
        for(int i = 0; i< threads.length; i++) {
            threads[i] = new Thread(() -> {
                for(int i1 = 0; i1 < 1000; i1++) {
                    increase();
                }
                countDownLatch.countDown();
            });
            threads[i].start();
        }

        countDownLatch.await();

        System.out.println(count);
        System.out.println(countVolatile);
        System.out.println(atomicInteger.get());
    }
}

测试结果如下:

1974
1990
2000

通过多次测试，我们可以看到只有AtomicInteger能够真正保证最终结果永远是2000。

源码阅读

1. 定义的变量

// setup to use Unsafe.compareAndSwapInt for updates
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;

// 通过Unsafe计算出value变量在对象中的偏移，该偏移值下边会用到
static {
   try {
       valueOffset = unsafe.objectFieldOffset
          (AtomicInteger.class.getDeclaredField("value"));
   } catch (Exception ex) { throw new Error(ex); }
}

// value保存当前的值
private volatile int value;

• unsafe: 一般来说，Java不像c或者c++那样，可以直接操作内存，Unsafe可以说是一个后门，可以直接操作内存，或者进行线程调度。
• valueOffset: 在类初始化的时候，计算出value变量在对象中的偏移
• value: 保存当前的值

2. layzSet方法:

public final void lazySet(int newValue) {
    unsafe.putOrderedInt(this, valueOffset, newValue);
}

• 使用lazySet的话，其他线程在之后的一小段时间里还是可以读到旧的值。
• 个人猜测：lazySet方法相比于set方法可能性能好一点。

3. set方法

• 相当于初始化value

4. 增加和减少

以下方法采用CAS机制，不断使用compareAndSwapInt尝试修改该值，如果失败，重新获取。

• addAndGet
• getAndAdd
• decrementAndGet
• getAndDecrement
• incrementAndGet
• getAndIncrement
• getAndSet

CAS问题

• 如果并发量小，问题不大。
• 并发量大的情况下，由于真正更新成功的线程占少数，容易导致循环次数过多，浪费时间。

public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update); }

CAS

参考：https://blog.csdn.net/qq_43040688/article/details/105914717