原子操作类AtomicInteger学习

为什么需要AtomicInteger原子操作类？

很多时候我们都用到 num++，若没有加synchronized关键字则是线程不安全的，num++解析为num=num+1，明显，这个操作不具备原子性，多线程时必然会出现问题，测试下：

public class AtomicIntegerTest {

    public static int num = 0;

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(){
                @Override
                public void run(){
                    for (int j = 0; j < 100; j++) {
                        System.out.println(num++);
                    }
                }
            }.start();
        }
    }
}

结果： 

这个值不定，每次测试都可能不一样，很显然，100个线程跑++操作，结果并没有像预期的那样num: 9999。

 

用了AtomicInteger类后会变成什么样子呢？

 

public class AtomicIntegerTest {
    
    public static void main(String[] args) {
        //从内部类中访问本地变量num; 需要被声明为最终类型
        final AtomicInteger num = new AtomicInteger();
        for (int i = 0; i < 100; i++) {
            new Thread(){
                @Override
                public void run(){
                    for (int j = 0; j < 100; j++) {
                        System.out.println(num.getAndIncrement());
                    }
                }
            }.start();
        }
    }
}

结果：

 没有失望，测试多次都是这个结果

学着其他大佬看看源码，虽然看的懵懵懂懂，多看看总是好的

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();
    private static final long valueOffset;

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

    private volatile int value;

    public AtomicInteger(int initialValue) {
        value = initialValue;
    }

   
    public AtomicInteger() {
    }

  
    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);
    }

    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

    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);
    }

    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;
    }

   
    public final int addAndGet(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
    }

  
    public final int getAndUpdate(IntUnaryOperator updateFunction) {
        int prev, next;
        do {
            prev = get();
            next = updateFunction.applyAsInt(prev);
        } while (!compareAndSet(prev, next));
        return prev;
    }

    public final int updateAndGet(IntUnaryOperator updateFunction) {
        int prev, next;
        do {
            prev = get();
            next = updateFunction.applyAsInt(prev);
        } while (!compareAndSet(prev, next));
        return next;
    }

    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;
    }

    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;
    }

   
    public String toString() {
        return Integer.toString(get());
    }

    public int intValue() {
        return get();
    }

    public long longValue() {
        return (long)get();
    }

   
    public float floatValue() {
        return (float)get();
    }

   
    public double doubleValue() {
        return (double)get();
    }

}

Value的定义和volatile

AtomicInteger 本身是个整型，所以最重要的属性就是value，我们看看它是如何声明value的

 private volatile int value;

使用了volatile修饰，看到这个，对于我这个小菜来说，啥啊这是

通过了解知道，volatile相当于synchronized的弱实现，也就是说volatile实现了类似synchronized的语义，却又没有锁机制。它确保对volatile字段的更新以可预见的方式告知其他的线程。这样，当一个线程修改了这个值后，其他线程可以读取到修改后的值

用CAS（Compare and Swap）操作实现安全的自增

看下incrementAndGet（）是如何实现的

public final int incrementAndGet() {
        for (;;) {
            int current = get();
            int next = current + 1;
            if (compareAndSet(current, next))
                return next;
        }
    }

 public final boolean compareAndSet(int expect, int update) {
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
 }

AtomicInteger 中的CAS操作就是compareAndSet()，其作用是每次从内存中根据内存偏移量（valueOffset）取出数据，将取出的值跟expect 比较，如果数据一致就把内存中的值改为update，这样使用CAS就保证了原子操作。

总结

总结一下，AtomicInteger 中主要实现了整型的原子操作，防止并发情况下出现异常结果，其内部主要依靠JDK 中的unsafe 类操作内存中的数据来实现的。volatile 修饰符保证了value在内存中其他线程可以看到其值得改变。CAS操作保证了AtomicInteger 可以安全的修改value 的值。

 

原文地址 原文地址