《提高能力，漲薪可待》-Java多線程與併發之ThreadLocal

歡迎關注公衆號【 Ccww筆記】，原創技術文章第一時間推出

往期文章：

• 《提高能力，漲薪可待》-Java併發之AQS全面詳
• 《提高能力，漲薪可待》—Java併發之Synchronized
• java多線程併發系列--基礎知識點（筆試、面試必備）
• ...

1. ThreadLocal是什麼？使用場景

ThreadLocal簡介

ThreadLocal是線程本地變量，能夠爲多線程的併發問題提供一種解決方式，當使用ThreadLocal維護變量時，ThreadLocal爲每一個使用該變量的線程提供獨立的變量副本，因此每個線程均可以獨立地改變本身的副本，而不會影響其它線程所對應的副本。

ThreadLocal使用場景

多個線程去獲取一個共享變量時，要求獲取的是這個變量的初始值的副本。每一個線程存儲這個變量的副本，對這個變量副本的改變不去影響變量自己。適用於多個線程依賴不一樣變量值完成操做的場景。好比：

• 多數據源的切換
• spring聲明式事務

2. ThreadLocal的使用案例

ThreadLocal類接口：

• void set(T value)：設置當前線程的線程局部變量的值
• T get()：獲取當前線程所對應的線程局部變量
• void remove()：刪除當前線程局部變量的值，目的是爲了減小內存的佔用
• T initialValue()：該線程局部變量的初始值(默認值爲null)，該方法是一個protected的懶加載方法，線程第1次調用get()或set(T value)時才執行在，並且也是爲了讓子類覆蓋而設計的。

public class ThreadLocalDemo {
    private static ThreadLocal<Index> index = new ThreadLocal(){
        @Override
        protected Object initialValue() {
            return new Index();
        }
    };

    private static class Index{
        private int num;

        public void incr(){
            num++;
        }
    }

    public static void main(String[] args) {
        for(int i=0; i<5; i++){
            new Thread(() ->{
                Index local = index.get();
                local.incr();
                System.out.println(Thread.currentThread().getName() + " " + index.get().num);
            }, "thread_" + i).start();
        }
    }
}

輸出結果：

thread_1 1
thread_0 1
thread_3 1
thread_4 1
thread_2 1

能夠看到每一個線程的獲取的初始值都是0，而且對num++的操做也互不影響

3.ThreadLocal如何實現的

3.1 ThreadLocal的數據結構

ThreadLocal內部維護的是一個相似Map的ThreadLocalMap數據結構，而每一個Thread類，都有一個ThreadLocalMap成員變量。ThreadLocalMap將線程本地變量（ThreadLocal）做爲key，線程變量的副本做爲value，如圖所示：

須要注意的是ThreadLocal中的Entry的key和value的關係有系統進行維護，若維護不當則可能致使多線程狀態下的不安全（通常不會，至少須要注意）。

3.2 get()源碼分析

public T get() {
          //獲取當前線程
          Thread t = Thread.currentThread();
          //獲取當前線程的ThreadLocalMap
          ThreadLocalMap map = getMap(t);
          if (map != null) {
              //若是ThreadLocalMap已經被建立了，那麼經過當前的threadLocal對象做爲key，獲取value
              ThreadLocalMap.Entry e = map.getEntry(this);
              if (e != null) {
                  @SuppressWarnings("unchecked")
                  T result = (T)e.value;
                  return result;
              }
          }
          //若是ThreadLocalMap尚未被建立或者在ThreadLocalMap中查找不到此元素
          return setInitialValue();
      }

3.2.1 ThreadLocalMap沒初始化

ThreadLocalMap沒初始化，ThreadLocalMap爲null時，會調用setInitialValue()方法:

private T setInitialValue() {
          //initialValue方法通常會被重寫，不重寫的話，直接返回null
          T value = initialValue();
          Thread t = Thread.currentThread();
          //獲取當前線程的ThreadLocalMap
          ThreadLocalMap map = getMap(t);
          if (map != null)
              //ThreadLocalMap已經被建立，那麼直接設置初始值（即保存變量副本），初始值來自initialValue方法
              map.set(this, value);
          else
              //建立ThreadLocalMap
              createMap(t, value);
          return value;
      }

其中，initialValue()方法是由咱們重寫的，須要注意的是，返回值必須爲new一個對象，而不是直接返回一個對象引用。由於若是多個線程都保存同一個引用的副本的話，那他們經過這個引用修改共享變量的值，是相互影響的。咱們原本的目的即是爲了獲取共享變量的初始值副本，各個線程對副本的修改不影響變量自己。

再來看看createMap是如何建立threadLocalMap的

void createMap(Thread t, T firstValue) {
          t.threadLocals = new ThreadLocalMap(this, firstValue);
      }

ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
             //建立一個初始容量爲16的Entry數組
              table = new Entry[INITIAL_CAPACITY];
              //經過threadLocal的threadLocalHashCode來定位在數組中的位置
              int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
              //保存在數組中
              table[i] = new Entry(firstKey, firstValue);
              //記錄下已用的大小
              size = 1;
              //設置閾值爲容量的2/3
              setThreshold(INITIAL_CAPACITY);
          }

3.2.2 初始化threadLocalMap

初始化threadLocalMap以後，此線程再次調用get()方法，又作了哪些操做呢

public T get() {
          //獲取當前線程
          Thread t = Thread.currentThread();
          //獲取當前線程的ThreadLocalMap
          ThreadLocalMap map = getMap(t);
          if (map != null) {
              //若是ThreadLocalMap已經被建立了，那麼經過當前的threadLocal對象做爲key，獲取value
              ThreadLocalMap.Entry e = map.getEntry(this);
              if (e != null) {
                  @SuppressWarnings("unchecked")
                  T result = (T)e.value;
                  return result;
              }
          }
          //若是ThreadLocalMap尚未被建立或者在ThreadLocalMap中查找不到此元素
          return setInitialValue();
      }

能夠看到是經過map.getEntry(this)去查找元素的

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
                  //若是定位的元素的key與傳入的key不相等，那麼一直日後找
                  return getEntryAfterMiss(key, i, e);
          }

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
              Entry[] tab = table;
              int len = tab.length;
  
              while (e != null) {
                  ThreadLocal<?> k = e.get();
                  if (k == key)
                      return e;
                  if (k == null)
                      //將過時的key清除掉，並把後面的元素（移動過位置的）往前移
                      expungeStaleEntry(i);
                  else
                      //日後移一位
                      i = nextIndex(i, len);
                  e = tab[i];
              }
              return null;
          }

private static int nextIndex(int i, int len) {
              return ((i + 1 < len) ? i + 1 : 0);
          }

private int expungeStaleEntry(int staleSlot) {
      Entry[] tab = table;
      int len = tab.length;
  
      // 清除當前元素
      tab[staleSlot].value = null;
      tab[staleSlot] = null;
      size--;
  
      //將此元素後面的，由於hash衝突移動過位置的元素往前移
      Entry e;
      int i;
      for (i = nextIndex(staleSlot, len);
           (e = tab[i]) != null;
           i = nextIndex(i, len)) {
          ThreadLocal<?> k = e.get();
          if (k == null) {
              e.value = null;
              tab[i] = null;
              size--;
          } else {
              int h = k.threadLocalHashCode & (len - 1);
              //h != i說明有過hash衝突
              if (h != i) {
                  tab[i] = null;
  
                  // Unlike Knuth 6.4 Algorithm R, we must scan until
                  // null because multiple entries could have been stale.
                  while (tab[h] != null)
                      h = nextIndex(h, len);
                  tab[h] = e;
              }
          }
      }
      return i;
  }

若是map.getEntry(this)也找不到元素怎麼辦？

public T get() {
          //獲取當前線程
          Thread t = Thread.currentThread();
          //獲取當前線程的ThreadLocalMap
          ThreadLocalMap map = getMap(t);
          if (map != null) {
              //若是ThreadLocalMap已經被建立了，那麼經過當前的threadLocal對象做爲key，獲取value
              ThreadLocalMap.Entry e = map.getEntry(this);
              if (e != null) {
                  @SuppressWarnings("unchecked")
                  T result = (T)e.value;
                  return result;
              }
          }
          //若是ThreadLocalMap尚未被建立或者在ThreadLocalMap中查找不到此元素
          return setInitialValue();
      }

那麼繼續調用setInitialValue()方法

private T setInitialValue() {
          //initialValue方法通常會被重寫，不重寫的話，直接返回null
          T value = initialValue();
          Thread t = Thread.currentThread();
          //獲取當前線程的ThreadLocalMap
          ThreadLocalMap map = getMap(t);
          if (map != null)
              //ThreadLocalMap已經被建立，那麼直接設置初始值（即保存變量副本），初始值來自initialValue方法
              map.set(this, value);
          else
              //建立ThreadLocalMap
              createMap(t, value);
          return value;
      }

能夠看到將會調用它裏面的map.set(this, value)方法

private void set(ThreadLocal<?> key, Object value) {
              Entry[] tab = table;
              int len = tab.length;
              int i = key.threadLocalHashCode & (len-1);
  
              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;
                  }
              }
              
              //若是在table中確實找不到，那麼新建一個
              tab[i] = new Entry(key, value);
              int sz = ++size;
              if (!cleanSomeSlots(i, sz) && sz >= threshold)
                  //若是沒有元素被清除，且超過閾值，那麼擴容並從新hash定位
                  rehash();
          }

3.3 set()源碼分析

在看看set()方式處理與setInitialValue相似，少了獲取初始化值，其餘都相同，可參考get()方式中ThreadLocalMap沒初始化方式:

public void set(T value) {
    //獲取當前線程
    Thread t = Thread.currentThread();
    //獲取當前線程的ThreadLocalMap
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

3.4 總結

• 首先判斷當前線程的threadLocalMap是否存在，若不存在則建立一個。將ThreadLocal做爲key，共享變量初始值的副本做爲value，保存在threadLocalMap中
• 若threadLocalMap存在，那麼將ThreadLocal做爲key，經過hash散列定位在數組中的位置，查找value
• 若是在threadLocalMap中找不到（緣由：被刪除了，或者此ThreaLocal沒有加入到threadLocalMap，畢竟threadLocalMap能夠存放多個threadLocal），那麼將ThreadLocal做爲key，共享變量初始值的副本做爲value，保存在threadLocalMap中
• 在set的過程當中，若是當前位置有其餘元素（即hash衝突），那麼日後找，直到不存在其餘元素。而且在set的過程當中會清除一些過時（key爲null）的元素。最後將根據size大小，決定是否擴容，從新hash定位

各位看官還能夠嗎？喜歡的話，動動手指點個💗，點個關注唄！！謝謝支持！
歡迎關注公衆號【Ccww筆記】，原創技術文章第一時間推出