原子操作类AtomicInteger

一、Java 自增/自减是非线程安全的

对于 Java 中的运算操作，例如自增或自减，若没有进行额外的同步操作，在多线程环境下就是线程不安全的。num++解析为num=num+1，该操作不具备原子性，多线程并发共享这个变量时必然会出现问题。测试：

public class AtomicIntegerTest {
    private static final int THREADS_CONUT = 20;
    public static int count = 0;
    public static void increase() {
        count++;
    }
    public static void main(String[] args) {
        Thread[] threads = new Thread[THREADS_CONUT];
        for (int i = 0; i < THREADS_CONUT; i++) {
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 1000; i++) {
                        increase();
                    }
                }
            });
            threads[i].start();
        }
        while (Thread.activeCount() > 1) {
            Thread.yield();
        }
        System.out.println(count);
    }
}

这里运行了 20 个线程，每个线程对 count 变量进行 1000 次自增操作，如果上面这段代码能够正常并发的话，最后的结果应该是 20000，但实际结果却有小于 20000 的数字的情况。

二、用 volatile 修饰 count 变量结果如何

volatile 关键字很重要的两个特性：

1. 保证变量在线程间可见，对 volatile 变量所有的写操作都能立即反应到其他线程中。换句话说，volatile 变量在各个线程中是一致的(得益于 Java 内存模型—"先行发生原则")
2. 禁止指令的重排序优化。

用 volatile 修饰 count 变量后，测试如下：

public class AtomicIntegerTest {
    private static final int THREADS_CONUT = 20;
    public static volatile int count = 0;
    public static void increase() {
        count++;
    }
    public static void main(String[] args) {
        Thread[] threads = new Thread[THREADS_CONUT];
        for (int i = 0; i < THREADS_CONUT; i++) {
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 1000; i++) {
                        increase();
                    }
                }
            });
            threads[i].start();
        }
        while (Thread.activeCount() > 1) {
            Thread.yield();
        }
        System.out.println(count);
    }
}

测试结果和上面的一致，依然有小于 20000 的数字出现的情况。这又是为什么么？ 上面的论据是正确的，也就是上面标红的内容，但是这个论据并不能得出“基于 volatile 变量的运算在并发下是安全的”这个结论，因为核心点在于 Java 里的运算(比如自增)并不是原子性的。

三、AtomicInteger 类

import java.util.concurrent.atomic.AtomicInteger;
 
public class AtomicIntegerTest {
    private static final int THREADS_CONUT = 20;
    public static AtomicInteger count = new AtomicInteger(0);
    public static void increase() {
        count.incrementAndGet();
    }
    public static void main(String[] args) {
        Thread[] threads = new Thread[THREADS_CONUT];
        for (int i = 0; i < THREADS_CONUT; i++) {
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 1000; i++) {
                        increase();
                    }
                }
            });
            threads[i].start();
        }
 
        while (Thread.activeCount() > 1) {
            Thread.yield();
        }
        System.out.println(count);
    }
}

结果每次都输出 20000，程序输出了正确的结果。

四、整合压测

public class AtomicIntegerTest implements Runnable {
 
    static AtomicInteger atomicInteger = new AtomicInteger(0);
 
    static int commonInteger = 0;
 
    public void addAtomicInteger() {
        atomicInteger.getAndIncrement();
    }
 
    public void addCommonInteger() {
        commonInteger++;
    }
 
    @Override
    public void run() {
        //可以调大10000看效果更明显
        for (int i = 0; i < 10000; i++) {
            addAtomicInteger();
            addCommonInteger();
        }
    }
 
    public static void main(String[] args) throws InterruptedException {
        AtomicIntegerTest atomicIntegerTest = new AtomicIntegerTest();
        Thread thread1 = new Thread(atomicIntegerTest);
        Thread thread2 = new Thread(atomicIntegerTest);
        thread1.start();
        thread2.start();
        //join()是为了让main线程等待thread1、thread2两个子线程执行完毕
        thread1.join();
        thread2.join();
        System.out.println("AtomicInteger add result = " + atomicInteger.get());
        System.out.println("CommonInteger add result = " + commonInteger);
    }
}

五、AtomicInteger中getAndIncrement与incrementAndGet的区别

1️⃣getAndIncrement 源码：

public final int getAndIncrement() {
    return unsafe.getAndAddInt(this, valueOffset, 1);
}

2️⃣incrementAndGet 源码：

public final int incrementAndGet() {
    return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}

两者都是调用了 unsafe 的 getAndAddInt 方法，只是后面的进行了 +1 操作。

3️⃣unsafe 的 getAndAddInt 源码如下：

public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    return var5;
}

getAndAddInt 源码，就是经典的 CAS 自旋操作 volatile 变量。这个方法有三个参数：

1. 操作的对象 var1。
2. 对象中字段的偏移量 var2。
3. 要增加的值 var4。

该方法获取内存地址为 var1+var2 的变量值，并将该变量值加上 var4。逻辑如下：

1. 通过对象和偏移量获取变量的值。由于 volatile 的修饰，所有线程看到的 var5 都是一样的。
2. while 中的 compareAndSwapInt() 尝试修改 var5 的值。具体地，该方法也会通过 var1 和 var2 获取变量的值。
3. 如果这个值和 var5 不一样，说明其他线程修改了 var1+var2 地址处的值，此时 compareAndSwapInt() 返回 false，继续循环。
4. 如果这个值和 var5 一样，说明没有其他线程修改 var1+var2 地址处的值，此时可以将 var1+var2 地址处的值改为 var5 + var4，compareAndSwapInt() 返回 true，退出循环。
5. Unsafe 类中的 compareAndSwapInt() 是原子操作，所以 compareAndSwapInt() 修改 var1+var2 地址处的值的时候不会被其他线程中断。

可以看到它是先获取当前的值，然后再调用 compareAndSwapInt() 尝试更新对应偏移量处的值，如果成功了就跳出循环，如果不成功就再重新尝试，直到成功为止。AtomicInteger 的其它方法几乎都是类似的，最终会调用到 Unsafe 的 compareAndSwapInt() 来保证对 value 值更新的原子性。注意，这里返回的 var5 是加法之前的结果，也就是返回的是 +1 之前的结果，那么1️⃣2️⃣两个方法区别就是一个返回 +1 之前的结果，一个返回 +1 之后的结果。