java.util.concurrent.atomic.AtomicLong 源码

2019独角兽企业重金招聘Python工程师标准>>>

类图：

源码： 

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 {
    private static final long serialVersionUID = 1927816293512124184L;//版本号

    private static final Unsafe unsafe = Unsafe.getUnsafe();//使用sun的Unsafe完成cas指令

    private static final long valueOffset;//value内存地址相对于对象内存地址的偏移量

    private volatile long value;//long的值,设为volatile,保证线程之间的可见性

    static final boolean VM_SUPPORTS_LONG_CAS = VMSupportsCS8();//记录JVM层面是否支持long类型CAS指令

    //返回JVM层面是否支持long类型的CAS指令.只调用一次,并将结果存放到VM_SUPPORTS_LONG_CAS之中
    private static native boolean VMSupportsCS8();

    static {
        try {
            //初始化valueOffset：通过unsafe.objectFieldOffset方法获取成员属性value内存地址相对于对象内存地址的偏移量
            valueOffset = unsafe.objectFieldOffset(AtomicLong.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    //构造方法:使用默认值0L
    public AtomicLong() {
    }

    /**
     * 构造方法，传入指定int值
     */
    public AtomicLong(long initialValue) {
        value = initialValue;
    }

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

    /**
     * 设为指定值
     */
    public final void set(long newValue) {
        value = newValue;
    }

    /**
     * 最终设为指定值，但其它线程不能马上看到变化，会延时一会
     */
    public final void lazySet(long newValue) {
        unsafe.putOrderedLong(this, valueOffset, newValue);
    }

    /**
     * 以原子方式设置为给定值，并返回旧值
     */
    public final long getAndSet(long newValue) {
        return unsafe.getAndSetLong(this, valueOffset, newValue);
    }

    /**
     * CAS操作，现代CPU已广泛支持，是一种原子操作；
     * 简单地说，当期待值expect与valueOffset地址处的值相等时，设置为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);
    }

    /**
     * 原子操作，自增，返回旧值
     */
    public final long getAndIncrement() {
        return unsafe.getAndAddLong(this, valueOffset, 1L);
    }

    /**
     * 原子操作，自减，返回旧值
     */
    public final long getAndDecrement() {
        return unsafe.getAndAddLong(this, valueOffset, -1L);
    }

    /**
     * 原子操作，加上一个数delta，返回旧值
     */
    public final long getAndAdd(long delta) {
        return unsafe.getAndAddLong(this, valueOffset, delta);
    }

    /**
     * 原子操作，加上一个数delta，返回新值
     */
    public final long addAndGet(long delta) {
        return unsafe.getAndAddLong(this, valueOffset, delta) + delta;
    }

    /**
     * 原子操作，自增，返回新值
     */
    public final long incrementAndGet() {
        return unsafe.getAndAddLong(this, valueOffset, 1L) + 1L;
    }

    /**
     * 原子操作，自减，返回新值
     */
    public final long decrementAndGet() {
        return unsafe.getAndAddLong(this, valueOffset, -1L) - 1L;
    }

    /**
     * 以原子方式设置为给定值，并返回旧值
     * updateFunction 一个参数的函数
     */
    public final long getAndUpdate(LongUnaryOperator updateFunction) {
        long prev, next;
        do {
            prev = get();
            next = updateFunction.applyAsLong(prev);
        } while (!compareAndSet(prev, next));
        return prev;
    }

    /**
     * 以原子方式设置为给定值，并返回新值
     * updateFunction 一个参数的函数
     */
    public final long updateAndGet(LongUnaryOperator updateFunction) {
        long prev, next;
        do {
            prev = get();
            next = updateFunction.applyAsLong(prev);
        } while (!compareAndSet(prev, next));
        return next;
    }

    /**
     * 以原子方式设置为给定值，并返回旧值
     * accumulatorFunction 两个参数的函数
     */
    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;
    }

    /**
     * 以原子方式设置为给定值，并返回新值
     * accumulatorFunction 两个参数的函数
     */
    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;
    }

    //得到value的string格式
    public String toString() {
        return Long.toString(get());
    }

    //得到value的int格式
    public int intValue() {
        return (int)get();
    }

    //得到value的long格式
    public long longValue() {
        return get();
    }

    //得到value的float格式
    public float floatValue() {
        return (float)get();
    }

    //得到value的double格式
    public double doubleValue() {
        return (double)get();
    }

}

 

转载于:https://my.oschina.net/langwanghuangshifu/blog/2879087