【JAVA笔记——道】JAVA原子性解决方案java.util.concurrent.atomic

java.util.concurrent是jdk提供在多线程下的原子性解决方案，java.util.concurrent下主要是常用数据结构的原子性实现类，java.util.concurrent.atomic是基础数据类型的原子性实现类
推荐先看：如何对JAVA进行内存操作 sun.misc.Unsafe类

AtomicBoolean

顾名思义，该类其实是一个原子布尔类，定义域如下：

    private static final long serialVersionUID = 4654671469794556979L;
    private static final Unsafe unsafe = 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是对核心数据boolean的存储，unsafe以及valueOffset都是用于实现value操作过程中的原子性。并发性的控制主要通过Unsafe进行操作。

//正常赋值
public final void set(boolean newValue) {
    value = newValue ? 1 : 0;
}

//懒加载，内存操作，不进行store load
public final void lazySet(boolean newValue) {
    int v = newValue ? 1 : 0;
    unsafe.putOrderedInt(this, valueOffset, v);
}

//取值后更新
public final boolean getAndSet(boolean newValue) {
    boolean prev;
    do {
        prev = get();
    } while (!compareAndSet(prev, newValue));
    return prev;
}
//if(expect == update) update();
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);
}

“`
与之相似的还有AtomicInt，AtomicLong等，实现方式没有太大的区别。

相对与并发控制语句，原子操作实际上进行的是内存级别的乐观锁控制，因此，性能上要比synchronized性能高出300倍以上