一、变量含义

AtomicBoolean主要原子操作boolean类型数据。下面第二行valueOffset记录了value变量的内存地址，用于原子操作value的值。后面会说到compareAndSet等方法都会用到这个内存地址。我们可以看到static方法里面利用unsafe的objectFieldOffset方法获取了字段内存地址。

private static final Unsafeunsafe = Unsafe.getUnsafe();

private static final long valueOffset;

static {

try {

valueOffset =unsafe.objectFieldOffset

(AtomicBoolean.class.getDeclaredField("value"));

    }catch (Exception ex) {throw new Error(ex); }

}

private volatile int value;

value被定义为volatile变量，volatile具有可见性、有序性，不具备原子性，主要是为了解决多线程对同一个变量的读写并发问题。

原子性：也就是操作事原子性的，不会出现修改了一半的情况，这好理解。

可见性：多个线程同时并发修改这个value，各个线程也可以实时读取到修改后的值。

有序性：这里主要针对编译器和处理器对指令进行重排序，也就是volatile修饰的变量不会出现指令重排序，其他例如通过synchronized和Lock也可以保证有序性。

二、原子性与CAS

那么问题来了，既然value能够保证原子性，那么下面的结果是10000吗？

public class Test {
    public volatile int inc = 0;
    public void increase() {
        inc++;
    }
    public static void main(String[] args) {
        final Test test = new Test();
        for(int i=0;i<10;i++){
            new Thread(){
                public void run() {
                    for(int j=0;j<1000;j++)
                        test.increase();
                };
            }.start();
        }
        while(Thread.activeCount()>1) //保证前面的线程都执行完
            Thread.yield();
        System.out.println(test.inc);
    }
}

答案是不行，原因是上面说的原子性指的“读”是原子性的，不包括写。AtomicBoolean通过compareAndSet方法来保证写操作的原子性，如下代码所示，设置变量value值为为u，并要求变量当前值为e

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);
}

使用了CAS操作，最终调用了unsafe的compareAndSwapInt方法

/***
  * Compares the value of the integer field at the specified offset
  * in the supplied object with the given expected value, and updates
  * it if they match.  The operation of this method should be atomic,
  * thus providing an uninterruptible way of updating an integer field.
  * 在obj的offset位置比较integer field和期望的值，如果相同则更新。这个方法
  * 的操作应该是原子的，因此提供了一种不可中断的方式更新integer field。
  *
  * @param obj the object containing the field to modify.
  *            包含要修改field的对象
  * @param offset the offset of the integer field within <code>obj</code>.
  *              <code>obj</code>中整型field的偏移量
  * @param expect the expected value of the field.
  *              希望field中存在的值
  * @param update the new value of the field if it equals <code>expect</code>.
  *          如果期望值expect与field的当前值相同，设置filed的值为这个新值
  * @return true if the field was changed.
  *                            如果field的值被更改
  */
public native boolean compareAndSwapInt(Object obj, long offset, intexpect, int update);

set(boolean newValue)和lazySet(boolean newValue)方法比较有意思。set方法好理解，lazySet使用了putOrderedInt方法，其实就是就是不使用内存屏障，修改后，不对其它线程理解可见，是对上面compareAndSwapInt功能的弱化

/**
* Unconditionally sets to the given value.
*
* @param newValue the new value
*/
public final void set(boolean newValue) {
  value = newValue ?1 :0;
}
/**
* Eventually sets to the given value.
*
* @param newValue the new value
* @since 1.6
*/
public final void lazySet(boolean newValue) {
int v = newValue ?1 :0;
    unsafe.putOrderedInt(this, valueOffset, v);
}

另外还有weakCompareAndSet看名字就知道是一个不保证返回结果的方法，jdk暂未实现。