引子
在讲原子类之前，请先看下面这段代码：
package net.coderchen.demo;
/**
* Created by Liuyuchen on 2018/3/12.
*/
public class Counter {
private static int sum = 0;
public static void main(String[] args) {
//开启10个线程，每个线程分别对sum进行1000次+1操作
for(int i = 0 ; i < 10 ; i++){
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
for(int j = 0 ; j < 1000 ; j++){
sum++;
}
}
});
thread.start();
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//输出多少？
System.out.println(sum);
}
}
这段代码的运行结果是多少？10000？
实际上，绝大部分情况下，最终输出的数字都是小于10000的。
出现这种情况的原因，是因为 sum++ 这个操作，不是原子操作，因为不是原子操作，程序的结果就可能因为线程的上下文切换，输出不确定的结果。
原子操作
原子（atomic）本意是“不能被进一步分割的最小粒子”，而原子操作（atomic operation）意为“不可被中断的一个或一系列操作”。——《Java并发编程的艺术》
在上述代码中，sum++为什么不是原子操作呢？在sum++这条代码执行的过程中，发生了什么呢？
sum++其实至少可以被分成三段代码：
通过javap- verbose Counter.class查看Counter类的字节码：
0: getstatic #1 // Field sum:I
3: dup
4: iconst_1
5: iadd
6: putstatic #1 // Field sum:I
getstatic：从静态域中得到当前sum值；
iadd：将sum与常量1相加；
putstatic：将相加的结果写回静态域；
以上操作均可被中断，当多个线程互相竞争时，就可能出现以下场景：
线程A从static域中读取到sum为0；
线程A将sum与1相加，得到sum为1，此时还未写回static域；
线程B从static域中读取到sum为0；
线程B将sum与1相加，得到sum为1，此时还未写回static域；
线程B将sum与1相加的结果写回static域，此时static中的sum为1；
线程A将sum与1相加的结果写回static域，此时static中的sum为1；
于是就出现了，两个线程分别对sum进行了+1操作，但是其中一个操作的结果却被另一个线程覆盖了，最终导致sum的值比预期的小。
Java中的原子类
如何解决上述问题呢？对sum变量进行加锁？当然可以，但是加锁的代价太大了，同一时刻只能有一个线程访问sum变量，大大降低了性能。
Java中针对此类问题，给我们提供了一个很好的解决方案。在java.util.concurrent.atomic包下面，有这样一些原子类：AtomicInteger、AtomicLong、AtomicReference等，利用不加锁的方式，实现了sum++操作的原子性，保证了线程安全。
以AtomicInteger为例，对上述程序进行改写：
package net.coderchen.demo;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Created by Liuyuchen on 2018/3/12.
*/
public class AtomicCounter {
private static AtomicInteger sum = new AtomicInteger(0);
public static void main(String[] args) {
//开启10个线程，每个线程分别对sum进行1000次+1操作
for(int i = 0 ; i < 10 ; i++){
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
for(int j = 0 ; j < 1000 ; j++){
sum.addAndGet(1);
}
}
});
thread.start();
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//输出多少？
System.out.println(sum.get());
}
}
改写后的代码，无论运行多少次，运行结果都是10000。
CAS
那么AtomicInteger究竟为我们做了什么呢？实际上，AtomicInteger是利用CAS（compare and swap）操作来实现的。而CAS是利用了处理器提供的CMPXCHG指令实现的，CAS的过程是原子的，不可被分割。
查看AtomicInteger.addAndGet的源代码：
/**
* Atomically adds the given value to the current value.
*
* @param delta the value to add
* @return the updated value
*/
public final int addAndGet(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
}
可以看到，addAndGet方法是通过sun.misc.Unsafe类的getAndAddInt方法实现的，继续查看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;
}
看到了吗！这里出现了一个很重要的方法compareAndSwapInt，通过循环CAS操作，如果成功自增，则操作结束，退出循环，否则说明有其他线程竞争，这时会不断进行重试，直到最终实现sum原子性递增。
问题
以上引出了Java中的各个原子类实现的核心原理：CAS。CAS默认不会出现竞争，一旦出现竞争，则进行不断重试，避免了加锁带来的性能问题。然而，CAS也带来了一些问题：
1）ABA问题。
一个值初始为A，变成了B，又被修改为A，这时使用CAS检查时会发现这个值本身并没有发生变化，但是实际上它已经变化了，如果还按照它没有变化进行处理，就会出现某些意想不到的问题；解决这个问题的方式是给变量加上一个版本号，更新时，如果版本号和值都和预期一致，才去进行更新。具体例子可以参考AtomicStampedReference类。
2）由于CAS的原理是出现竞争后不断进行尝试，随着并发量的增加，尝试次数会随之增加，CAS的性能会变得非常差，也给CPU带来相当大的开销。
3)CAS只能保证一个变量的原子操作，对于多个变量的的原子性无法保证，这时可以用锁进行处理。
