JAVA之原子操做原理

咱们在解决并发问题时，不少时候都用到java的java.util.concurrent.atomic包，那么其中原理是什么？

1、绪论

Java中原子操做是依赖于处理器实现的，处理器提供总线锁定和缓存锁定两个机制来保证复杂内存操做的原子性。

• 使用总线锁保证原子性。 所谓总线锁就是使用处理器提供的一个LOCK#信号，当一个处理器在总线上输出此信号时，其余处理器的请求将被阻塞住，那么该处理器能够独占共享内存。
• 使用缓存锁保证原子性。 所谓的缓存锁定是指内存区域若是被缓存在处理器的缓存行中，而且在Lock操做期间被锁定，那么当它执行锁操做回写到内存时，处理器不在总线上声言LOCK#信号，而是修改内部的内存地址，并容许它的缓存一致性机制来保证操做的原子性，由于缓存一致性机制会阻止同时修改两个以上处理器缓存的内存区域数据，当其余处理器回写已被锁定的缓存行的数据时，会使缓存行无效。

问题：为何要引入缓存锁定？ 由于在某些状况下，咱们须要保证对某个内存地址的操做是原子性便可，可是总线锁定把SPU和内存之间的通信锁住了，这使得锁按期间，其余处理器不能操做其余内存地址的数据，因此总线锁定的开销比较大，目前处理器在某些场合下使用缓存锁定代替总线锁定来进行优化。

2、Java实现原子操做介绍

在Java中能够经过锁和循环CAS的方式来实现原子操做。CAS原理在上一篇《JAVA之锁机制实现原理(简化版)》介绍偏向锁中有提到。

1.使用循环CAS实现原子操做。

下面来看一个基于CAS线程安全的计数器方法safeCount和非安全的计数器count的例子。

public class CasAtomicInteger {
    private int i = 0;
    private AtomicInteger atomicI = new AtomicInteger(0);
    public static void main(String[] args) {
        final CasAtomicInteger cas = new CasAtomicInteger();
        List<Thread> ts = new ArrayList<>(600);
        long start = System.currentTimeMillis();
        for (int j = 0; j < 100; j ++) {
            Thread t = new Thread(() -> {
                for (int i = 0; i < 10000; i ++) {
                    cas.count();
                    cas.safeCount();
                }
            });
            ts.add(t);
        }

        for (Thread t : ts) {
            t.start();
        }

        for (Thread t : ts) {
            try {
                t.join();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        System.out.println("非线程安全count计数器：" + cas.i);
        System.out.println("线程安全safeCount计数器：" + cas.atomicI.get());
        System.out.println(System.currentTimeMillis() - start);
    }

    /** * 使用CAS实现线程安全计数器 */
    private void safeCount() {
        for (;;) {
            int i = atomicI.get();
            boolean suc = atomicI.compareAndSet(i, ++i);
            if (suc) {
                break;
            }
        }
    }

    /** * 非线程安全计数器 */
    private void count() {
        i++;
    }
}
复制代码

数据结果：

非线程安全count计数器：998883
线程安全safeCount计数器：1000000
107
复制代码

显然，非线程安全count计数器少了计数。在此，咱们遇到相似的并发问题能够用到java的java.util.concurrent.atomic包里的工具解决。atomic包提供了一些原子操做，如AtomicBoolean(用原子方式更新的boolean值)、AtomicInteger(用原子方式更新的int值)、AtomicLong(用原子方式更新的long值)等。

二、浅谈CAS原子操做的三大问题

(1) ABA问题。 由于CAS须要在操做值的时候，检查值有没有发生变化，若是没有发生变化则更新，可是若是一个值原来是A，变成了B，又变回了A，那么使用CAS进行检查时会发现它的值没有变化，可是其实是变化了。

解决思路：使用版本号，每次变量更新的时候把版本号加1.从Java1.5开始，JDK的Atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法的做用是首先检查当前引用是否等于预期引用，而且检查当前标志是否等于预期标志，若是所有相等，则以原子方式将该引用和该标志的值设置为给定的更新值。

(2) 循环时间长开销大。 自旋CAS若是长时间不成功，会给CPU带来很是大的执行开销。若是JVM能支持处理器提供的pause指令，那么效率会有必定的提高。

pause指令有两个做用：第一，它能够延迟流水线执行指令(de-pipeline)，使CPU不会消耗过多的执行资源，延迟的时间取决于具体实现的版本，在一些处理器上延迟时间是零；第二，它能够避免在退出循环的时候因内存顺序冲突(Memory Order Violation)而引发CPU流水线被清空(CPU Pipeline Flush)，从而提升CPU的执行效率。

(3)只能保证一个共享变量的原子操做。 当对一个共享变量执行操做时，咱们可使用循环CAS的方式来保证原子操做，可是多个共享变量操做时，循环CAS就没法保证操做的原子性，这个时候就能够用锁。

参考：《Java 并发编程的艺术》 方腾飞，魏鹏，程晓明