一、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 关键字很重要的两个特性：
保证变量在线程间可见，对 volatile 变量所有的写操作都能立即反应到其他线程中。换句话说，volatile 变量在各个线程中是一致的(得益于 Java 内存模型—"先行发生原则")- 禁止指令的重排序优化。
用 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 变量。这个方法有三个参数：
- 操作的对象 var1。
- 对象中字段的偏移量 var2。
- 要增加的值 var4。
该方法获取内存地址为 var1+var2 的变量值，并将该变量值加上 var4。逻辑如下：
- 通过对象和偏移量获取变量的值。由于 volatile 的修饰，所有线程看到的 var5 都是一样的。
- while 中的 compareAndSwapInt() 尝试修改 var5 的值。具体地，该方法也会通过 var1 和 var2 获取变量的值。
- 如果这个值和 var5 不一样，说明其他线程修改了 var1+var2 地址处的值，此时 compareAndSwapInt() 返回 false，继续循环。
- 如果这个值和 var5 一样，说明没有其他线程修改 var1+var2 地址处的值，此时可以将 var1+var2 地址处的值改为 var5 + var4，compareAndSwapInt() 返回 true，退出循环。
- Unsafe 类中的 compareAndSwapInt() 是原子操作，所以 compareAndSwapInt() 修改 var1+var2 地址处的值的时候不会被其他线程中断。
可以看到它是先获取当前的值，然后再调用 compareAndSwapInt() 尝试更新对应偏移量处的值，如果成功了就跳出循环，如果不成功就再重新尝试，直到成功为止。AtomicInteger 的其它方法几乎都是类似的，最终会调用到 Unsafe 的 compareAndSwapInt() 来保证对 value 值更新的原子性。注意，这里返回的 var5 是加法之前的结果，也就是返回的是 +1 之前的结果，那么1️⃣2️⃣两个方法区别就是一个返回 +1 之前的结果，一个返回 +1 之后的结果。
