AtomicInteger实现计数器demo&原理分析

一. demo

先上一个demo：

public class AtomicDemo {

    public static void main(String[] args) {
        MyData myData = new MyData();
        for (int i = 1; i <= 20; i++) {
            new Thread(() -> {
                for (int j = 1; j <= 1000; j++) {
                    myData.addPlusPlus();
                    myData.addMyAtomic();
                }
            }).start();
        }
        //需要等new的20个线程执行结束
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println("非原子的++结果：" + myData.num);
        System.out.println("原子的++结果：" + myData.atomicInteger);
    }
}

class MyData {

    volatile int num = 0;
    AtomicInteger atomicInteger = new AtomicInteger();

    public void addPlusPlus() {
        num++;
    }

    public void addMyAtomic() {
        atomicInteger.getAndIncrement();
    }
}

执行结果：
非原子的++结果：17214
原子的++结果：20000

二. volatile

我们知道，volatile关键字不能用来做计数器，因为它只能保证两个特性：
1.可见性
2.禁止指令重排序
但并不能保证原子性，所以不能保证线程间的绝对同步；

可见性过程：
线程2、线程2两个线程开始都使用变量initFlag=false，但是线程2在执行后，将initFlag改为了true，但是线程1并不能实时感知到，除非变量initFlag使用了volatile关键字修饰。

未使用volatile关键字时如下：

由于线程1使用的是工作内存，因此即使线程2把修改后的变量值写到主内存，线程1也感觉不到新值。

使用volatile关键字后如下：

使用volatile关键字后，总线会开启MESI缓存一致性协议，同时cpu开启总线嗅探机制，因此，当线程1把修改后的值写入主内存经过总线时，就会别cpu感知到，进而使线程1工作内存中的变量失效，那么线程1就只能去主内存取值，也就取到了新值。

其中，read、load、use、assign、store、write、lock、unlock 都是JMM数据原子操作。

三. AtomicInteger

i++操作是非原子性的，实际分为3步，在多线程环境下，就会出现线程不安全。

这个时候，java juc包下的原子AtomicInteger就可以发挥作用了；

下面简单看下AtomicInteger如何保证原子性的，就拿getAndIncrement自增方法看：

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

我们看到调用了unsafe对象的getAndAddInt；那么unsafe是什么呢？

private static final Unsafe unsafe = Unsafe.getUnsafe();

Unsafe是本地方法类，方法被native关键字修饰，可以理解为是操作系统层面的汇编语言，
上面这个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;
    }

此方法有3个参数：
1.Object var：传入的是this，也就是AtomicInteger本身；
2.long var2：我们传入了valueOffset，表示内存地址偏移量；通过它，unsafe可以直接获取到主内存中的value值；
3.int var4：每次增加的数目，这里是自增1，所以参数是1；

通过前两个参数var1，var2， var5 = this.getIntVolatile(var1, var2); //获取主内存的当前值，
比如现在值是3了， 然后while中，
this.compareAndSwapInt(var1, var2, var5, var5 + var4)比较关键，这是cas（比较并交换）原理的的实现，这个方法是操作系统层面，能保证原子性，被native修饰。

通过前两个参数，再次取出内存中的值，和第3个期望参数var5比较，如果一样，那么 var5 + var4，也就是3+1,；如果不一样，比如这个初始值3已经被别的线程改为5了，那么通过while自旋，再次取到5，然后5+1，如果还不一样，继续自旋；
这样就保证了技术操作的准确性，不会像i++那样丢失值。