在處理多線程并發(fā)安全的方法中，最常用的方法，就是使用鎖，通過鎖來控制多個不同線程對臨界區(qū)的訪問。
但是，無論是什么樣的鎖，樂觀鎖或者悲觀鎖，都會在并發(fā)沖突的時候?qū)π阅墚a(chǎn)生一定的影響。
那有沒有一種方法，可以徹底避免競爭呢？
答案是肯定的，這就是ThreadLocal。
從字面意思上看，ThreadLocal可以解釋成線程的局部變量，也就是說一個ThreadLocal的變量只有當(dāng)前自身線程可以訪問，別的線程都訪問不了，那么自然就避免了線程競爭。
因此，ThreadLocal提供了一種與眾不同的線程安全方式，它不是在發(fā)生線程沖突時想辦法解決沖突，而是徹底的避免了沖突的發(fā)生。
ThreadLocal的基本使用
創(chuàng)建一個ThreadLocal對象：
privateThreadLocal localInt =newThreadLocal<>();復(fù)制代碼
上述代碼創(chuàng)建一個localInt變量，由于ThreadLocal是一個泛型類，這里指定了localInt的類型為整數(shù)。
下面展示了如果設(shè)置和獲取這個變量的值：
publicintsetAndGet(){? ? localInt.set(8);returnlocalInt.get();}復(fù)制代碼
上述代碼設(shè)置變量的值為8，接著取得這個值。
由于ThreadLocal里設(shè)置的值，只有當(dāng)前線程自己看得見，這意味著你不可能通過其他線程為它初始化值。為了彌補(bǔ)這一點(diǎn)，ThreadLocal提供了一個withInitial()方法統(tǒng)一初始化所有線程的ThreadLocal的值：
privateThreadLocal localInt = ThreadLocal.withInitial(() ->6);復(fù)制代碼
上述代碼將ThreadLocal的初始值設(shè)置為6，這對全體線程都是可見的。
ThreadLocal的實現(xiàn)原理
ThreadLocal變量只在單個線程內(nèi)可見，那它是如何做到的呢？我們先從最基本的get()方法說起：
publicTget(){//獲得當(dāng)前線程Thread t = Thread.currentThread();//每個線程 都有一個自己的ThreadLocalMap，//ThreadLocalMap里就保存著所有的ThreadLocal變量ThreadLocalMap map = getMap(t);if(map !=null) {//ThreadLocalMap的key就是當(dāng)前ThreadLocal對象實例，//多個ThreadLocal變量都是放在這個map中的ThreadLocalMap.Entry e = map.getEntry(this);if(e !=null) {@SuppressWarnings("unchecked")//從map里取出來的值就是我們需要的這個ThreadLocal變量T result = (T)e.value;returnresult;? ? ? ? }? ? }// 如果map沒有初始化，那么在這里初始化一下returnsetInitialValue();}復(fù)制代碼
可以看到，所謂的ThreadLocal變量就是保存在每個線程的map中的。這個map就是Thread對象中的threadLocals字段。如下：
ThreadLocal.ThreadLocalMap threadLocals =null;復(fù)制代碼
ThreadLocal.ThreadLocalMap是一個比較特殊的Map，它的每個Entry的key都是一個弱引用：
staticclassEntryextendsWeakReference>{/** The value associated with this ThreadLocal. */Object value;//key就是一個弱引用Entry(ThreadLocal k, Object v) {super(k);? ? ? ? value = v;? ? }}復(fù)制代碼
這樣設(shè)計的好處是，如果這個變量不再被其他對象使用時，可以自動回收這個ThreadLocal對象，避免可能的內(nèi)存泄露（注意，Entry中的value，依然是強(qiáng)引用，如何回收，見下文分解）。
理解ThreadLocal中的內(nèi)存泄漏問題
雖然ThreadLocalMap中的key是弱引用，當(dāng)不存在外部強(qiáng)引用的時候，就會自動被回收，但是Entry中的value依然是強(qiáng)引用。這個value的引用鏈條如下：
可以看到，只有當(dāng)Thread被回收時，這個value才有被回收的機(jī)會，否則，只要線程不退出，value總是會存在一個強(qiáng)引用。但是，要求每個Thread都會退出，是一個極其苛刻的要求，對于線程池來說，大部分線程會一直存在在系統(tǒng)的整個生命周期內(nèi)，那樣的話，就會造成value對象出現(xiàn)泄漏的可能。處理的方法是，在ThreadLocalMap進(jìn)行set(),get(),remove()的時候，都會進(jìn)行清理：
以getEntry()為例：
privateEntrygetEntry(ThreadLocal<?> key){inti = key.threadLocalHashCode & (table.length -1);? ? Entry e = table[i];if(e !=null&& e.get() == key)//如果找到key，直接返回returne;else//如果找不到，就會嘗試清理，如果你總是訪問存在的key，那么這個清理永遠(yuǎn)不會進(jìn)來returngetEntryAfterMiss(key, i, e);}復(fù)制代碼
下面是getEntryAfterMiss()的實現(xiàn)：
privateEntrygetEntryAfterMiss(ThreadLocal key,inti, Entry e){? ? Entry[] tab = table;intlen = tab.length;while(e !=null) {// 整個e是entry ，也就是一個弱引用ThreadLocal k = e.get();//如果找到了，就返回if(k == key)returne;if(k ==null)//如果key為null，說明弱引用已經(jīng)被回收了//那么就要在這里回收里面的value了expungeStaleEntry(i);else//如果key不是要找的那個，那說明有hash沖突，這里是處理沖突，找下一個entryi = nextIndex(i, len);? ? ? ? e = tab[i];? ? }returnnull;}復(fù)制代碼
真正用來回收value的是expungeStaleEntry()方法，在remove()和set()方法中，都會直接或者間接調(diào)用到這個方法進(jìn)行value的清理：
從這里可以看到，ThreadLocal為了避免內(nèi)存泄露，也算是花了一番大心思。不僅使用了弱引用維護(hù)key，還會在每個操作上檢查key是否被回收，進(jìn)而再回收value。
但是從中也可以看到，ThreadLocal并不能100%保證不發(fā)生內(nèi)存泄漏。
比如，很不幸的，你的get()方法總是訪問固定幾個一直存在的ThreadLocal，那么清理動作就不會執(zhí)行，如果你沒有機(jī)會調(diào)用set()和remove()，那么這個內(nèi)存泄漏依然會發(fā)生。
因此，一個良好的習(xí)慣依然是：當(dāng)你不需要這個ThreadLocal變量時，主動調(diào)用remove()，這樣對整個系統(tǒng)是有好處的。
ThreadLocalMap中的Hash沖突處理
ThreadLocalMap作為一個HashMap和java.util.HashMap的實現(xiàn)是不同的。對于java.util.HashMap使用的是鏈表法來處理沖突：
但是，對于ThreadLocalMap，它使用的是簡單的線性探測法，如果發(fā)生了元素沖突，那么就使用下一個槽位存放：
具體來說，整個set()的過程如下：
可以被繼承的ThreadLocal——InheritableThreadLocal
在實際開發(fā)過程中，我們可能會遇到這么一種場景。主線程開了一個子線程，但是我們希望在子線程中可以訪問主線程中的ThreadLocal對象，也就是說有些數(shù)據(jù)需要進(jìn)行父子線程間的傳遞。比如像這樣：
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();
? ? ? ? }
? ? });
}
執(zhí)行上述代碼，你會看到：
Thread-0:null
Thread-1:null
Thread-2:null
Thread-3:null
因為在子線程中，是沒有threadLocal的。如果我們希望子線可以看到父線程的ThreadLocal，那么就可以使用InheritableThreadLocal。顧名思義，這就是一個支持線程間父子繼承的ThreadLocal，將上述代碼中的threadLocal使用InheritableThreadLocal：
InheritableThreadLocal threadLocal = new InheritableThreadLocal();
再執(zhí)行，就能看到：
Thread-0:0
Thread-1:1
Thread-2:2
Thread-3:3
Thread-4:4
可以看到，每個線程都可以訪問到從父進(jìn)程傳遞過來的一個數(shù)據(jù)。雖然InheritableThreadLocal看起來挺方便的，但是依然要注意以下幾點(diǎn)：
變量的傳遞是發(fā)生在線程創(chuàng)建的時候，如果不是新建線程，而是用了線程池里的線程，就不靈了
變量的賦值就是從主線程的map復(fù)制到子線程，它們的value是同一個對象，如果這個對象本身不是線程安全的，那么就會有線程安全問題
