Java从JDK1.5开始提供java.util.concurrent.atomic包，方便程序员在多线程环境下，无锁的进行原子操作。
原子变量的底层使用了处理器提供的原子指令，但是不同的CPU架构可能提供的原子指令不一样，也有可能需要某种形式的内部锁，所以该方法不能绝对保证线程不被阻塞。atomic使用的是cas的更新方式，当某个线程在执行atomic的方法时，不会被其他线程打断，而别的线程就像自旋锁一样，一直等到该方法执行完成，才由JVM从等待队列中选择一个线程执行，在软件层面上是非阻塞的，它是在底层硬件上借助处理器的原子指令来保证的。
Atomic包里一共有12个类，四种原子更新方式，分别是原子更新基本类型、原子更新数组、原子更新引用、原子更新字段。Atomic包里的类基本都是使用Unsafe实现的包装类。
- AtomicBoolean，AtomicInteger，AtomicLong，AtomicReference
- AtomicIntegerArray，AtomicLongArray，AtomicReferenceArray
- AtomicLongFieldUpdate，AtomicIntegerFieldUpdater，AtomicReferenceFieldUpdater
- AtomicMarkableReference，AtomicStapedReference
我们看一下最简单的AtomicInteger有哪些常用的方法：
| 方法 | 作用 |
|---|---|
| get() | 直接返回值 |
| getAndAdd(int) | 增加指定的数据，返回变化前的数据 |
| getAndDecrement() | 减少1，返回减少前的数据 |
| getAndIncrement() | 增加1，返回增加前的数据 |
| getAndSet(int) | 设置指定的数据，返回设置前的数据 |
| addAndGet(int) | 增加指定的数据，返回变化后的数据 |
| decrementAndGet() | 减少1，返回变化后的值 |
| incrementAndGet() | 增加1，返回变化后的值 |
| lazeSet(int) | 仅仅当get时才会set，参考：lazySet是如何工作的 |
| compareAndSet(int,int) | 尝试新增后对比，若增加成功则返回true，失败返回false |
我们看一下Unsafe的源码：
package sun.misc;
public final class Unsafe {
......
//可以看出所有方法都是native修饰的
public native int getInt(Object var1, long var2);
public native void putInt(Object var1, long var2, int var4);
public native Object getObject(Object var1, long var2);
public native void putObject(Object var1, long var2, Object var4);
//使用处理器提供的CAS算法去做更新
public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
//在这个地方做一个自旋，保证一定更新成功
do {
//volatile保证可见性，每次都会从主内存中获取最新值
var5 = this.getIntVolatile(var1, var2);
} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
return var5;
}
public final long getAndAddLong(Object var1, long var2, long var4) {
long var6;
do {
var6 = this.getLongVolatile(var1, var2);
} while(!this.compareAndSwapLong(var1, var2, var6, var6 + var4));
return var6;
}
......
}我们看一下Atomic的源码，可以看出是直接调用了Unsafe的方法（即JNI接口）
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
public final int decrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
}Unsafe只提供了三种CAS方法，compareAndSwapObject，compareAndSwapInt和compareAndSwapLong，那么其他类型怎么更新呢？再看AtomicBoolean源码，发现是先把Boolean转换成整型，再使用compareAndSwapInt进行CAS，所以原子更新double也可以用类似的思路来实现。
//AtomicBoolean源码
public final boolean compareAndSet(boolean expect, boolean update) {
int e = expect ? 1 : 0;
int u = update ? 1 : 0;
return unsafe.compareAndSwapInt(this, valueOffset, e, u);
}
//AtomicDouble源码
//PS:AtomicDouble不是juc.atomic包下的，是com.google.common.util.concurrent下的
public final double getAndSet(double newValue) {
long next = Double.doubleToRawLongBits(newValue);
return Double.longBitsToDouble(updater.getAndSet(this, next));
}
public final boolean compareAndSet(double expect, double update) {
return updater.compareAndSet(this, Double.doubleToRawLongBits(expect), Double.doubleToRawLongBits(update));
}原子更新数组类
AtomicIntegerArray常用方法：
| 方法 | 作用 |
|---|---|
| addAndGet() | 以原子方式将输入值与数组中的索引i的元素相加 |
| compareAndSet(int i,int exepect,int update) | 如果当前值等于预期值，则以原子方式将数组位置i的元素设置成update值 |
public final int addAndGet(int i, int delta) {
return getAndAdd(i, delta) + delta;
}
public final int getAndAdd(int i, int delta) {
return unsafe.getAndAddInt(array, checkedByteOffset(i), delta);
}
public final boolean compareAndSet(int i, int expect, int update) {
return compareAndSetRaw(checkedByteOffset(i), expect, update);
}
private boolean compareAndSetRaw(long offset, int expect, int update) {
return unsafe.compareAndSwapInt(array, offset, expect, update);
}AtomicIntegerArray类需要注意的是，数组value通过构造方法传递进去，然后AtomicIntegerArray会将当前数组复制一份，所以当AtomicIntegerArray对内部的数组元素进行修改时，不会影响传入的数组。
原子更新引用类型
原子更新基本类型AtomicInteger，只能更新一个变量，如果要原子的更新多个变量，就需要使用这个原子更新引用类型提供的类。
- AtomicReference：原子更新引用类型。
- AtomicReferenceFieldUpdater：原子更新引用类型里的字段。
- AtomicMarkableReference：原子更新带有标记位的引用类型。可以原子的更新一个布尔类型的标记位和引用类型。构造方法是AtomicMarkableReference(V initialRef, boolean initialMark)
AtomicMarkableReference源码如下，是使用了一个内部类Pair绑定更新标记为和引用的
public class AtomicMarkableReference<V> {
private static class Pair<T> {
final T reference;
final boolean mark;
private Pair(T reference, boolean mark) {
this.reference = reference;
this.mark = mark;
}
static <T> Pair<T> of(T reference, boolean mark) {
return new Pair<T>(reference, mark);
}
}
private volatile Pair<V> pair;
public V get(boolean[] markHolder) {
Pair<V> pair = this.pair;
markHolder[0] = pair.mark;
return pair.reference;
}
public boolean compareAndSet(V expectedReference,
V newReference,
boolean expectedMark,
boolean newMark) {
Pair<V> current = pair;
return
expectedReference == current.reference &&
expectedMark == current.mark &&
((newReference == current.reference &&
newMark == current.mark) ||
casPair(current, Pair.of(newReference, newMark)));
}
//对Pair进行CAS
private boolean casPair(Pair<V> cmp, Pair<V> val) {
return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
}AtomicReference的使用例子代码如下：
public class AtomicReferenceTest {
public static AtomicReference<user> atomicUserRef = new AtomicReference</user><user>();
public static void main(String[] args) {
User user = new User("conan", 15);
atomicUserRef.set(user);
User updateUser = new User("Shinichi", 17);
atomicUserRef.compareAndSet(user, updateUser);
System.out.println(atomicUserRef.get().getName());
System.out.println(atomicUserRef.get().getAge());
}
static class User {
private String name;
private int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
}原子更新字段
如果我们只需要更新某个类里的某个字段，那么就需要使用原子更新字段类。
- AtomicIntegerFieldUpdater：原子更新整型的字段的更新器。
- AtomicLongFieldUpdater：原子更新长整型字段的更新器。
- AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于原子的更数据和数据的版本号，可以解决使用CAS进行原子更新时，可能出现的ABA问题。实现与AtomicMarkableReference类似，都是使用了Pair内部类实现版本号和数据的绑定CAS更新。
public abstract class AtomicIntegerFieldUpdater<T> {
public abstract boolean compareAndSet(T obj, int expect, int update);
public abstract void lazySet(T obj, int newValue);
public abstract int get(T obj);
public int getAndAdd(T obj, int delta) {
int prev, next;
do {
prev = get(obj);
next = prev + delta;
} while (!compareAndSet(obj, prev, next));
return prev;
}原子更新字段类都是抽象类，每次使用都的时候都必须使用静态方法newUpdater创建一个更新器。原子更新类的字段必须使用public volatile修饰符。AtomicIntegerFieldUpdate的例子代码如下：
public class AtomicIntegerFieldUpdaterTest {
private static AtomicIntegerFieldUpdater<User> a = AtomicIntegerFieldUpdater
.newUpdater(User.class, "age");
public static void main(String[] args) {
User conan = new User("conan", 10);
System.out.println(a.getAndIncrement(conan));
System.out.println(a.get(conan));
}
static class User {
private String name;
private int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
}