死磕 java并发包之AtomicInteger源码分析

问题

（1）什么是原子操做？

（2）原子操做和数据库的ACID有啥关系？

（3）AtomicInteger是怎么实现原子操做的？

（4）AtomicInteger是有什么缺点？

简介

AtomicInteger是java并发包下面提供的原子类，主要操做的是int类型的整型，经过调用底层Unsafe的CAS等方法实现原子操做。

还记得Unsafe吗？点击连接直达【死磕 java魔法类之Unsafe解析】

原子操做

原子操做是指不会被线程调度机制打断的操做，这种操做一旦开始，就一直运行到结束，中间不会有任何线程上下文切换。

原子操做能够是一个步骤，也能够是多个操做步骤，可是其顺序不能够被打乱，也不能够被切割而只执行其中的一部分，将整个操做视做一个总体是原子性的核心特征。

咱们这里说的原子操做与数据库ACID中的原子性，笔者认为最大区别在于，数据库中的原子性主要运用在事务中，一个事务以内的全部更新操做要么都成功，要么都失败，事务是有回滚机制的，而咱们这里说的原子操做是没有回滚的，这是最大的区别。

源码分析

主要属性

// 获取Unsafe的实例
private static final Unsafe unsafe = Unsafe.getUnsafe();
// 标识value字段的偏移量
private static final long valueOffset;
// 静态代码块，经过unsafe获取value的偏移量
static {
    try {
        valueOffset = unsafe.objectFieldOffset
            (AtomicInteger.class.getDeclaredField("value"));
    } catch (Exception ex) { throw new Error(ex); }
}
// 存储int类型值的地方，使用volatile修饰
private volatile int value;

（1）使用int类型的value存储值，且使用volatile修饰，volatile主要是保证可见性，即一个线程修改对另外一个线程当即可见，主要的实现原理是内存屏障，这里不展开来说，有兴趣的能够自行查阅相关资料。

（2）调用Unsafe的objectFieldOffset()方法获取value字段在类中的偏移量，用于后面CAS操做时使用。

compareAndSet()方法

public final boolean compareAndSet(int expect, int update) {
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
// Unsafe中的方法
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

调用Unsafe.compareAndSwapInt()方法实现，这个方法有四个参数：

（1）操做的对象；

（2）对象中字段的偏移量；

（3）原来的值，即指望的值；

（4）要修改的值；

能够看到，这是一个native方法，底层是使用C/C++写的，主要是调用CPU的CAS指令来实现，它可以保证只有当对应偏移量处的字段值是指望值时才更新，即相似下面这样的两步操做：

if(value == expect) {
    value = newValue;
}

经过CPU的CAS指令能够保证这两步操做是一个总体，也就不会出现多线程环境中可能比较的时候value值是a，而到真正赋值的时候value值可能已经变成b了的问题。

getAndIncrement()方法

public final int getAndIncrement() {
    return unsafe.getAndAddInt(this, valueOffset, 1);
}

// Unsafe中的方法
public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

    return var5;
}

getAndIncrement()方法底层是调用的Unsafe的getAndAddInt()方法，这个方法有三个参数：

（1）操做的对象；

（2）对象中字段的偏移量；

（3）要增长的值；

查看Unsafe的getAndAddInt()方法的源码，能够看到它是先获取当前的值，而后再调用compareAndSwapInt()尝试更新对应偏移量处的值，若是成功了就跳出循环，若是不成功就再从新尝试，直到成功为止，这可不就是（CAS+自旋）的乐观锁机制么^^

AtomicInteger中的其它方法几乎都是相似的，最终会调用到Unsafe的compareAndSwapInt()来保证对value值更新的原子性。

总结

（1）AtomicInteger中维护了一个使用volatile修饰的变量value，保证可见性；

（2）AtomicInteger中的主要方法最终几乎都会调用到Unsafe的compareAndSwapInt()方法保证对变量修改的原子性。

彩蛋

（1）为何须要AtomicInteger？

让咱们来看一个例子：

public class AtomicIntegerTest {
    private static int count = 0;

    public static void increment() {
        count++;
    }

    public static void main(String[] args) {
        IntStream.range(0, 100)
                .forEach(i->
                        new Thread(()->IntStream.range(0, 1000)
                                .forEach(j->increment())).start());

        // 这里使用2或者1看本身的机器
        // 我这里是用run跑大于2才会退出循环
        // 可是用debug跑大于1就会退出循环了
        while (Thread.activeCount() > 1) {
            // 让出CPU
            Thread.yield();
        }

        System.out.println(count);
    }
}

这里起了100个线程，每一个线程对count自增1000次，你会发现每次运行的结果都不同，但它们有个共同点就是都不到100000次，因此直接使用int是有问题的。

那么，使用volatile能解决这个问题吗？

private static volatile int count = 0;

public static void increment() {
    count++;
}

答案是很遗憾的，volatile没法解决这个问题，由于volatile仅有两个做用：

（1）保证可见性，即一个线程对变量的修改另外一个线程当即可见；

（2）禁止指令重排序；

这里有个很重要的问题，count++其实是两步操做，第一步是获取count的值，第二步是对它的值加1。

使用volatile是没法保证这两步不被其它线程调度打断的，因此没法保证原子性。

这就引出了咱们今天讲的AtomicInteger，它的自增调用的是Unsafe的CAS并使用自旋保证必定会成功，它能够保证两步操做的原子性。

public class AtomicIntegerTest {
    private static AtomicInteger count = new AtomicInteger(0);

    public static void increment() {
        count.incrementAndGet();
    }

    public static void main(String[] args) {
        IntStream.range(0, 100)
                .forEach(i->
                        new Thread(()->IntStream.range(0, 1000)
                                .forEach(j->increment())).start());

        // 这里使用2或者1看本身的机器
        // 我这里是用run跑大于2才会退出循环
        // 可是用debug跑大于1就会退出循环了
        while (Thread.activeCount() > 1) {
            // 让出CPU
            Thread.yield();
        }

        System.out.println(count);
    }
}

这里老是会打印出100000。

（2）说了那么多，你知道AtomicInteger有什么缺点吗？

固然就是著名的ABA问题啦，咱们下章接着聊^^

---

欢迎关注个人公众号“彤哥读源码”，查看更多源码系列文章, 与彤哥一块儿畅游源码的海洋。