問題

（1）什么是原子操作？

（2）原子操作和數(shù)據(jù)庫(kù)的ACID有啥關(guān)系？

（3）AtomicInteger是怎么實(shí)現(xiàn)原子操作的？

（4）AtomicInteger是有什么缺點(diǎn)？

簡(jiǎn)介

AtomicInteger是java并發(fā)包下面提供的原子類，主要操作的是int類型的整型，通過調(diào)用底層Unsafe的CAS等方法實(shí)現(xiàn)原子操作。

還記得Unsafe嗎？點(diǎn)擊鏈接直達(dá)【java Unsafe詳細(xì)解析】

原子操作

原子操作是指不會(huì)被線程調(diào)度機(jī)制打斷的操作，這種操作一旦開始，就一直運(yùn)行到結(jié)束，中間不會(huì)有任何線程上下文切換。

原子操作可以是一個(gè)步驟，也可以是多個(gè)操作步驟，但是其順序不可以被打亂，也不可以被切割而只執(zhí)行其中的一部分，將整個(gè)操作視作一個(gè)整體是原子性的核心特征。

我們這里說的原子操作與數(shù)據(jù)庫(kù)ACID中的原子性，筆者認(rèn)為最大區(qū)別在于，數(shù)據(jù)庫(kù)中的原子性主要運(yùn)用在事務(wù)中，一個(gè)事務(wù)之內(nèi)的所有更新操作要么都成功，要么都失敗，事務(wù)是有回滾機(jī)制的，而我們這里說的原子操作是沒有回滾的，這是最大的區(qū)別。

源碼分析

主要屬性

// 獲取Unsafe的實(shí)例
private static final Unsafe unsafe = Unsafe.getUnsafe();
// 標(biāo)識(shí)value字段的偏移量
private static final long valueOffset;
// 靜態(tài)代碼塊，通過unsafe獲取value的偏移量
static {
 try {
  valueOffset = unsafe.objectFieldOffset
   (AtomicInteger.class.getDeclaredField("value"));
 } catch (Exception ex) { throw new Error(ex); }
}
// 存儲(chǔ)int類型值的地方，使用volatile修飾
private volatile int value;

（1）使用int類型的value存儲(chǔ)值，且使用volatile修飾，volatile主要是保證可見性，即一個(gè)線程修改對(duì)另一個(gè)線程立即可見，主要的實(shí)現(xiàn)原理是內(nèi)存屏障，這里不展開來講，有興趣的可以自行查閱相關(guān)資料。

（2）調(diào)用Unsafe的objectFieldOffset()方法獲取value字段在類中的偏移量，用于后面CAS操作時(shí)使用。

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);

調(diào)用Unsafe.compareAndSwapInt()方法實(shí)現(xiàn)，這個(gè)方法有四個(gè)參數(shù)：

（1）操作的對(duì)象；

（2）對(duì)象中字段的偏移量；

（3）原來的值，即期望的值；

（4）要修改的值；

可以看到，這是一個(gè)native方法，底層是使用C/C++寫的，主要是調(diào)用CPU的CAS指令來實(shí)現(xiàn)，它能夠保證只有當(dāng)對(duì)應(yīng)偏移量處的字段值是期望值時(shí)才更新，即類似下面這樣的兩步操作：

if(value == expect) {
 value = newValue;
}

通過CPU的CAS指令可以保證這兩步操作是一個(gè)整體，也就不會(huì)出現(xiàn)多線程環(huán)境中可能比較的時(shí)候value值是a，而到真正賦值的時(shí)候value值可能已經(jīng)變成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()方法底層是調(diào)用的Unsafe的getAndAddInt()方法，這個(gè)方法有三個(gè)參數(shù)：

（1）操作的對(duì)象；

（2）對(duì)象中字段的偏移量；

（3）要增加的值；

查看Unsafe的getAndAddInt()方法的源碼，可以看到它是先獲取當(dāng)前的值，然后再調(diào)用compareAndSwapInt()嘗試更新對(duì)應(yīng)偏移量處的值，如果成功了就跳出循環(huán)，如果不成功就再重新嘗試，直到成功為止，這可不就是（CAS+自旋）的樂觀鎖機(jī)制么^^

AtomicInteger中的其它方法幾乎都是類似的，最終會(huì)調(diào)用到Unsafe的compareAndSwapInt()來保證對(duì)value值更新的原子性。

總結(jié)

（1）AtomicInteger中維護(hù)了一個(gè)使用volatile修飾的變量value，保證可見性；

（2）AtomicInteger中的主要方法最終幾乎都會(huì)調(diào)用到Unsafe的compareAndSwapInt()方法保證對(duì)變量修改的原子性。

彩蛋

（1）為什么需要AtomicInteger？

讓我們來看一個(gè)例子：

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看自己的機(jī)器
  // 我這里是用run跑大于2才會(huì)退出循環(huán)
  // 但是用debug跑大于1就會(huì)退出循環(huán)了
  while (Thread.activeCount() > 1) {
   // 讓出CPU
   Thread.yield();
  }

  System.out.println(count);
 }
}

這里起了100個(gè)線程，每個(gè)線程對(duì)count自增1000次，你會(huì)發(fā)現(xiàn)每次運(yùn)行的結(jié)果都不一樣，但它們有個(gè)共同點(diǎn)就是都不到100000次，所以直接使用int是有問題的。

那么，使用volatile能解決這個(gè)問題嗎？

private static volatile int count = 0;

public static void increment() {
 count++;
}

答案是很遺憾的，volatile無法解決這個(gè)問題，因?yàn)関olatile僅有兩個(gè)作用：

（1）保證可見性，即一個(gè)線程對(duì)變量的修改另一個(gè)線程立即可見；

（2）禁止指令重排序；

這里有個(gè)很重要的問題，count++實(shí)際上是兩步操作，第一步是獲取count的值，第二步是對(duì)它的值加1。

使用volatile是無法保證這兩步不被其它線程調(diào)度打斷的，所以無法保證原子性。

這就引出了我們今天講的AtomicInteger，它的自增調(diào)用的是Unsafe的CAS并使用自旋保證一定會(huì)成功，它可以保證兩步操作的原子性。

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看自己的機(jī)器
  // 我這里是用run跑大于2才會(huì)退出循環(huán)
  // 但是用debug跑大于1就會(huì)退出循環(huán)了
  while (Thread.activeCount() > 1) {
   // 讓出CPU
   Thread.yield();
  }

  System.out.println(count);
 }
}

這里總是會(huì)打印出100000。

以上就是本文的全部?jī)?nèi)容，希望對(duì)大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。

最新評(píng)論