ThreadLocal使用與原理
在處理多線程并發安全的方法中，最常用的方法，就是使用鎖，通過鎖來控制多個不同線程對臨界區的訪問。
但是，無論是什么樣的鎖，樂觀鎖或者悲觀鎖，都會在并發沖突的時候對性能產生一定的影響。
那有沒有一種方法，可以徹底避免競爭呢?
答案是肯定的，這就是ThreadLocal。
從字面意思上看，ThreadLocal可以解釋成線程的局部變量，也就是說一個ThreadLocal的變量只有當前自身線程可以訪問，別的線程都訪問不了，那么自然就避免了線程競爭。
因此，ThreadLocal提供了一種與眾不同的線程安全方式，它不是在發生線程沖突時想辦法解決沖突，而是徹底的避免了沖突的發生。
ThreadLocal的基本使用
創建一個ThreadLocal對象：
- private ThreadLocal<Integer> localInt = new ThreadLocal<>();
上述代碼創建一個localInt變量，由于ThreadLocal是一個泛型類，這里指定了localInt的類型為整數。
下面展示了如果設置和獲取這個變量的值：
- public int setAndGet(){
- localInt.set(8);
- return localInt.get();
- }
上述代碼設置變量的值為8，接著取得這個值。
由于ThreadLocal里設置的值，只有當前線程自己看得見，這意味著你不可能通過其他線程為它初始化值。為了彌補這一點，ThreadLocal提供了一個withInitial()方法統一初始化所有線程的ThreadLocal的值：
- private ThreadLocal<Integer> localInt = ThreadLocal.withInitial(() -> 6);
上述代碼將ThreadLocal的初始值設置為6，這對全體線程都是可見的。
ThreadLocal的實現原理
ThreadLocal變量只在單個線程內可見，那它是如何做到的呢?我們先從最基本的get()方法說起：
- public T get() {
- //獲得當前線程
- Thread t = Thread.currentThread();
- //每個線程 都有一個自己的ThreadLocalMap，
- //ThreadLocalMap里就保存著所有的ThreadLocal變量
- ThreadLocalMap map = getMap(t);
- if (map != null) {
- //ThreadLocalMap的key就是當前ThreadLocal對象實例，
- //多個ThreadLocal變量都是放在這個map中的
- ThreadLocalMap.Entry e = map.getEntry(this);
- if (e != null) {
- @SuppressWarnings("unchecked")
- //從map里取出來的值就是我們需要的這個ThreadLocal變量
- T result = (T)e.value;
- return result;
- }
- }
- // 如果map沒有初始化，那么在這里初始化一下
- return setInitialValue();
- }
可以看到，所謂的ThreadLocal變量就是保存在每個線程的map中的。這個map就是Thread對象中的threadLocals字段。如下：
- ThreadLocal.ThreadLocalMap threadLocals = null;
ThreadLocal.ThreadLocalMap是一個比較特殊的Map，它的每個Entry的key都是一個弱引用：
- static class Entry extends WeakReference<ThreadLocal<?>> {
- /** The value associated with this ThreadLocal. */
- Object value;
- //key就是一個弱引用
- Entry(ThreadLocal<?> k, Object v) {
- super(k);
- value = v;
- }
- }
這樣設計的好處是，如果這個變量不再被其他對象使用時，可以自動回收這個ThreadLocal對象，避免可能的內存泄露(注意，Entry中的value，依然是強引用，如何回收，見下文分解)。
理解ThreadLocal中的內存泄漏問題
雖然ThreadLocalMap中的key是弱引用，當不存在外部強引用的時候，就會自動被回收，但是Entry中的value依然是強引用。這個value的引用鏈條如下：
可以看到，只有當Thread被回收時，這個value才有被回收的機會，否則，只要線程不退出，value總是會存在一個強引用。但是，要求每個Thread都會退出，是一個極其苛刻的要求，對于線程池來說，大部分線程會一直存在在系統的整個生命周期內，那樣的話，就會造成value對象出現泄漏的可能。處理的方法是，在ThreadLocalMap進行set(),get(),remove()的時候，都會進行清理：
以getEntry()為例：
- private Entry getEntry(ThreadLocal<?> key) {
- int i = key.threadLocalHashCode & (table.length - 1);
- Entry e = table[i];
- if (e != null && e.get() == key)
- //如果找到key，直接返回
- return e;
- else
- //如果找不到，就會嘗試清理，如果你總是訪問存在的key，那么這個清理永遠不會進來
- return getEntryAfterMiss(key, i, e);
- }
下面是getEntryAfterMiss()的實現：
- private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
- Entry[] tab = table;
- int len = tab.length;
- while (e != null) {
- // 整個e是entry ，也就是一個弱引用
- ThreadLocal<?> k = e.get();
- //如果找到了，就返回
- if (k == key)
- return e;
- if (k == null)
- //如果key為null，說明弱引用已經被回收了
- //那么就要在這里回收里面的value了
- expungeStaleEntry(i);
- else
- //如果key不是要找的那個，那說明有hash沖突，這里是處理沖突，找下一個entry
- i = nextIndex(i, len);
- e = tab[i];
- }
- return null;
- }
真正用來回收value的是expungeStaleEntry()方法，在remove()和set()方法中，都會直接或者間接調用到這個方法進行value的清理：
從這里可以看到，ThreadLocal為了避免內存泄露，也算是花了一番大心思。不僅使用了弱引用維護key，還會在每個操作上檢查key是否被回收，進而再回收value。
但是從中也可以看到，ThreadLocal并不能100%保證不發生內存泄漏。
比如，很不幸的，你的get()方法總是訪問固定幾個一直存在的ThreadLocal，那么清理動作就不會執行，如果你沒有機會調用set()和remove()，那么這個內存泄漏依然會發生。
因此，一個良好的習慣依然是：當你不需要這個ThreadLocal變量時，主動調用remove()，這樣對整個系統是有好處的。
ThreadLocalMap中的Hash沖突處理
ThreadLocalMap作為一個HashMap和java.util.HashMap的實現是不同的。對于java.util.HashMap使用的是鏈表法來處理沖突：
但是，對于ThreadLocalMap，它使用的是簡單的線性探測法，如果發生了元素沖突，那么就使用下一個槽位存放：
具體來說，整個set()的過程如下：
可以被繼承的ThreadLocal——InheritableThreadLocal
在實際開發過程中，我們可能會遇到這么一種場景。主線程開了一個子線程，但是我們希望在子線程中可以訪問主線程中的ThreadLocal對象，也就是說有些數據需要進行父子線程間的傳遞。比如像這樣：
- public static void main(String[] args) {
- ThreadLocal threadLocal = new ThreadLocal();
- IntStream.range(0,10).forEach(i -> {
- //每個線程的序列號，希望在子線程中能夠拿到
- threadLocal.set(i);
- //這里來了一個子線程，我們希望可以訪問上面的threadLocal
- new Thread(() -> {
- System.out.println(Thread.currentThread().getName() + ":" + threadLocal.get());
- }).start();
- try {
- Thread.sleep(1000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- });
- }
執行上述代碼，你會看到：
- Thread-0:null
- Thread-1:null
- Thread-2:null
- Thread-3:null
因為在子線程中，是沒有threadLocal的。如果我們希望子線可以看到父線程的ThreadLocal，那么就可以使用InheritableThreadLocal。顧名思義，這就是一個支持線程間父子繼承的ThreadLocal，將上述代碼中的threadLocal使用InheritableThreadLocal：
- InheritableThreadLocal threadLocal = new InheritableThreadLocal();
再執行，就能看到：
- Thread-0:0
- Thread-1:1
- Thread-2:2
- Thread-3:3
- Thread-4:4
可以看到，每個線程都可以訪問到從父進程傳遞過來的一個數據。雖然InheritableThreadLocal看起來挺方便的，但是依然要注意以下幾點：
變量的傳遞是發生在線程創建的時候，如果不是新建線程，而是用了線程池里的線程，就不靈了
變量的賦值就是從主線程的map復制到子線程，它們的value是同一個對象，如果這個對象本身不是線程安全的，那么就會有線程安全問題
寫在最后的話
今天，我們介紹了ThreadLocal，ThreadLocal在Java的多線程開發中有著十分重要的作用。
在這里，我們介紹了ThreadLocal的基本使用和實現原理，尤其重點介紹了基于當前實現原理下可能存在的內存泄漏問題。
最后，還介紹了一個用于在父子線程間傳遞數據的特殊的ThreadLocal實現，希望對大家有所幫助。
