Java并发学习之AtomicInteger AtomicLong AtomicBoolean

AtomicXXX具体怎么实现的呢？ 
volatile的基本数据类型+CAS操作。 
volatile保证可见性，当一个线程修改volatile变量时，其他线程拿到的都是修改后的最新值。里面的方法都是对Unsafe方法的封装，而Unsafe里面的方法都是JNI方法，通过调用底层c++方法从而实现指令级的原子操作。 
AtomicInteger count=new AtomicInteger(0);
以下是常见常用的方法：

    //set方法
    public final void set(int newValue) {  
        value = newValue;  
    } 

   //lazyset，没有storeload屏障的set
    public final void lazySet(int newValue) {
        unsafe.putOrderedInt(this, valueOffset, newValue);
    }

    //获取并且设置
    public final int getAndSet(int newValue) {
        return unsafe.getAndSetInt(this, valueOffset, newValue);
    }

    //原子更新值
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

    //weak的CAS，也就是没有volatile语义的CAS，没有加入内存屏障
    public final boolean weakCompareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

    //自增加，返回原先值
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

    //自减少，返回原先值
    public final int getAndDecrement() {
        return unsafe.getAndAddInt(this, valueOffset, -1);
    }

    //原子性增加delta值
    public final int getAndAdd(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta);
    }

    //自增1，返回最终值
    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }
    //阻塞式更新，并且对prev进行一个IntUnaryOperator操作运算
    public final int updateAndGet(IntUnaryOperator updateFunction) {
        int prev, next;
        do {
            prev = get();
            next = updateFunction.applyAsInt(prev);
        } while (!compareAndSet(prev, next));
        return next;
    }
    //阻塞式更新，并对prev和x，进行二元运算操作。
    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;
    }

 

lazySet

从上面代码可以看到，由于value是volatile类型，所以普通方法set，就是写入volatile类型变量。此时JVM会插入特定的内存屏障，内存语义具有可见性。

而lazySet呢？看意思是“懒惰”的set，什么意思呢？ 
set是内存语义是立即对其他线程可见，则lazySet则是不一定立即可见。 

1.首先set()是对volatile变量的一个写操作, 我们知道volatile的write为了保证对其他线程的可见性会追加以下两个Fence(内存屏障) 

　　1)StoreStore // 在intel cpu中, 不存在[写写]重排序, 这个可以直接 省略了 

　　2)StoreLoad // 这个是所有内存屏障里最耗性能的

2.lazySet()省去了StoreLoad屏障, 只留下StoreStore 。

“可能是Mustang最后一次JSR166的后续跟进，
我们在Atomic类中添加了一个“lazySet”方法
（AtomicInteger，AtomicReference等）。这是一个利基
在使用微调代码时有时很有用的方法
非阻塞数据结构。语义是
保证写入不会被任何重新排序
上一次写入，但可以与后续操作重新排序
（或等效地，可能不会被其他线程看到）直到
发生一些其他易失性写入或同步动作）。

主要用例是将节点的字段归零
非阻塞数据结构仅仅是为了避免
长期垃圾焚烧; 它适用于无害的情况
如果其他线程暂时看到非空值，但是你可以
喜欢确保结构最终是GCable。
例如，你可以通过避免获得更好的性能
null volatile-write的成本。有几个
沿着这些行的其他用例非基于参考
原子也是如此，因此所有方法都支持该方法
AtomicX课程。

对于那些喜欢用这些操作来思考这些操作的人
常见多处理器的机器级障碍，lazySet
提供了一个先前的商店障碍（也是
在当前平台上没有操作或非常便宜），但没有
商店装载障碍（通常是昂贵的部分
一个易变的写）。“

所以这样一来，在效率上毫无疑问lazySet要比set高很多，可以这样理解，lazySet在intel cpu中，其实就可以看做普通变量的写操作了。

lazySet比set()具有性能优势，但是使用场景很有限。

 

weakCompareAndSet

基于Java8分析，在上述代码中，可以很明显的看到weakCompareAndSet方法和compareAndSet方法，具有相同的实现，但是为啥名字不同呢？ 
其实按照Doug Lea本来的设计意图，是想吧weakCompareAndSet设定为一种在性能上更加高效的方法。 
由于compareAndSet和其他读取并更新的操作，拥有相同的内存语义，即具有原子性。 
所以设计了weakCompareAndSet方法，在读上具有通用的原子性，但是写方面不具有volatile语义了，换而言之，weakCompareAndSet的写操作，不能即时被其他线程可见。 

updateAndGet和getAndAccumulate ，这两个方法是Java8新加入的，增加了函数式编程的运用。 
IntUnaryOperator：

@FunctionalInterface
public interface IntUnaryOperator {

    /**
     * 一个操作数的函数
     */
    int applyAsInt(int operand);

    //compose
    default IntUnaryOperator compose(IntUnaryOperator before) {
        Objects.requireNonNull(before);
        return (int v) -> applyAsInt(before.applyAsInt(v));
    }

    //andThen
    default IntUnaryOperator andThen(IntUnaryOperator after) {
        Objects.requireNonNull(after);
        return (int t) -> after.applyAsInt(applyAsInt(t));
    }

    //返回当前运算值
    static IntUnaryOperator identity() {
        return t -> t;
    }
}

IntBinaryOperator： 
IntBinaryOperator则更加简单，也是函数式的方法接口，就只有一个待实现方法：

@FunctionalInterface
public interface IntBinaryOperator {

    /**
     * @param left the first operand
     * @param right the second operand
     * @return the operator result
     */
    int applyAsInt(int left, int right);
}

 

AtomicLong注意之处

有些机器是32位的，所以会把64位long类型volatile拆分成2个32位进行计算，但有些不是的。所以在实现AtomicLong的时候，如果是32位，那就需要加上锁来实现CAS操作。JVM特别的还加了一个判断，来区分是32位：

/**
     * Records whether the underlying JVM supports lockless
     * compareAndSwap for longs. While the Unsafe.compareAndSwapLong
     * method works in either case, some constructions should be
     * handled at Java level to avoid locking user-visible locks.
     */
    static final boolean VM_SUPPORTS_LONG_CAS = VMSupportsCS8();

    /**
     * Returns whether underlying JVM supports lockless CompareAndSet
     * for longs. Called only once and cached in VM_SUPPORTS_LONG_CAS.
     */
    private static native boolean VMSupportsCS8();

 

AtomicBoolean注意之处

在AtomicBoolean中，作为volatile变量的，并不是boolean类型，而是一个int类型的0和1来分别表示false和true。

 private volatile int value;

    /**
     * Creates a new {@code AtomicBoolean} with the given initial value.
     *
     * @param initialValue the initial value
     */
    public AtomicBoolean(boolean initialValue) {
        value = initialValue ? 1 : 0;
    }