一 什么是原子类?
所谓原子类必然是具有原子性的类，原子性操作--原子操作，百度百科中给的定义如下
"原子操作(atomic operation)是不需要synchronized"，这是Java多线程编程的老生常谈了。所谓原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch （切[1] 换到另一个线程）。
顾名思义，原子类就是一个一旦被执行就不能中断的类。
二 为什么需要原子类？
在看为什么需要原子类之前，我们看看普通Number类,在处理问题时可能存在的问题，这里我们通过Integer来演示
public class Main {
private static Integer sum = 0;
public static void main(String[] args) {
for (int i = 0; i < 20; i++) {
new Thread(new Task()).start();
}
Thread.yield();
System.out.println(sum);
}
static class Task implements Runnable {
@Override
public void run() {
for(int i = 0;i<100;i++){
sum++;
}
}
}
}
这段代码意思是开20个线程，每个线程对sum自加100次，理论上应该最后输出2000；但是事实上每次都是小于2000；
这是听说过volatile关键字的小伙伴可能会说，使用volatile来修饰sum,好，我们继续试验
public class Main {
private static volatile Integer sum = 0;
public static void main(String[] args) {
for (int i = 0; i < 20; i++) {
new Thread(new Task()).start();
}
Thread.yield();
System.out.println(sum);
}
static class Task implements Runnable {
@Override
public void run() {
for(int i = 0;i<100;i++){
sum++;
}
}
}
}
这是试验五次的输出
1766，1616，1859，1980，1800
还是都是小于2000，这是怎么回事，这里先提一下，volatile只能保证单个操作的原子性，而sum++，包括三个操作
sum = getSum() //读取sum temp = sum +1; //sum+1,赋给临时变量 sum = setSum(temp) //将sum写回
因此，即使是volatile也无法保证sum++的原子性，volatile只能保证单个操作的原子性，而++操作是复合操作，volatile变量会在后续章节详细讨论；
那么，在Atomic未出现之前，是如何处理i++在多线程环境下的线程安全问题，主要是通过Synchronize加锁来处理，处理过程复杂，性能低
JDK5.0之后出现的Java.util.concurrent.Atomic包中为我们提供了13中原子类，来保证单个原子变量复合操作的原子性。下面我们通过AtomicInteger的使用来认识一下原子类
三 原子类示例详解
AtomicInteger 字段
// setup to use Unsafe.compareAndSwapInt for updates
//这里， unsafe是java提供的获得对对象内存地址访问的类，注释已经清楚的写出了，它的作用就是在更新操作时提供“比较并替换”的作用。实际上就是AtomicInteger中的一个工具。
private static final Unsafe unsafe = Unsafe.getUnsafe();
//valueOffset是用来记录value本身在内存的便宜地址的，这个记录，也主要是为了在更新操作在内存中找到value的位置，方便比较。
private static final long valueOffset;
//value是用来存储整数的时间变量，这里被声明为volatile，就是为了保证在更新操作时，当前线程可以拿到value最新的值（并发环境下，value可能已经被其他线程更新了）。
private volatile int value;
AtomicInteger 构造方法
/**
* Creates a new AtomicInteger with the given initial value.
*
* @param initialValue the initial value
*/
public AtomicInteger(int initialValue) {
value = initialValue;
} /**
* Creates a new AtomicInteger with initial value {@code 0}.
*/
public AtomicInteger() {
}
AtomicInteger 并发安全实现
那么AtomicInteger是如何实现多线程的自增操作的线程安全的呢？核心思想就是CAS自旋；CAS:Compare And Swap 比较并交换。自旋：通过循环知道预期值和内存之相同，进行CAS操作，AtomicInteger的自增如下所示
public final int incrementAndGet() {
for (;;) {
//这里可以拿到value的最新内存值
int current = get();
int next = current + 1;
if (compareAndSet(current, next))
return next;
}
}
public final boolean compareAndSet(int expect, int update) {
//使用unsafe的native方法，实现高效的硬件级别CAS
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
AtomicInteger 其他常用方法
/**
* 返回旧值，然后自增1
*
* @return the previous value
*/
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
} /**
* 返回旧值，然后自减1
*
* @return the previous value
*/
public final int getAndDecrement() {
return unsafe.getAndAddInt(this, valueOffset, -1);
} /**
* 返回旧值，然后 旧值+delta
*
* @param delta the value to add
* @return the previous value
*/
public final int getAndAdd(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta);
} /**
* 先进行自增，返回自增后的值
*
* @return the updated value
*/
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
} /**
* 先进行自减，然后返回自减后的值
*
* @return the updated value
*/
public final int decrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
} /**
*先在原值上加delta，再返回加之后的值
*
* @param delta the value to add
* @return the updated value
*/
public final int addAndGet(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
}
注：其他Atomic类类似，不一一介绍；
四 Atomic 存在的问题
》 长时间自旋，导致CPU和资源的占用
》 只能保证单个原子变量的多线程安全操作，当然可以将多个变量封装成一个类,通过原子引用类型实现
》 ABA问题；使用AtomicStampedReference 原子更新带有版本号的引用类型解决