原子操作

原子性就是指該操作是不可再分的。不論是多核還是單核，具有原子性的量，同一時刻只能有一個執行緒來對它進行操作。
原子操作可以是一個步驟，也可以是多個步驟，但是其順序不可以被打亂，也不可以被切割而只執行其中的一部分（不可中斷性）。
將操作視作一個整體，資源在該次操作中保持一致，這是原子性的核心特徵。

首先我們來看一個非原子操作的示例：

public class Counter {

  volatile int i = 0;

  public void increament() {
    i++;
  }
}

測試程式碼：

public class CouterTest {

  public static void main(String[] args) throws InterruptedException {
    final Counter counter = new Counter();
    for (int i = 0; i < 6; i++) {
      new Thread(
              new Runnable() {
                @Override
                public void run() {
                  for (int j = 0; j < 10000; j++) {
                    counter.increament();
                  }
                  System.out.println("done...");
                }
              })
          .start();
    }
    Thread.sleep(6000L);
    System.out.println(counter.i);
  }
}
 

正確情況下以上測試程式碼我們啟動了6個執行緒每個增加10000，結果輸出應該是60000，但實際結果卻是小於60000的，其原因就在於i++並不是原子的操作，通過反編譯我們可以知道它實際上在JVM執行時是4個指令。

那麼如何才能讓以上程式碼正確執行那？

1. 通過加鎖的形式，可以是synchronized加鎖，也可以是ReentrantLock加鎖. 這種方式是通過加鎖的方式使其變成序列的單執行緒操作，效果不是太高。

syncchronized 加鎖程式碼示例：

public class Counter {

  volatile int i = 0;

  public synchronized void increament() {
    i++;
  }
}
 

ReentrantLock加鎖程式碼示例:

public class Counter {

  volatile int i = 0;

  Lock lock = new ReentrantLock();

  public void increament() {
    lock.lock();
    i++;
    lock.unlock();
  }
}

1. 通過JDK提供的原子操作的API中的AtomicInteger，這種方式其底層是通過CAS操作，仍是使用多執行緒進行，所以效率會相對較高。

AtomicInteger程式碼示例:

public class Counter {

  AtomicInteger i= new AtomicInteger();

  public void increament() {
    i.incrementAndGet();
  }
}
 

CAS（Compare and swap）

Compare and swap 比較和交換，屬於硬體同步原語，處理器提供了基本記憶體操作的原子性保證。
CAS 操作包含三個運算元—記憶體位置(V),預期原值(A)和新值(B)。 如果記憶體位置的值與預期原值相匹配，那麼處理器會自動將該位置值交換成新值，如果不匹配，即記憶體位置的值了變化則不做交換。
Java中的sun.misc.Unsafe類提供了compareAndSwapInt和compareAndSwapLong等幾個方法實現CAS, 其程式碼示例如下：

// JDK提供的原子操作API其原理基本如此
public class CounterUnsafe {

  volatile int i = 0;

  private static Unsafe unsafe = null;

  // i欄位地址偏移量
  private static long valueOffset;

  static {
    //    unsafe = Unsafe.getUnsafe();  該方式並不可用
    try {
      Field field = Unsafe.class.getDeclaredField("theUnsafe");
      field.setAccessible(true);
      unsafe = (Unsafe) field.get(null);

      Field fieldi = CounterUnsafe.class.getDeclaredField("i");
      // 獲取欄位i的地址偏移量
      valueOffset = unsafe.objectFieldOffset(fieldi);

    } catch (NoSuchFieldException | IllegalAccessException e) {
      e.printStackTrace();
    }
  }

  public void increament() {
    for (; ; ) {
      int current = unsafe.getIntVolatile(this, valueOffset);
      // 如果成功則返回true，跳出迴圈，如果失敗返回false, 將進行自旋（就是for迴圈）
      if (unsafe.compareAndSwapInt(this, valueOffset, current, current + 1)) break;
    }
  }
}

JDK提供的原子操作類簡介：

CAS的三大問題

• 迴圈+CAS，自旋的實現讓所有執行緒都處於高頻執行，爭搶CPU執行時間的狀態。如果操作長時間不成功，會帶來很大的CPU資源消耗
• 僅針對單個變數的操作，不能用於多個變數來實現原子操作
• ABA問題

ABA問題