java.util.concurrent.atomic.AtomicInteger 源码

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

类图：

源码：

package java.util.concurrent.atomic;

import java.util.function.IntUnaryOperator;
import java.util.function.IntBinaryOperator;
import sun.misc.Unsafe;


public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;//版本号

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

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

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

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

    /**
     * 构造方法，使用默认值0
     */
    public AtomicInteger() {
    }

    /**
     * 构造方法，传入指定int值
     */
    public AtomicInteger(int initialValue) {
        value = initialValue;
    }
    
    /**
     * 获取int值
     */
    public final int get() {
        return value;
    }

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

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

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

    /**
     * CAS操作，现代CPU已广泛支持，是一种原子操作；
     * 简单地说，当期待值expect与valueOffset地址处的值相等时，设置为update值
     */
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

    //和compareAndSet()方法相同
    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);
    }

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

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

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

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

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

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

    /**
     * 以原子方式设置为给定值，并返回新值
     * accumulatorFunction 两个参数的无副作用函数
     */
    public final int accumulateAndGet(int x, IntBinaryOperator accumulatorFunction) {
        int prev, next;
        do {
            prev = get();
            next = accumulatorFunction.applyAsInt(prev, x);
        } while (!compareAndSet(prev, next));
        return next;
    }

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

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

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

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

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

}

    对于使用到的unsafe类的方法，需要进行一些说明：
        lazySet(int newValue) ：直接调用native方法

public native void putOrderedInt(Object var1, long var2, int var4);

 
    compareAndSet(int expect, int update) ，weakCompareAndSet(int expect, int update)，

    getAndIncrement()，getAndDecrement()，getAndAdd(int delta)，

    incrementAndGet()，decrementAndGet()，addAndGet(int delta)：直接调用native方法

//var1对象的内存地址加上偏移量var2得到的value的值。如果该值等于期望值var4，则将value的内存地址上的值修改为var5，并返回true；不相等则不更新，直接返回false。
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

 
    getAndSet(int newValue):调用了unsafe类的getAndSetInt(Object var1, long var2, int var4) 

//在线程竞争激烈的时候，可能会导致多次重试，但最终可以保证更新操作一定能成功。
public final int getAndSetInt(Object var1, long var2, int var4) {
    int var5;
    do {
        var5 = this.getIntVolatile(var1, var2);//得到当前在对象var1偏移地址var2的值
    } while(!this.compareAndSwapInt(var1, var2, var5, var4));//再去读一次偏移地址对应的值和上次读的做比较：相同则更新为var4，不相同则不更新，然后继续循环重试。
    return var5;//返回最后一次读取的值
}

   此处，调用了getIntVolatile(Object var1, long var2) 和 compareAndSwapInt(Object var1, long var2, int var4, int var5)：

// 获取对象var1内存地址加上偏移量offset所对应的整型值（支持volatile，具有线程可见性）
public native int getIntVolatile(Object var1, long var2);

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