多线程系列学习：AtomicInteger

在 java.util.concurrent.atomic 包下，有很多原子类，这种原子类的出现，解决了多线程环境下，诸如：i++等非原子操作的线程安全问题，包括的类如下：

 

下面以AtomicInteger为例了解其使用及基本原理，先看下类定义及相关说明：

根据注释说明，可以大概知道，AtomicInteger主要用来解决类似于自动递增的计数问题，它并不能替代Integer类。注意到，它有一个成员属性 value，并且是用volatile修饰的，从而保证了可见性。

 

首先来看下，不使用AtomicInteger来实现的计数功能：

创建一个类，实现一个计数功能，使用volatile保证线程间的可见性：

    static class UnAtomic{
        private volatile int num = 0;

        public void increment(){
            num++;
        }

        public int getNum(){
            return num;
        }
    }

测试代码，创建3个线程，每个线程循环1000次：

    public static void main(String[] args) {
        UnAtomic unAtomic = new UnAtomic();
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    unAtomic.increment();
                }
            }).start();
        }
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(unAtomic.getNum());
    }

测试结果如下：

测试结果显示，最后的结果并不是3000，而是比3000小，原因在于i++是非原子操作，每个线程都有自己的工作空间，包括了以下几个步骤：

1. 从主内存中读取i的值到本线程的工作空间，作为副本，假设此时i=0
2. 读取本线程的i，执行+1操作，那么i+1=1
3. 将+1后的值，赋值给本线程的i，此时i = 1
4. 再将本线程的i值写回主内存中

那么，在这一系列的操作过程中，就有可能出现问题，比如，线程1执行完了+1操作，但是还没有将新值写回主内存，此时线程2执行了+1操作，并且将新值写回了主内存，这样两次+1操作，后者就会覆盖前者。这样就产生了线程安全问题，解决方法是可以在+1操作的过程加锁，或者使用Atomic类。

 

使用Atomicinteger实现计数功能：

测试类：

    static class AtomicTest{
        private AtomicInteger num = new AtomicInteger();

        public void increment(){
            // 相当于 num++
            num.getAndIncrement();
        }

        public int getNum(){
            return num.get();
        }
    }

测试代码：

    public static void main(String[] args) {
        AtomicTest atomicTest = new AtomicTest();

        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    atomicTest.increment();
                }
            }).start();
        }
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(atomicTest.getNum());
    }

测试结果：

 

可以看到，结果是符合预期的，那么，它是怎么实现的呢？注意这一句代码：

            // 相当于 num++
            num.getAndIncrement();

我们跟进去，发现它调用了unsafe的getAndAddInt方法：

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

unsafe的getAndAddInt方法的实现：

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

而compareAndSwapInt是一个native方法：

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

这个方法就是CAS的简称，比较并交换，它的基本原理如下：

var1是当前AtomicInteger对象，var2是期待的值，个人理解，可以看作是第一次读取的值，var4是刚读取的内存值，可以看作是第二次读取的值，var5是新值，那么：

只有当两次读取的值相等时，才会更新AtomicInteger的值为新值，也就是：var2 == var4，才会执行更新操作，这样做的好处是，在我第一次读取和第二次读取之间，没有其他线程修改它，如果不符合条件，就会一直循环执行。那么，这里其实也是存在问题的，如果很多线程要修改的话，那就会循环很久，性能上也并不是那么好。