什麼是原子操作？ 原子操作和資料庫的ACID有啥關係？ AtomicInteger是怎麼實現原子操作的？ AtomicInteger是有什麼缺點？ ...
問題
（1）什麼是原子操作？
（2）原子操作和資料庫的ACID有啥關係？
（3）AtomicInteger是怎麼實現原子操作的？
（4）AtomicInteger是有什麼缺點？
簡介
AtomicInteger是java併發包下麵提供的原子類，主要操作的是int類型的整型，通過調用底層Unsafe的CAS等方法實現原子操作。
還記得Unsafe嗎？點擊鏈接直達【死磕 java魔法類之Unsafe解析】
原子操作
原子操作是指不會被線程調度機制打斷的操作，這種操作一旦開始，就一直運行到結束，中間不會有任何線程上下文切換。
原子操作可以是一個步驟，也可以是多個操作步驟，但是其順序不可以被打亂，也不可以被切割而只執行其中的一部分，將整個操作視作一個整體是原子性的核心特征。
我們這裡說的原子操作與資料庫ACID中的原子性，筆者認為最大區別在於，資料庫中的原子性主要運用在事務中，一個事務之內的所有更新操作要麼都成功，要麼都失敗，事務是有回滾機制的，而我們這裡說的原子操作是沒有回滾的，這是最大的區別。
源碼分析
主要屬性
// 獲取Unsafe的實例
private static final Unsafe unsafe = Unsafe.getUnsafe();
// 標識value欄位的偏移量
private static final long valueOffset;
// 靜態代碼塊，通過unsafe獲取value的偏移量
static {
try {
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
// 存儲int類型值的地方，使用volatile修飾
private volatile int value;（1）使用int類型的value存儲值，且使用volatile修飾，volatile主要是保證可見性，即一個線程修改對另一個線程立即可見，主要的實現原理是記憶體屏障，這裡不展開來講，有興趣的可以自行查閱相關資料。
（2）調用Unsafe的objectFieldOffset()方法獲取value欄位在類中的偏移量，用於後面CAS操作時使用。
compareAndSet()方法
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
// Unsafe中的方法
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);調用Unsafe.compareAndSwapInt()方法實現，這個方法有四個參數：
（1）操作的對象；
（2）對象中欄位的偏移量；
（3）原來的值，即期望的值；
（4）要修改的值；
可以看到，這是一個native方法，底層是使用C/C++寫的，主要是調用CPU的CAS指令來實現，它能夠保證只有當對應偏移量處的欄位值是期望值時才更新，即類似下麵這樣的兩步操作：
if(value == expect) {
value = newValue;
}通過CPU的CAS指令可以保證這兩步操作是一個整體，也就不會出現多線程環境中可能比較的時候value值是a，而到真正賦值的時候value值可能已經變成b了的問題。
getAndIncrement()方法
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}
// Unsafe中的方法
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;
}getAndIncrement()方法底層是調用的Unsafe的getAndAddInt()方法，這個方法有三個參數：
（1）操作的對象；
（2）對象中欄位的偏移量；
（3）要增加的值；
查看Unsafe的getAndAddInt()方法的源碼，可以看到它是先獲取當前的值，然後再調用compareAndSwapInt()嘗試更新對應偏移量處的值，如果成功了就跳出迴圈，如果不成功就再重新嘗試，直到成功為止，這可不就是（CAS+自旋）的樂觀鎖機制麽^^
AtomicInteger中的其它方法幾乎都是類似的，最終會調用到Unsafe的compareAndSwapInt()來保證對value值更新的原子性。
總結
（1）AtomicInteger中維護了一個使用volatile修飾的變數value，保證可見性；
（2）AtomicInteger中的主要方法最終幾乎都會調用到Unsafe的compareAndSwapInt()方法保證對變數修改的原子性。
彩蛋
（1）為什麼需要AtomicInteger？
讓我們來看一個例子：
public class AtomicIntegerTest {
private static int count = 0;
public static void increment() {
count++;
}
public static void main(String[] args) {
IntStream.range(0, 100)
.forEach(i->
new Thread(()->IntStream.range(0, 1000)
.forEach(j->increment())).start());
// 這裡使用2或者1看自己的機器
// 我這裡是用run跑大於2才會退出迴圈
// 但是用debug跑大於1就會退出迴圈了
while (Thread.activeCount() > 1) {
// 讓出CPU
Thread.yield();
}
System.out.println(count);
}
}這裡起了100個線程，每個線程對count自增1000次，你會發現每次運行的結果都不一樣，但它們有個共同點就是都不到100000次，所以直接使用int是有問題的。
那麼，使用volatile能解決這個問題嗎？
private static volatile int count = 0;
public static void increment() {
count++;
}答案是很遺憾的，volatile無法解決這個問題，因為volatile僅有兩個作用：
（1）保證可見性，即一個線程對變數的修改另一個線程立即可見；
（2）禁止指令重排序；
這裡有個很重要的問題，count++實際上是兩步操作，第一步是獲取count的值，第二步是對它的值加1。
使用volatile是無法保證這兩步不被其它線程調度打斷的，所以無法保證原子性。
這就引出了我們今天講的AtomicInteger，它的自增調用的是Unsafe的CAS並使用自旋保證一定會成功，它可以保證兩步操作的原子性。
public class AtomicIntegerTest {
private static AtomicInteger count = new AtomicInteger(0);
public static void increment() {
count.incrementAndGet();
}
public static void main(String[] args) {
IntStream.range(0, 100)
.forEach(i->
new Thread(()->IntStream.range(0, 1000)
.forEach(j->increment())).start());
// 這裡使用2或者1看自己的機器
// 我這裡是用run跑大於2才會退出迴圈
// 但是用debug跑大於1就會退出迴圈了
while (Thread.activeCount() > 1) {
// 讓出CPU
Thread.yield();
}
System.out.println(count);
}
}這裡總是會列印出100000。
（2）說了那麼多，你知道AtomicInteger有什麼缺點嗎？
當然就是著名的ABA問題啦，我們下章接著聊^^
歡迎關註我的公眾號“彤哥讀源碼”，查看更多源碼系列文章, 與彤哥一起暢游源碼的海洋。
