1 概述
Java 从 JDK 1.5 开始提供了 java.util.concurrent.atomic 包，这个包中的实现类称为原子类，之所以被称为原子类是因为他们对Java各种数据类型的数据提供了线程安全的原子操作。
如AtomicInteger封装了一个Integer类型的原子类。其中incrementAndGet方法将数值+1并返回是原子操作（线程安全）。并且这种线程安全是基于CAS乐观锁的方式。相对于synchronized性能要好很多。
在 atomic 包里一共提供了 13 个原子操作类，提供了 4 种类型的原子更新方式。
- 原子更新基本类型。
- 原子更新数组。
- 原子更新引用。
- 原子更新属性（字段）
2 基本类型原子类
| 类名 | 说明 |
|---|---|
| AtomicBoolean | 原子布尔类型。 |
| AtomicInteger | 原子整型。 |
| AtomicLong | 原子长整型。 |
AtomicInteger
2.1 构造方法和属性
/** unsafe **/
private static final Unsafe unsafe = Unsafe.getUnsafe();
/** 获取属性value在内存中偏移位置 **/
private static final long valueOffset;
static {
try {
/** 获取属性value在内存中偏移位置 **/
valueOffset = unsafe.objectFieldOffset
(java.util.concurrent.atomic.AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
/**
* int值，声明为volatile，"可见性"
*/
private volatile int value;
/**
* 使用给定的初始值实例化AtomicInteger。
*/
public AtomicInteger(int initialValue) {
value = initialValue;
}
/**
* 实例化一个初始值为{@code 0}的新AtomicInteger。
*/
public AtomicInteger() {
}
原理解析
AtomicInteger 内部维护一个int类型的属性，以及其在内存中偏移位置（使用unsafe.objectFieldOffset获取）
/** 获取属性value在内存中偏移位置 */
private static final long valueOffset;
/** int值，声明为volatile，"可见性" */
private volatile int value;
static {
try {
/** 获取属性value在内存中偏移位置 **/
valueOffset = unsafe.objectFieldOffset
(java.util.concurrent.atomic.AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
对AtomicInteger 操作本质是对内部int属性的操作。为保证操作的线程安全性，AtomicInteger并没有使用synchronized，而是使用了CAS+循环这种无锁的机制
/** 获取属性value在内存中偏移位置 **/
private static final long valueOffset;
public final int getAndSet(int newValue) {
return unsafe.getAndSetInt(this, valueOffset, newValue);
}
public final int getAndSetInt(Object var1, long var2, int var4) {
int var5;
do {
var5 = this.getIntVolatile(var1, var2);
} while(!this.compareAndSwapInt(var1, var2, var5, var4));
return var5;
}
源码解析
/**
* 获取int值
*/
public final int get() {
return value;
}
/**
* 设置int值为新值newValue
*/
public final void set(int newValue) {
value = newValue;
}
/**
* 设置int值为新值newValue（不保证其他线程立刻看到），
* 因为value设置为volatile一般情况下其他线程都可见，这里就是抛弃了volatile特性，
* 1 清空其他线程中缓存，保证可见性
* 2 内存屏障保证有序性。
* @param newValue the new value
* @since 1.6
*/
public final void lazySet(int newValue) {
unsafe.putOrderedInt(this, valueOffset, newValue);
}
/**
* 原子设置为给定值并返回旧值。(内部使用CAS乐观锁+循环)
*/
public final int getAndSet(int newValue) {
return unsafe.getAndSetInt(this, valueOffset, newValue);
}
/**
* 使用CAS设置新值newValue，成功返回true,失败返回false
*/
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
/**
* 使用CAS设置新值newValue，成功返回true,失败返回false
*/
public final boolean weakCompareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
/**
* 以原子方式将当前值+1。(内部使用CAS乐观锁+循环),返回旧值
*/
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}
/**
* 以原子方式将当前值-1。(内部使用CAS乐观锁+循环),返回旧值
*/
public final int getAndDecrement() {
return unsafe.getAndAddInt(this, valueOffset, -1);
}
/**
* 以原子方式将当前值增加delta。这里传入负数就是减少|delta|(内部使用CAS乐观锁+循环)，返回旧值
*/
public final int getAndAdd(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta);
}
/**
* 以原子方式将当前值+1。(内部使用CAS乐观锁+循环),返回新值
*/
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
/**
* 以原子方式将当前值-1。(内部使用CAS乐观锁+循环),返回新值
*/
public final int decrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
}
/**
* 以原子方式将当前值增加delta。这里传入负数就是减少|delta|(内部使用CAS乐观锁+循环)，返回新值
*/
public final int addAndGet(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
}
/**
* 以原子方式执行IntUnaryOperator函数处理，使用CAS乐观锁+循环，返回旧值
*/
public final int getAndUpdate(IntUnaryOperator updateFunction) {
int prev, next;
do {
prev = get();
next = updateFunction.applyAsInt(prev);
} while (!compareAndSet(prev, next));
return prev;
}
/**
* 以原子方式执行IntUnaryOperator函数处理，使用CAS乐观锁+循环，返回新值
*/
public final int updateAndGet(IntUnaryOperator updateFunction) {
int prev, next;
do {
prev = get();
next = updateFunction.applyAsInt(prev);
} while (!compareAndSet(prev, next));
return next;
}
/**
* 以原子方式执行IntBinaryOperator函数处理，使用CAS乐观锁+循环，返回旧值
*/
public final int getAndAccumulate(int x,
IntBinaryOperator accumulatorFunction) {
int prev, next;
do {
prev = get();
next = accumulatorFunction.applyAsInt(prev, x);
} while (!compareAndSet(prev, next));
return prev;
}
/**
* 以原子方式执行IntBinaryOperator函数处理，使用CAS乐观锁+循环，返回旧值
*/
public final int accumulateAndGet(int x,
IntBinaryOperator accumulatorFunction) {
int prev, next;
do {
prev = get();
next = accumulatorFunction.applyAsInt(prev, x);
} while (!compareAndSet(prev, next));
return next;
}
AtomicLong
AtomicLong 逻辑和AtomicInteger,由于JVM中操作栈数据大小为32位，对于一个64位Long,设置值操作需要设置前2步，导致Long属性设置是线程步安全的。
为了解决这个问题AtomicLong加入了如下代码保证题AtomicLong设置操作是原子的。
static final boolean VM_SUPPORTS_LONG_CAS = VMSupportsCS8();
private static native boolean VMSupportsCS8();
AtomicBoolean
AtomicBoolean 逻辑和AtomicInteger，同样使用整形1.0来表示true,false
