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 逻辑如下：

1. 先获内存中的value值。
2. 然后调用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;
    }