转载

JAVA之原子操作原理

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

一、绪论

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

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

问题：为什么要引入缓存锁定？
因为在某些情况下，我们需要保证对某个内存地址的操作是原子性即可，但是总线锁定把SPU和内存之间的通讯锁住了，这使得锁定期间，其他处理器不能操作其他内存地址的数据，所以总线锁定的开销比较大，目前处理器在某些场合下使用缓存锁定代替总线锁定来进行优化。
复制代码

二、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值)等。

2、浅谈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 并发编程的艺术》方腾飞，魏鹏，程晓明

原文 https://juejin.im/post/5d0dac7c5188253298401919

正文到此结束