【ThreadLocal】理解一

threadlocal使用方法很簡單

static final ThreadLocal<T> sThreadLocal = new ThreadLocal<T>();
sThreadLocal.set()
sThreadLocal.get()

threadlocal而是一個線程內部的存儲類，可以在指定線程內存儲數據，數據存儲以後，只有指定線程可以得到存儲數據，官方解釋如下。

/**
 * This class provides thread-local variables.  These variables differ from
 * their normal counterparts in that each thread that accesses one (via its
 * {@code get} or {@code set} method) has its own, independently initialized
 * copy of the variable.  {@code ThreadLocal} instances are typically private
 * static fields in classes that wish to associate state with a thread (e.g.,
 * a user ID or Transaction ID).
 */

大致意思就是ThreadLocal提供了線程內存儲變量的能力，這些變量不同之處在於每一個線程讀取的變量是對應的互相獨立的。通過get和set方法就可以得到當前線程對應的值。

做個不恰當的比喻，從表面上看ThreadLocal相當於維護了一個map，key就是當前的線程，value就是需要存儲的對象。

這裏的這個比喻是不恰當的，實際上是ThreadLocal的靜態內部類ThreadLocalMap爲每個Thread都維護了一個數組table，ThreadLocal確定了一個數組下標，而這個下標就是value存儲的對應位置。。

作爲一個存儲數據的類，關鍵點就在get和set方法。

//set 方法
public void set(T value) {
      //獲取當前線程
      Thread t = Thread.currentThread();
      //實際存儲的數據結構類型
      ThreadLocalMap map = getMap(t);
      //如果存在map就直接set，沒有則創建map並set
      if (map != null)
          map.set(this, value);
      else
          createMap(t, value);
  }
  
//getMap方法
ThreadLocalMap getMap(Thread t) {
      //thred中維護了一個ThreadLocalMap
      return t.threadLocals;
 }
 
//createMap
void createMap(Thread t, T firstValue) {
      //實例化一個新的ThreadLocalMap，並賦值給線程的成員變量threadLocals
      t.threadLocals = new ThreadLocalMap(this, firstValue);
}

從上面代碼可以看出每個線程持有一個ThreadLocalMap對象。每一個新的線程Thread都會實例化一個ThreadLocalMap並賦值給成員變量threadLocals，使用時若已經存在threadLocals則直接使用已經存在的對象。

Thread

/* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;

Thread中關於ThreadLocalMap部分的相關聲明，接下來看一下createMap方法中的實例化過程。

ThreadLocalMap

set方法

//Entry爲ThreadLocalMap靜態內部類，對ThreadLocal的若引用
//同時讓ThreadLocal和儲值形成key-value的關係
static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;

    Entry(ThreadLocal<?> k, Object v) {
           super(k);
            value = v;
    }
}

//ThreadLocalMap構造方法
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
        //內部成員數組，INITIAL_CAPACITY值爲16的常量
        table = new Entry[INITIAL_CAPACITY];
        //位運算，結果與取模相同，計算出需要存放的位置
        //threadLocalHashCode比較有趣
        int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
        table[i] = new Entry(firstKey, firstValue);
        size = 1;
        setThreshold(INITIAL_CAPACITY);
}

通過上面的代碼不難看出在實例化ThreadLocalMap時創建了一個長度爲16的Entry數組。通過hashCode與length位運算確定出一個索引值i，這個i就是被存儲在table數組中的位置。

前面講過每個線程Thread持有一個ThreadLocalMap類型的實例threadLocals，結合此處的構造方法可以理解成每個線程Thread都持有一個Entry型的數組table，而一切的讀取過程都是通過操作這個數組table完成的。

顯然table是set和get的焦點，在看具體的set和get方法前，先看下面這段代碼。

//在某一線程聲明瞭ABC三種類型的ThreadLocal
ThreadLocal<A> sThreadLocalA = new ThreadLocal<A>();
ThreadLocal<B> sThreadLocalB = new ThreadLocal<B>();
ThreadLocal<C> sThreadLocalC = new ThreadLocal<C>();

由前面我們知道對於一個Thread來說只有持有一個ThreadLocalMap，所以ABC對應同一個ThreadLocalMap對象。爲了管理ABC，於是將他們存儲在一個數組的不同位置，而這個數組就是上面提到的Entry型的數組table。

那麼問題來了，ABC在table中的位置是如何確定的？爲了能正常夠正常的訪問對應的值，肯定存在一種方法計算出確定的索引值i，show me code。

  //ThreadLocalMap中set方法。
  private void set(ThreadLocal<?> key, Object value) {

            // We don't use a fast path as with get() because it is at
            // least as common to use set() to create new entries as
            // it is to replace existing ones, in which case, a fast
            // path would fail more often than not.

            Entry[] tab = table;
            int len = tab.length;
            //獲取索引值，這個地方是比較特別的地方
            int i = key.threadLocalHashCode & (len-1);

            //遍歷tab如果已經存在則更新值
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();

                if (k == key) {
                    e.value = value;
                    return;
                }

                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }
            
            //如果上面沒有遍歷成功則創建新值
            tab[i] = new Entry(key, value);
            int sz = ++size;
            //滿足條件數組擴容x2
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

在ThreadLocalMap中的set方法與構造方法能看到以下代碼片段。

int i = key.threadLocalHashCode & (len-1)
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1)

簡而言之就是將threadLocalHashCode進行一個位運算（取模）得到索引i，threadLocalHashCode代碼如下。

    //ThreadLocal中threadLocalHashCode相關代碼.
    
    private final int threadLocalHashCode = nextHashCode();

    /**
     * The next hash code to be given out. Updated atomically. Starts at
     * zero.
     */
    private static AtomicInteger nextHashCode =
        new AtomicInteger();

    /**
     * The difference between successively generated hash codes - turns
     * implicit sequential thread-local IDs into near-optimally spread
     * multiplicative hash values for power-of-two-sized tables.
     */
    private static final int HASH_INCREMENT = 0x61c88647;

    /**
     * Returns the next hash code.
     */
    private static int nextHashCode() {
        //自增
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

因爲static的原因，在每次new ThreadLocal時因爲threadLocalHashCode的初始化，會使threadLocalHashCode值自增一次，增量爲0x61c88647。

0x61c88647是斐波那契散列乘數,它的優點是通過它散列(hash)出來的結果分佈會比較均勻，可以很大程度上避免hash衝突，已初始容量16爲例，hash並與15位運算計算數組下標結果如下：

hashCode	數組下標
0x61c88647	7
0xc3910c8e	14
0x255992d5	5
0x8722191c	12
0xe8ea9f63	3
0x4ab325aa	10
0xac7babf1	1
0xe443238	8
0x700cb87f	15

總結如下：

對於某一ThreadLocal來講，他的索引值i是確定的，在不同線程之間訪問時訪問的是不同的table數組的同一位置即都爲table[i]，只不過這個不同線程之間的table是獨立的。
對於同一線程的不同ThreadLocal來講，這些ThreadLocal實例共享一個table數組，然後每個ThreadLocal實例在table中的索引i是不同的。

get()方法

//ThreadLocal中get方法
public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}
    
//ThreadLocalMap中getEntry方法
private Entry getEntry(ThreadLocal<?> key) {
       int i = key.threadLocalHashCode & (table.length - 1);
       Entry e = table[i];
       if (e != null && e.get() == key)
            return e;
       else
            return getEntryAfterMiss(key, i, e);
   }

理解了set方法，get方法也就清楚明瞭，無非是通過計算出索引直接從數組對應位置讀取即可。

ThreadLocal實現主要涉及Thread，ThreadLocal，ThreadLocalMap這三個類。關於ThreadLocal的實現流程正如上面寫的那樣，實際代碼還有許多細節處理的部分並沒有在這裏寫出來。

ThreadLocal特性

ThreadLocal和Synchronized都是爲了解決多線程中相同變量的訪問衝突問題，不同的點是

Synchronized是通過線程等待，犧牲時間來解決訪問衝突
ThreadLocal是通過每個線程單獨一份存儲空間，犧牲空間來解決衝突，並且相比於Synchronized，ThreadLocal具有線程隔離的效果，只有在線程內才能獲取到對應的值，線程外則不能訪問到想要的值。

正因爲ThreadLocal的線程隔離特性，使他的應用場景相對來說更爲特殊一些。在android中Looper、ActivityThread以及AMS中都用到了ThreadLocal。當某些數據是以線程爲作用域並且不同線程具有不同的數據副本的時候，就可以考慮採用ThreadLocal。

原文鏈接：https://www.jianshu.com/p/3c5d7f09dfbd

【ThreadLocal】理解一

【JPA】Springboot+jpa簡單的增刪改查

【Es+Kibana】es和kibana部署安裝

【MySql】解決mysql沒有root用戶問題

【Apollo】分佈式配置中心Apollo環境搭建

【Centos】FATAL: kernel too old

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

【ThreadLocal】 理解一

【ThreadLocal】理解一