Java原子操作保证方案
引言
原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch （切换到另一个线程）。通常所说的原子操作包括对非long和double型的primitive进行赋值，以及返回这两者之外的primitive。之所以要把它们排除在外是因为它们都比较大，而JVM的设计规范又没有要求读操作和赋值操作必须是原子操作（JVM可以试着去这么做，但并不保证）。
三种保证方式
- 加锁
- AtomicXXX
- LongAdder
现在使用1000个线程，对一个数进行加1操作，每一个线程操作10_0000遍；
最终结果应该是：10_0000*1000 = 1_0000_0000
不作任何操作
在多线程的情况下，对一个变量进行修改，如果不做任何操作，使用传统的方式来进行的话，会导致最终的结果不是我们想要的结果。
int count = 0;
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, InterruptedException {
UnsaveTest unsaveTest = new UnsaveTest();
Thread[] threads = new Thread[1000];
for (int i = 0; i < 1000; i++) {
threads[i] = new Thread(() -> {
int j = 0;
//每个线程对成员变量count进行加1操作，每个线程加10_0000次，1000个线程。
//所以 最终结果应该是：10_0000*1000 = 1_0000_0000
while (j++ < 10_0000) {
unsaveTest.count++;
}
});
}
long timeStart = System.currentTimeMillis();
for (int i = 0; i < 1000; i++) {
threads[i].start();
}
for (int i = 0; i < 1000; i++) {
threads[i].join();
}
long timeEnd = System.currentTimeMillis();
System.out.println("期望结果："+100000 * 1000);
System.out.println("运行结果 ： " + unsaveTest.count);
System.out.println("耗时：" + (timeEnd - timeStart));
}
运行结果
期望结果：100000000
运行结果 ： 97416060
耗时：82
加锁Synchronized
通过加锁的方式来保证原子操作，但有的时候同步变量只有一个，如果依然使用加锁的方式来保证原子性，在多线程竞争激烈的情况下，升级为重量级锁，会导致效率低下。
代码如下
int count = 0;
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, InterruptedException {
UnsaveTest unsaveTest = new UnsaveTest();
Thread[] threads = new Thread[1000];
for (int i = 0; i < 1000; i++) {
threads[i] = new Thread(() -> {
int j = 0;
//每个线程对成员变量count进行加1操作，每个线程加10_0000次，1000个线程。
//所以 最终结果应该是：10_0000*1000 = 1_0000_0000
while (j++ < 10_0000) {
synchronized (unsaveTest) {
unsaveTest.count++;
}
}
});
}
long timeStart = System.currentTimeMillis();
for (int i = 0; i < 1000; i++) {
threads[i].start();
}
for (int i = 0; i < 1000; i++) {
threads[i].join();
}
long timeEnd = System.currentTimeMillis();
System.out.println("期望结果：" + 100000 * 1000);
System.out.println("运行结果 ： " + unsaveTest.count);
System.out.println("耗时：" + (timeEnd - timeStart));
}
运行结果
期望结果：100000000
运行结果 ： 100000000
耗时：2574
使用AtomicXXXX
AtomicXXXX是并发包里面提供的一系列并发工具类，通过Unsafe的CAS操作（最终调用是通过CPU指令级别的方式）来保证原子操作，也就是所谓的无锁优化
代码如下
AtomicInteger counter = new AtomicInteger(0);
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, InterruptedException {
UnsaveTest unsaveTest = new UnsaveTest();
Thread[] threads = new Thread[1000];
for (int i = 0; i < 1000; i++) {
threads[i] = new Thread(() -> {
int j = 0;
//每个线程对成员变量count进行加1操作，每个线程加10_0000次，1000个线程。
//所以 最终结果应该是：10_0000*1000 = 1_0000_0000
while (j++ < 10_0000) {
unsaveTest.counter.incrementAndGet();
}
});
}
long timeStart = System.currentTimeMillis();
for (int i = 0; i < 1000; i++) {
threads[i].start();
}
for (int i = 0; i < 1000; i++) {
threads[i].join();
}
long timeEnd = System.currentTimeMillis();
System.out.println("期望结果：" + 100000 * 1000);
System.out.println("运行结果 ： " + unsaveTest.counter.get());
System.out.println("耗时：" + (timeEnd - timeStart));
}
运行结果
期望结果：100000000
运行结果 ： 100000000
耗时：1006
使用LongAdder
LongAdder是JDK1.8后为了提高AtomicLong运行效率的一个新并发工具类
代码如下：
LongAdder longAdder = new LongAdder();
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, InterruptedException {
UnsaveTest unsaveTest = new UnsaveTest();
Thread[] threads = new Thread[1000];
for (int i = 0; i < 1000; i++) {
threads[i] = new Thread(() -> {
int j = 0;
//每个线程对成员变量count进行加1操作，每个线程加10_0000次，1000个线程。
//所以 最终结果应该是：10_0000*1000 = 1_0000_0000
while (j++ < 10_0000) {
unsaveTest.longAdder.increment();
}
});
}
long timeStart = System.currentTimeMillis();
for (int i = 0; i < 1000; i++) {
threads[i].start();
}
for (int i = 0; i < 1000; i++) {
threads[i].join();
}
long timeEnd = System.currentTimeMillis();
System.out.println("期望结果：" + 100000 * 1000);
System.out.println("运行结果 ： " + unsaveTest.longAdder.intValue());
System.out.println("耗时：" + (timeEnd - timeStart));
}
运行结果
期望结果：100000000
运行结果 ： 100000000
耗时：212
总结
通过以上的几种测试，我们可以得出以下结果
在不作任何其它操作的情况下，运行效率最高，但是结果却不正确，这也是最大的问题。如果一个操作不能保证结果正确，那它就失去了意义。
在保证结果正确的情况下
Synchronized效率最低
Synchronized在多线程竞争激烈的情况下，效率会显著下降，因为无锁————》偏向锁————》轻量级锁（自旋锁）————》重量级锁，大量线程在多次等待锁的过程中，会自旋为重量级锁，这个时候效率会变得很低。
其次是AtomicInteger
AtomicInteger底层使用的Unsafe类的CAS操作，是通过CPU指令级别的方式来保证原子操作。效率也还可以。
效率最高的是LongAdder。
LongAdder类与AtomicLong类的区别在于高并发时前者将对单一变量的CAS操作分散为对数组cells中多个元素的CAS操作，取值时进行求和；而在并发较低时仅对base变量进行CAS操作，与AtomicLong类原理相同
