Java多线程之JUC原子类AtomicLong

1、AtomicLong的介绍

    咱们都知道在java中long类型变量占用的字节数是8也就是64位，而在32位的操做系统对64位的数据读写要分红两步完成，每一步取32位操做。这样的话JVM就不能保证对long和double赋值操做的原子性，由于多线程环境下有可能出现这样一种状况，两个线程同时写一个多线程共享变量(主内存)一个写低32位而另外一个线程高32位或者一个线程在两步写中间过程当中穿插了另外一个线程的两步写操做，这样就有可能致使用户获取的64位long变量是是无效的脏数据。咱们有两种方法来解决此类现象：第1种，使用volatile修饰long变量有的同窗很奇怪volatile不是只保证变量多线程修改的可见性和字节码指令重排的局部有序性吗，注意java内存模型为咱们保证了声明为volatile的long类型变量的赋值和获取操做是原子操做；第2种方式就是本文要讲的直接使用JUC(java.util.current包)提供的原子类AtomicLong保证长整形操做的原子性。

2、AtomicLong的数据结构

1 - 继承结构

package java.util.concurrent.atomic;
import java.util.function.LongUnaryOperator;
import java.util.function.LongBinaryOperator;
import sun.misc.Unsafe;

public class AtomicLong extends Number implements java.io.Serializable

    

2 - 类成员变量

private static final long serialVersionUID = 1927816293512124184L;

    //Unsafe类提供了硬件级别的原子操做，经过它的compareAndSwapLong方法对long变量进行原子更新
    private static final Unsafe unsafe = Unsafe.getUnsafe();

    //我的理解valueOffset保存的信息相似AtomicLong内部long值的当前版本号，由于AtomicLong支持延后更新当前值不见得
    //就是最新值，Unsafe进行cas操做时经过valueOffset去获取最近一次更新后的long值
    private static final long valueOffset;

    //标识当前JVM所在的操做系统是否支持long变量操做的原子性，其实个人理解就是判断当前操做系统是否支持对8字节也就是64
    //位数据的操做原子性，再简单点就是判断该操做系统是32位的仍是64位的
    static final boolean VM_SUPPORTS_LONG_CAS = VMSupportsCS8();

    private static native boolean VMSupportsCS8();

    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicLong.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    //存储的long类型数据使用volatile修饰保证它修改的多线程可见性
    private volatile long value;

3、AtomicLong的源码分析

1 - 构造方法

public AtomicLong(long initialValue) {
        value = initialValue;
    }

    public AtomicLong() {
    }

    两个构造方法没什么可说的一个带初始值初始化value一个不带初始值（value默认初始化为0）

2 - 其余成员方法

//获取当前值
    public final long get() {
        return value;
    }

    //设置当前值为newValue，该操做是原子操做，为啥参考前面
    public final void set(long newValue) {
        value = newValue;
    }

    //延时设置当前变量为新值newValue,这个方法区别于set方法的点在于它在后台修改值且不等待修改完成当即返回，若是程序
    //不须要当即获取更新后的值那么使用这个方法性能会好点
    public final void lazySet(long newValue) {
        unsafe.putOrderedLong(this, valueOffset, newValue);
    }

    //以原子操做方式更新当前值为newValue返回旧值
    public final long getAndSet(long newValue) {
        return unsafe.getAndSetLong(this, valueOffset, newValue);
    }

    //若是当前值等于预期值expect，则以原子方式基于无锁cas将当前值更新为update
    public final boolean compareAndSet(long expect, long update) {
        return unsafe.compareAndSwapLong(this, valueOffset, expect, update);
    }

    //坑爹挂羊头卖狗肉，实现和接口定义不一致，做用和compareAndSet等同
    public final boolean weakCompareAndSet(long expect, long update) {
        return unsafe.compareAndSwapLong(this, valueOffset, expect, update);
    }

    //以原子方式将当前值+1，返回递增以后的值
    public final long getAndIncrement() {
        return unsafe.getAndAddLong(this, valueOffset, 1L);
    }

    //以原子方法将当前值-1，返回递减以后的值
    public final long getAndDecrement() {
        return unsafe.getAndAddLong(this, valueOffset, -1L);
    }

    //以原子方式将当前值+delta返回相加前的值
    public final long getAndAdd(long delta) {
        return unsafe.getAndAddLong(this, valueOffset, delta);
    }

    //以原子方式将当前值+1，并返回递增后的值
    public final long incrementAndGet() {
        return unsafe.getAndAddLong(this, valueOffset, 1L) + 1L;
    }

    //以原子方法递减并返回递减后的值
    public final long decrementAndGet() {
        return unsafe.getAndAddLong(this, valueOffset, -1L) - 1L;
    }

    //以原子方式增长指定的值delta并返回相加后的值
    public final long addAndGet(long delta) {
        return unsafe.getAndAddLong(this, valueOffset, delta) + delta;
    }

    //jdk1.8新提供的方法，应用指定函数updateFunction以原子方式更新当前值
    public final long getAndUpdate(LongUnaryOperator updateFunction) {
        long prev, next;
        do {
            prev = get();
            next = updateFunction.applyAsLong(prev);
        } while (!compareAndSet(prev, next));
        return prev;
    }

    //jdk1.8新提供方法，以原子方式应用单元运算更新当前值，返回更新以后的值
    public final long updateAndGet(LongUnaryOperator updateFunction) {
        long prev, next;
        do {
            prev = get();
            next = updateFunction.applyAsLong(prev);
        } while (!compareAndSet(prev, next));
        return next;
    }

    //jdk1.8新提供方法，以原子方式应用一个双元(当前值和x)运算函数完成当前值更新，返回更新前的值
    public final long getAndAccumulate(long x,
                                       LongBinaryOperator accumulatorFunction) {
        long prev, next;
        do {
            prev = get();
            next = accumulatorFunction.applyAsLong(prev, x);
        } while (!compareAndSet(prev, next));
        return prev;
    }

    //jdk1.8新提供方法，以原子方式应用一个双元(当前值和x)运算函数完成当前值更新，返回更新后的值
    public final long accumulateAndGet(long x,
                                       LongBinaryOperator accumulatorFunction) {
        long prev, next;
        do {
            prev = get();
            next = accumulatorFunction.applyAsLong(prev, x);
        } while (!compareAndSet(prev, next));
        return next;
    }

    //字符串形式
    public String toString() {
        return Long.toString(get());
    }

    //当前值转long
    public int intValue() {
        return (int)get();
    }

    //获取当前最新值，一个反作用是能够阻塞等待AtomicLong后台更新操做完成
    public long longValue() {
        return get();
    }

    //当前值转float
    public float floatValue() {
        return (float)get();
    }

    //当前值转double
    public double doubleValue() {
        return (double)get();
    }

    下面咱们选取incrementAndGet方法进行分析了解下AtomicLong实现long变量操做原子性的原理。

incrementAndGet方法

    incrementAndGet方法以原子方式将当前值加1，返回递增后的值，下面是该方法的源码：

public final long incrementAndGet() {
        return unsafe.getAndAddLong(this, valueOffset, 1L) + 1L;
    }

    分析源码可知方法内部经过调用unsafe.getAndAddLong(this,valueOffset,1L)+1L实现对long的原子加减和返回，下面咱们进入Unsafe类的getAndAddLong方法源码；

public final long getAndAddLong(Object var1, long var2, long var4) {
        long var6;
        do {
            var6 = this.getLongVolatile(var1, var2);
        } while(!this.compareAndSwapLong(var1, var2, var6, var6 + var4));

        return var6;
    }

    分析这段代码咱们知道，Unsafe基本就是采用循环+cas的方式保证AtomicLong的原子操做。在方法里面首先在一个循环里面根据传入的AtomicLong对象和它指定的版本号valueOffset去获取对应版本的long值，而后与当前最新版本号进行比较，若是版本号相等那么AtomicLong的value+1，返回AtomicLong更新前的volatile value，所以方法unsafe.getAndAddLong(this, valueOffset, 1L)+1就是一个volatile修饰的long类型变量+1也是原子性操做且线程安全。