原子操作的实现及其源码分析

原子操作的实现原理

原子（atomic）本意是“不能被进一步分割的最小粒子”，而原子操作（atomic operation）意为“不可被中断的一个或一系列操作”。在多处理器上实现原子操作就变得有点复杂。让我们一起来聊一聊在Intel处理器和Java里是如何实现原子操作的。

1 如何实现原子操作

1. 使用总线锁保证原子性

   举个栗子：如果i=1，我们进行两次 i++ 操作，我们期望的结果是3，但是有可能结果是2

   

   处理器使用总线锁就是来解决这个问题的。

   当一个处理器在总线上输出此信号时，其他处理器的请求将被阻塞住，那么该处理器可以独占共享内存。

   缺点：总线锁定把CPU和内存之间的通信锁住了，这使得锁定期间，其他处理器不能操作其他内存地址的数据，所以总线锁定的开销比较大

2. 使用缓存锁保证原子性

   “缓存锁定”是指内存区域如果被缓存在处理器的缓存行中，并且在Lock操作期间被锁定，那么当它执行锁操作回写到内存时，处理器不在总线上声言LOCK＃信号，而是修改内部的内存地址，并允许它的缓存一致性机制来保证操作的原子性

   两种情况下处理器不会使用缓存锁定:

   • 当操作的数据不能被缓存在处理器内部，或操作的数据跨多个缓存行->总线锁定
   • 处理器不支持缓存锁定

2 Java如何实现原子操作

以下代码实现了一个基于 CAS 线程安全的计数器方法safeCount和一个非线程安全的计数器count。

public class CASTest {
    private AtomicInteger atomicI = new AtomicInteger(0);
    private int i = 0;

    public static void main(String[] args) throws InterruptedException {
        final CASTest cas = new CASTest();
        List<Thread> ts = new ArrayList<Thread>(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 (InterruptedException e) {
                e.printStackTrace();
            }
        }
//        TimeUnit.SECONDS.sleep(1);
        System.out.println(cas.i);
        System.out.println(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;
            }
        }
        int i = atomicI.addAndGet(1);
    }
    /**
     * 非线程安全计数器
     */
    private void count() {
        i++;
    }
}

Output:

964857
2000000
219

2.1 CAS 实现原子操作的三大问题

• ABA问题:

  如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化.

  解决方案：

  JDK的Atomic包里提供了一个类 AtomicStampedReference 来解决ABA问题

  源码分析：

  public boolean compareAndSet(
      V expectedReference, // 预期引用
      V newReference, // 更新后的引用
      int expectedStamp, // 预期标志
      int newStamp // 更新后的标志
  )
  

• 循环时间长开销大：

  自旋 CAS 如果长时间不成功，会给CPU带来非常大的执行开销

• 只能保证一个共享变量的原子操作：

  我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁。

  解决方案：

  JDK提供了AtomicReference类来保证引用对象之间的原子性，就可以把多个变量放在一个对象里来进行CAS操作。

  源码分析：

  public class AtomicReference<V> implements java.io.Serializable {
      // 可以看出 value值可以为任意类型
      private volatile V value;
       /**
       * Atomically updates the current value with the results of
       * applying the given function to the current and given values,
       * returning the previous value. The function should be
       * side-effect-free, since it may be re-applied when attempted
       * updates fail due to contention among threads.  The function
       * is applied with the current value as its first argument,
       * and the given update as the second argument.
       *
       * @param x the update value
       * @param accumulatorFunction a side-effect-free function of two arguments
       * @return the previous value
       * @since 1.8
       */
      public final V getAndAccumulate(V x,
                                      BinaryOperator<V> accumulatorFunction) {
          V prev, next;
          do {
              prev = get();
              next = accumulatorFunction.apply(prev, x);
          } while (!compareAndSet(prev, next));
          return prev;
      }
  }
  

2.2 使用锁机制实现原子操作

锁机制保证了只有获得锁的线程才能够操作锁定的内存区域。

JVM内部实现了很多种锁机制，有偏向锁、轻量级锁和互斥锁。有意思的是除了偏向锁，JVM实现锁的方式都用了循环CAS，即当一个线程想进入同步块的时候使用循环CAS的方式来获取锁，当它退出同步块的时候使用循环CAS释放锁。

3 源码分析 ----- AtomicInteger

J.U.C 包里面的整数原子类 AtomicInteger 的方法调用了 Unsafe 类的 CAS 操作。

/**
	 * Atomically sets to the given value and returns the old value.
     *
     * @param newValue the new value
     * @return the previous value
     */
public final int getAndSet(int newValue) {
    return unsafe.getAndSetInt(this, valueOffset, newValue);
}

我们继续深入，看看getAndSetInt是怎么实现的？

public final int getAndSetInt(Object var1, long var2, int var4) {
    // var1为起始位置，var2为偏移量，通过v1，v2可以找到内存中的int值
    int var5;
    do {
        // 获取内存中的值
        var5 = this.getIntVolatile(var1, var2);
        // 当 当前内存中的值与var5相同时，才进行swap操作
    } while(!this.compareAndSwapInt(var1, var2, var5, var4));

    return var5;
}