Java高併發16-LongAdder類源碼解析（上）

一、複習

• AtomicLong類

二、LongAdder源碼分析

1.繼承與實現關係

• LongAdder類繼承自Striped64這個類，同時實現了Serializable接口

abtract class Strped64{
    transient volatile Cell[] cells;
    transient volatile long base;
    transient volatile int cellsBusy;
    ........
}

• 繼承了三個變量，其中cells變量就是Cell實例數組，用於存放共享變量，base值是一個基礎值，cellsBusy用來實現自旋鎖，其值只有0和1
• 「當創建Cell元素，擴容Cell數組或者初始化Cell數組的時候，使用CAS操作該變量來保證同時只有一個線程可以進行其中之一的操作。」

2.關鍵字transient

• 講這個關鍵字之前不得不提一下Seriable這個接口，我們以LongAdder這裏類爲例，由於它實現了序列化這個接口，也就意味着這個類可以序列化，並且保存到磁盤中，而不僅僅是隻在內存中使用，然後對於有一些數據是不應該序列化的，比如密碼，關鍵信息等等，這些數據保存到變量之後，然後被transient這個關鍵字修飾，那麼將來序列化這個實例的時候，就不會保存這個變量，保證信息安全。

3.Cell源碼

package com.ruigege.AtomicOperationClass4;
import sun.misc.Unsafe;

@sun.misc.Contended public class LongAdderTest {
 
 volatile long value;
 
 public LongAdderTest(long value) {
  this.value = value;
 }

 private static final Unsafe unsafe;
 private static final long valueOffset;
 static {
  try {
   unsafe = Unsafe.getUnsafe();
   Class<?> ak = Cell.class;
   valueOffset = unsafe.objectFieldOffset(ak.getDeclaredField("value"));
  }catch(Exception e) {
   throw new Error(e);
  }
 }
 
 final long cas(long cmp,long val) {
  return unsafe.compareAndSwapLong(this,valueOffset,cmp,val);
 }
}

• cas函數使用了CAS操作，保證了當前線程更新時被分配的Cell元素中的value值的原子性。

 public long sum() {
  Cell[] as = cells;
  long sum = base;
  if(as != null) {
   for (int i=0;i<as.length;i++) {
    if(as[i] != null) {
     sum += as[i].value;
    }
   }
  }
 }

• 上面這個函數就是求總值，但是由於沒有加鎖，所以在計算的過程中，有可能Cell實例的值變化了，所以得到的值可能不準。

 public void reset() {
  Cell[] as = cells;
  base = 0L;
  if(as != null) {
   for (int i=0;i<as.length;i++) {
    if(as[i] != null) {
     as[i].value = 0L;
    }
   }
  }
 }

• 該函數用於重置該LongAdder實例

 public long sunThenReset() {
  Cell[] as = cells;
  int sum = base;
  if(as != null) {
   for (int i=0;i<as.length;i++) {
    if(as[i] != null) {
     sum += as[i];
     as[i] = 0L;
    }
   }
  }
 }

• 先求和，然後Cell數組置空，但是這個方法沒有加鎖，容易造成數據不一致。

 public void add(long x) {
  Cell[] as;
  long b,v;
  int m;
  Cell a;
  if((as = cells) != null) || !caseBase(b=base,b+x)){
   //如果as是一個空數組，也就是第一個是false，那麼會去判斷第二個，第二個函數，其實就是一個CAS操作，
   //空數組就意味着沒有初始化數組，這個LongAdder實例，裏面就一個base變量，也就是說併發量太小了，不足以
   //初始化數組，這時這個實例就是一個AtomicLong實例，沒有區別，第二個判斷就是給base賦值爲最新的增長量
   //如果cas失敗了，那麼就進入到下面的判斷語句中
   boolean uncontended = true;
   if(as==null || (m = as.length-1)<0 || (a = as[getProbe() & m]) == null || !(uncontended=a.cas(v=a.value,v+x))){
    /**
     * 四個判斷條件，逐步深入
     * （1）如果數組爲空，繼續執行判斷體內；不爲空，看第二個條件
     * （2）如果數組中元素爲0，繼續執行判斷體內；不少於1個，看第三個條件
     * （3）getProbe()函數用於獲取獲取當前線程中變量threadLocalRandomProbe的值，這個值一開始爲0，在接下
     * 來的判斷體中會進行初始化，並且當前線程通過分配的Cell元素的cas函數來保證對Cell元素value值更新的原子性。
     * 這第三個就是爲了找到一個數組中的Cell變量，我們暫且看到是0&m,那就是0了，也就是啊as[0]賦值給a，並且如果是空的，則直接
     * 進入到判斷執行體；如果不爲空，接着看第四個判斷條件
     * （4）第四個判斷條件就是剛纔的那個a使用CAS操作來更新值，如果更新失敗了就進入到執行體
     */
    longAccumulate(x,null,uncontended);
   }
  }
 }
 
 final boolean casBase(long cmp,long val) {
  return UNSAFE.compareAndSwapLong(this,BASE,cmp,val);
 }

• 以上都是add函數，內部具體實現邏輯，

final void longAccumulate(long x,LongBinaryOperator fn,boolean wasUncontended) {
  //初始化當前線程的變量threadLocalRandomProbe的值
  int h;
  if(h = getProbe() == 0) {
   ThreadLocalRandom.current();
   h = getProbe();
   wasUncontended = true;
  }
  boolean collide = false;
  for(;;) {
   Cell[] as;Cell a;int n;long v;
   if((as=cells) != null && (n=as.length)>0) {
    if((a=as[(n-1) &h]) == null) {
     if(cellsBusy == 0) {
      Cell r = new Cell(x);
      if(cellsBusy == 0 && casCellsBusy()) {
       boolean created = false;
      }
      try {
       Cell[] rs;int m,j;
       if((rs=cells) != null && (m=rs.length)>0 && rs[j = (m-1) &h] == null) {
        rs[j] = r;
        created = true;
       }
      }finally {
       cellsBusy = 0;
      }
      if(created) {
       break;
      }
      continue;
     }
    }
    collide = false;
   }else if(!wasUntended) {
    wasUncontended = true;
   }else if(a.cas(v=a.value,((fn==null)?v+x : fn.applyAsLong(v,x)))) {
    break;
   }else if(n >= NCPU || cells != as) {
    collide = false;
   }else if(!collide) {
    collide = ture;
   }else if(cellsBusy == 0 && casCellsBusy()) {
    try {
     if(cells == as) {
      Cell[] rs = new Cell[n<<1];
      for(int i=0;i<n;++i) {
       rs[i] = as[i];
      }
      cells = rs;
     }
    }finally {
     cellsBusy = 0;
    }
   }
  }
 }

三、源碼：

• 所在包：com.ruigege.AtomicOperationClass4
• https://github.com/ruigege66/ConcurrentJava
• CSDN：https://blog.csdn.net/weixin_44630050
• 博客園：https://www.cnblogs.com/ruigege0000/
• 歡迎關注微信公衆號：傅里葉變換，個人賬號，僅用於技術交流