最近看Android FrameWork層代碼，看到了ThreadLocal這個類，有點兒陌生，就翻了各種相關博客一一拜讀；自己隨後又研究了一遍源碼，發現自己的理解較之前閱讀的博文有不同之處，所以決定自己寫篇文章說說自己的理解，希望可以起到以下作用：
- 可以疏通研究結果，加深自己的理解；
- 可以起到拋磚引玉的作用，幫助感興趣的同學疏通思路；
- 分享學習經歷，同大家一起交流和學習。
一、 ThreadLocal 是什麼
ThreadLocal 是Java類庫的基礎類，在包java.lang下面；
官方的解釋是這樣的：
Implements a thread-local storage, that is, a variable for which each thread has its own value. All threads share the same ThreadLocal object, but each sees a different value when accessing it, and changes made by one thread do not affect the other threads. The implementation supports null values.
大致意思是：
可以實現線程的本地存儲機制，ThreadLocal變量是一個不同線程可以擁有不同值的變量。所有的線程可以共享同一個ThreadLocal對象，但是不同線程訪問的時候可以取得不同的值，而且任意一個線程對它的改變不會影響其他線程。類實現是支持null值的（可以在set和get方法傳遞和訪問null值）。
概括來講有三個特性：
- 不同線程訪問時取得不同的值
- 任意線程對它的改變不影響其他線程
- 支持null
下面分別對這些特性進行實例驗證，首先定義一個Test類，在此類中我們鑑證上邊所提到的三個特性。類定義如下：
Test.java
public class Test{//定義ThreadLocal private static ThreadLocal name;public static void main(String[] args) throws Exception{name = new ThreadLocal();//Define Thread AThread a = new Thread(){public void run(){System.out.println("Before invoke set,value is:"+name.get());name.set(“Thread A”);System.out.println("After invoke set, value is:"+name.get());}};//Define Thread BThread b = new Thread(){public void run(){System.out.println("Before invoke set,value is :"+name.get());name.set(“Thread B”);System.out.println("After invoke set,value is :"+name.get());}};// Not invoke set, print the value is nullSystem.out.println(name.get());// Invoke set to fill a valuename.set(“Thread Main”);// Start thread Aa.start();a.join();// Print the value after changed the value by thread ASystem.out.println(name.get());// Start thread Bb.start();b.join();// Print the value after changed the value by thread BSystem.out.println(name.get())}}代碼分析：
從定義中我們可以看到只聲明了一個ThreadLocal對象，其他三個線程（主線程、Thread A和Thread B）共享同一個對象；然後，在不同的線程中修改對象的值和在不同的線程中訪問對象的值，並在控制台輸出查看結果。
看結果：
從控制台輸出結果可以看到裡邊有三個null的輸出，這個是因為在輸出前沒有對對象進行賦值，驗證了支持null的特點；再者，還可以發現在每個線程我都對對象的值做了修改，但是在其他線程訪問對象時並不是修改後的值，而是訪問線程本地的值；這樣也驗證了其他兩個特點。
二、 ThreadLocal的作用
大家都知道它的使用場景大都是多線程編程，至於具體的作用，這個怎麼說那？我覺得這個只能用一個泛的說法來定義，因為一個東西的功能屬性定義了以後會限制大家的思路，就好比說菜刀是用來切菜的，好多人就不會用它切西瓜了。
這裡，說下我對它的作用的認識，僅供參考，希望能有所幫助。這樣來描述吧，當一個多線程的程序需要對多數線程的部分任務（就是run方法裡的部分代碼）進行封裝時，在封裝體裡就可以用ThreadLocal來包裝與線程相關的成員變量，從而保證線程訪問的獨占性，而且所有線程可以共享一個封裝體對象；可以參考下Android裡的Looper。不會用代碼描述問題的程序員不是好程序員；
看代碼：統計線程某段代碼耗時的工具（為說明問題自造）
StatisticCostTime.java
// Class that statistic the cost timepublic class StatisticCostTime{// record the startTime// private ThreadLocal startTime = new ThreadLocal();private long startTime;// private ThreadLocal costTime = new ThreadLocal();private long costTime;private StatisticCostTime(){}//Singletonpublic static final StatisticCostTime shareInstance(){return InstanceFactory.instance;}private static class InstanceFactory{private static final StatisticCostTime instance = new StatisticCostTime();}// startpublic void start(){// startTime.set(System. nanoTime ());startTime = System.nanoTime();}// endpublic void end(){// costTime.set(System. nanoTime () - startTime.get());costTime = System.nanoTime() - startTime;}public long getStartTime(){return startTime;// return startTime.get();}public long getCostTime(){// return costTime.get();return costTime;}好了，工具設計完工了,現在我們用它來統計一下線程耗時試試唄：
Main.java
public class Main{public static void main(String[] args) throws Exception{// Define the thread aThread a = new Thread(){public void run(){try{// start record timeStatisticCostTime.shareInstance().start();sleep(200);// print the start time of A System.out.println("A-startTime:"+StatisticCostTime.shareInstance().getStartTime());// end the recordStatisticCostTime.shareInstance().end();// print the costTime of A System.out.println("A:"+StatisticCostTime.shareInstance().getCostTime());}catch(Exception e){}}};// start aa.start();// Define thread bThread b = new Thread(){public void run(){try{// record the start time of B1StatisticCostTime.shareInstance().start();sleep(100);// print the start time to consoleSystem.out.println("B1-startTime:"+StatisticCostTime.shareInstance().getStartTime());// end record start time of B1StatisticCostTime.shareInstance().end();// print the cost time of B1System.out.println("B1:"+StatisticCostTime.shareInstance().getCostTime());// start record time of B2StatisticCostTime.shareInstance().start();sleep(100);// print start time of B2System.out.println("B2-startTime:"+StatisticCostTime.shareInstance().getStartTime());// end record time of B2StatisticCostTime.shareInstance().end();// print cost time of B2System.out.println("B2:"+StatisticCostTime.shareInstance().getCostTime());}catch(Exception e){}}};b.start();}}運行代碼後輸出結果是這樣的注意：輸出結果精確度為納秒級
看結果是不是和我們預想的不一樣，發現A的結果應該約等於B1+B2才對呀，怎麼變成和B2一樣了那？答案就是我們在定義startTime和costTime變量時，本意是不應共享的，應是線程獨占的才對。而這裡變量隨單例共享了，所以當計算A的值時，其實startTime已經被B2修改了，所以就輸出了和B2一樣的結果。
現在我們把StatisticCostTime中註釋掉的部分打開，換成ThreadLocal的聲明方式試下。
看結果：
呀！這下達到預期效果了，這時候有同學會說這不是可以線程並發訪問了嗎，是不是只要我用了ThreadLocal就可以保證線程安全了？答案是no！首先先弄明白為什麼會有線程安全問題，無非兩種情況：
1、不該共享的資源，你在線程間共享了；
2、線程間共享的資源，你沒有保證有序訪問；
前者可以用“空間換時間”的方式解決，用ThreadLocal（也可以直接聲明線程局部變量），後者用“時間換空間”的方式解決，顯然這個就不是ThreadLocal力所能及的了。
三、 ThreadLocal 原理
實現原理其實很簡單，每次對ThreadLocal 對象的讀寫操作其實是對線程的Values對象的讀寫操作；這裡澄清一下，沒有什麼變量副本的創建，因為就沒有用變量分配的內存空間來存T對象的，而是用它所在線程的Values來存T對象的；我們在線程中每次調用ThreadLocal的set方法時，實際上是將object寫入線程對應Values對象的過程；調用ThreadLocal的get方法時，實際上是從線程對應Values對象取object的過程。
看源碼：
ThreadLocal 的成員變量set
/** * Sets the value of this variable for the current thread. If set to * {@code null}, the value will be set to null and the underlying entry will * still be present. * * @param value the new value of the variable for the caller thread. */public void set(T value) { Thread currentThread = Thread.currentThread(); Values values = values(currentThread); if (values == null) { values = initializeValues(currentThread); } values.put(this, value);}TreadLocal 的成員方法get
/** * Returns the value of this variable for the current thread. If an entry * doesn't yet exist for this variable on this thread, this method will * create an entry, populating the value with the result of * {@link #initialValue()}. * * @return the current value of the variable for the calling thread. */@SuppressWarnings("unchecked")public T get() { // Optimized for the fast path. Thread currentThread = Thread.currentThread(); Values values = values(currentThread); if (values != null) { Object[] table = values.table; int index = hash & values.mask; if (this.reference == table[index]) { return (T) table[index + 1]; } } else { values = initializeValues(currentThread); } return (T) values.getAfterMiss(this);}ThreadLocal的成員方法initializeValues
/** * Creates Values instance for this thread and variable type. */Values initializeValues(Thread current) { return current.localValues = new Values();}ThreadLocal 的成員方法values
/** * Gets Values instance for this thread and variable type. */Values values(Thread current) { return current.localValues;}那這個Values又是怎樣讀寫Object那？
Values是作為ThreadLocal的內部類存在的；這個Values裡包括了一個重要數組Object[]，這個數據就是解答問題的關鍵部分，它是用來存儲線程本地各種類型TreadLocal變量用的；那麼問題來了，具體取某個類型的變量時是怎麼保證不取到其他類型的值那？按一般的做法會用一個Map根據key-value映射一下的；對的，思路就是這個思路，但是這裡並沒有用Map來實現，是用一個Object[]實現的Map機制；但是，若要用Map理解的話，也是不可以的，因為機制是相同的；key其實上對應ThreadLocal的弱引用，value就對應我們傳進去的Object。
解釋下是怎麼用Object[]實現Map機制的（參考圖1）；它是用數組下標的奇偶來區分key和value的，就是下表是偶數的位置存儲key，奇數存儲value，就是這樣搞得；感興趣的同學如果想知道算法實現的話，可以深入研究一下，這裡我不在詳述了。
結合前面第一個實例分析下存儲情況：
當程序執行時存在A，B和main三個線程，分別在線程中調用name.set()時同時針對三個線程實例在堆區分配了三塊相同的內存空間來存儲Values對象，以name引用作為key，具體的object作為值存進三個不同的Object[]（參看下圖）：
四、 總結
ThreadLocal 不能完全解決多線程編程時的並發問題，這種問題還要根據不同的情況選擇不同的解決方案，“空間換時間”還是“時間換空間”。
ThreadLocal最大的作用就是把線程共享變量轉換成線程本地變量，實現線程之間的隔離。
以上就是本文關於快速了解Java中ThreadLocal的全部內容，希望對大家有所幫助。如有不足之處，歡迎留言指出。感謝朋友們對本站的支持。