java的原子变量操作类都是通过Unsafe的CAS方法实现。先看如何使用Unsafe实现原子自增。（有关Unsafe的介绍可以参阅）
首先通过反射获取Unsafe对象，然后通过Unsafe对象获得state2 偏移地址。使用CyclicBarrier 模拟10线程并发处理情况。可以看到原子类AtomicInteger 和Unsafe都可以保持原子性。其实AtomicInteger底层也是通过调用Unsafe的方法实现的。
public class AtomicTest {
static int state1 = 0;
private int state2 = 0;
static AtomicInteger state3 = new AtomicInteger();
static Unsafe unsafe;
static long stateOffset;
static {
try {
//通过反射获取Unsafe对象
Field field = Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
unsafe = (Unsafe) field.get(null);
//获得字段state2内存偏移量
stateOffset = unsafe.objectFieldOffset(AtomicTest.class.getDeclaredField("state2"));
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws InterruptedException {
//并发工具类，模拟并发情况
final CyclicBarrier cyclicBarrier = new CyclicBarrier(10);
final AtomicTest atomicTest = new AtomicTest();
for (int i = 0; i < 10; i++) {
new Thread(new Runnable() {
public void run() {
try {
cyclicBarrier.await();
} catch (Exception e) {
e.printStackTrace();
}
for (int j = 0; j < 100; j++) {
state1++;
unsafe.getAndAddInt(atomicTest, stateOffset, 1);
state3.getAndIncrement();
}
}
}).start();
}
TimeUnit.SECONDS.sleep(3);
System.out.println("state1: "+state1);
System.out.println("state2: "+atomicTest.getState2());
System.out.println("state3: "+state3);
}
public int getState2() {
return state2;
}
public void setState2(int state2) {
this.state2 = state2;
}
}
输出结果
state1: 977
state2: 1000
state3: 1000
AtomicInteger自增原理分析
原子操作类的实现原理类似，我们以AtomicInteger 来讲解它们的实现原理。
可以看到AtomicInteger 第一步操作也是通过静态代码块获得value在AtomicInteger 的偏移地址。因为原子类也是放在rt.jar包内，所以可以通过调用getUnsafe静态方法直接获取。
public class AtomicInteger extends Number implements java.io.Serializable {
private static final long serialVersionUID = 6214790243416807050L;
//获得一个Unsafe对象
private static final Unsafe unsafe = Unsafe.getUnsafe();
// value在AtomicInteger 中的偏移量
private static final long valueOffset;
static {
try {
//获得value在AtomicInteger 中的偏移量
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
//自增操作的值
private volatile int value;
public AtomicInteger(int initialValue) {
value = initialValue;
}
public AtomicInteger() {
}
..............省略
原子自增和自减代码如下。可以看到底层都是调用了unsafe相关的方法
/**
* 调用unsafe原子自增，返回原始值
*/
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}
/**
* 调用unsafe原子自减，返回原始值
*/
public final int getAndDecrement() {
return unsafe.getAndAddInt(this, valueOffset, -1);
}
/**
* 调用unsafe原子自增，自增后的值。
*/
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
/**
* 调用unsafe原子自减，返回递减后的值。
*/
public final int decrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
}
getAndAddInt 逻辑如下：
- 先获内存中的value值。
- 然后调用cas方法进行自增，死循环直至CAS成功为止。
compareAndSwapInt 的参数依次为 操作的对象（o），操作的值在对象中的的偏移地址（offset），原来的值(v)，自增后的值（v+delta）
public final int getAndAddInt(Object o, long offset, int delta) {
int v;
do {
v = getIntVolatile(o, offset);
} while (!compareAndSwapInt(o, offset, v, v + delta));
return v;
}
