如果轉載請聲明，轉自【https://www.cnblogs.com/andy-songwei/p/12040372.html】，謝謝！
本文的主要內容為：
1、一個生活中的場景
鑒於普羅大眾都喜歡看熱鬧，咱們先來看個熱鬧再開工吧！
場景一：
中午了， 張三、李四和王五一起去食堂大菜吃飯。食堂剛經營不久，還很簡陋，負責打菜的只有一位老阿姨。 張三：我要一份雞腿。 李四：我要一份小雞燉蘑菇。 張三：我再要一份紅燒肉。 王五：我要一份紅燒排骨。 李四：我不要小雞燉蘑菇了，換成紅燒鯽魚。 王五：我再要一份椒鹽蝦。 張三：我再要一份梅菜扣肉。 ...... 張三：我點的紅燒肉，為啥給我打紅燒鯽魚？ 李四：我的紅燒鯽魚呢？ 王五：我有點紅燒肉嗎？ ...... 李四：我點了15元的菜，為啥扣我20？ 王五：我點了20元的菜，只扣了我15元，賺了，竊喜！ 張三：我已經刷了卡了，怎么還叫我刷卡？ ...... 老阿姨畢竟上了年紀，不那么利索，這幾個小伙子咋咋呼呼，快言快語，老阿姨也被攪暈了，手忙腳亂，忙中出錯，這仨小伙也是怨聲載道。 場景二： 食堂領導看到這個場景，趕緊要求大家排隊，一個一個來。后來，老阿姨輕松多了，也沒有再犯錯了。 但是，新的問題又來了，打菜的人當中，很多妹子很磨嘰，點個菜猶猶豫豫想半天。 張三：太慢了，我快餓死了！ 李四：再這么慢，下次去別家！ 王五：我等得花兒都謝啦！ 趙六：啥？我點了啥菜，花了多少錢，其它人怎么都知道？是阿姨多嘴了，還是其它人偷偷關注我很久了？太不安全了，一點隱私都沒有，以后不來了。 ...... 場景三： 領導聽到這些怨言，心里很不是滋味，大手一揮：擴大經營，以后為你們每一個人開一個流動窗口並請一位私人阿姨，只為你一個人服務！ 從此，再也沒有怨言，阿姨也沒有再犯錯了，皆大歡喜......
場景一就像多個線程同時去操作一個數據，最終的結果就是混亂。於是出現了同步鎖synchronized，同一時刻只運行一個線程操作，就像場景二，大家先來后到排隊，混亂的問題解決了。但是此時一個線程在操作的時候，其它線程只能閑等着，而且這些數據是共享的，每個線程希望擁有只能自己操作的私人數據，ThreadLocal就正好滿足了這個需求。
所以，相比於synchronized，Threadlocal通過犧牲空間來換取時間和效率。
2、ThreadLocal簡介
ThreadLocal官方的介紹為：
1 /** 2 * This class provides thread-local variables. These variables differ from 3 * their normal counterparts in that each thread that accesses one (via its 4 * {@code get} or {@code set} method) has its own, independently initialized 5 * copy of the variable. {@code ThreadLocal} instances are typically private 6 * static fields in classes that wish to associate state with a thread (e.g., 7 * a user ID or Transaction ID). 8 */
大致意思是：ThreadLocal提供了線程本地變量。這些變量與一般變量相比，其不同之處在於，通過它的get()和set()方法，每個線程可以訪問自己獨立擁有的初始變量副本。翻譯成人話就是，ThreadLocal為每一個線程開辟了一個獨立的存儲器，只有對應的線程才能夠訪問其數據，其它線程則無法訪問。對應於前文的場景，就像食堂為每一個人安排了一個窗口和專屬阿姨為其打菜，這個過程中，這個窗口和阿姨就是其專屬的獨立的資源，其他人就無從知道他點了什么菜，花了多少錢。
3、ThreadLocal的簡單使用示例
是騾子是馬，先拉出來溜溜！先直觀看看它的能耐，再來了解它豐富的內心：
1 // =========實例3.1======== 2 private ThreadLocal<String> mThreadLocal = new ThreadLocal<>(); 3 private void testThreadLocal() throws InterruptedException { 4 mThreadLocal.set("main-thread"); 5 Log.i("threadlocaldemo", "result-1=" + mThreadLocal.get()); 6 Thread thread_1 = new Thread() { 7 @Override 8 public void run() { 9 super.run(); 10 mThreadLocal.set("thread_1"); 11 Log.i("threadlocaldemo", "result-2=" + mThreadLocal.get()); 12 } 13 }; 14 thread_1.start(); 15 //該句表示thread_1執行完后才會繼續執行 16 thread_1.join(); 17 Thread thread_2 = new Thread() { 18 @Override 19 public void run() { 20 super.run(); 21 Log.i("threadlocaldemo", "result-3=" + mThreadLocal.get()); 22 } 23 }; 24 thread_2.start(); 25 //該句表示thread_2執行完后才會繼續執行 26 thread_2.join(); 27 Log.i("threadlocaldemo", "result-4=" + mThreadLocal.get()); 28 }
在主線程中調用這個方法，運行結果：
1 12-13 13:42:50.117 25626-25626/com.example.demos I/threadlocaldemo: result-1=main-thread 2 12-13 13:42:50.119 25626-25689/com.example.demos I/threadlocaldemo: result-2=thread_1 3 12-13 13:42:50.119 25626-25690/com.example.demos I/threadlocaldemo: result-3=null 4 12-13 13:42:50.120 25626-25626/com.example.demos I/threadlocaldemo: result-4=main-thread
看到這個結果會不會驚掉下巴呢？明明在第9行中set了值，第10行中也得到了對應的值，但第20行的get得到的卻是null，第26行得到的是第3行set的值。這就是ThreadLocal的神奇功效，主線程set的值，只能在主線程get到；thread_1內部set的值，thread_1中才能get；thread_2中沒有set，所以get到的就是null。
而實現這，不要999，也不要99，只要3......三步即可：
1 ThreadLocal<T> mThreadLocal = new ThreadLocal<>(); 2 mThreadLocal.set(T); 3 mThreadLocal.get();
就是這么方便，就是這么簡潔！
4、提供的4個主要接口
ThreadLocal以其使用簡單，風格簡潔讓人一見傾心。它對外提供的接口很少，當前SDK中，主要有4個：
1 public void set(T value) { } 2 public T get() { } 3 public void remove() { } 4 protected T initialValue() { }
為了保持對這些方法說明的原滋原味，我們直接通過源碼中對其的注釋說明來認識它們。
（1）set()
1 /** 2 * Sets the current thread's copy of this thread-local variable 3 * to the specified value. Most subclasses will have no need to 4 * override this method, relying solely on the {@link #initialValue} 5 * method to set the values of thread-locals. 6 * 7 * @param value the value to be stored in the current thread's copy of 8 * this thread-local. 9 */ 10 public void set(T value)
設置當前線程的ThreadLocal值為指定的value。大部分子類沒有必要重寫該方法，可以依賴initialValue()方法來設置ThreadLocal的值。
（2）get()
1 /** 2 * Returns the value in the current thread's copy of this 3 * thread-local variable. If the variable has no value for the 4 * current thread, it is first initialized to the value returned 5 * by an invocation of the {@link #initialValue} method. 6 * 7 * @return the current thread's value of this thread-local 8 */ 9 public T get()
用於獲取當前線程所對應的ThreadLocal值。如果當前線程下，該變量沒有值，會通過調用initialValue()方法返回的值對其進行初始化。
（3）remove()
1 /** 2 * Removes the current thread's value for this thread-local 3 * variable. If this thread-local variable is subsequently 4 * {@linkplain #get read} by the current thread, its value will be 5 * reinitialized by invoking its {@link #initialValue} method, 6 * unless its value is {@linkplain #set set} by the current thread 7 * in the interim. This may result in multiple invocations of the 8 * {@code initialValue} method in the current thread. 9 * 10 * @since 1.5 11 */ 12 public void remove()
該接口是從JDK1.5開始提供的，用於刪除當前線程對應的ThreadLocal值，從而減少內存占用。在同一線程中，如果該方法被調用了，隨后再調用get()方法時，會使得initialValue()被調用，從而ThreadLocal的值被重新初始化，除非此時在調用get()前調用了set()來賦值。該方法可能導致initialValue()被多次調用。該方法可以不用顯示調用，因為當線程結束后，系統會自動回收線程局部變量值。所以該方法不是必須調用的，只不過顯示調用可以加快內存回收。
（4）initialValue()
1 /** 2 * Returns the current thread's "initial value" for this 3 * thread-local variable. This method will be invoked the first 4 * time a thread accesses the variable with the {@link #get} 5 * method, unless the thread previously invoked the {@link #set} 6 * method, in which case the {@code initialValue} method will not 7 * be invoked for the thread. Normally, this method is invoked at 8 * most once per thread, but it may be invoked again in case of 9 * subsequent invocations of {@link #remove} followed by {@link #get}. 10 * 11 * <p>This implementation simply returns {@code null}; if the 12 * programmer desires thread-local variables to have an initial 13 * value other than {@code null}, {@code ThreadLocal} must be 14 * subclassed, and this method overridden. Typically, an 15 * anonymous inner class will be used. 16 * 17 * @return the initial value for this thread-local 18 */ 19 protected T initialValue() { 20 return null; 21 }
返回當前線程對應的ThreadLocal的初始值。當當前線程是通過get()方法第一次對ThreadLocal進行訪問時，該方法將會被調用，除非當前線程之前調用過set()方法，在這種情況下initialValue()方法將不會被當前線程所調用。一般而言，該方法最多只會被每個線程調用一次，除非隨后在當前線程中調用remove()方法，然后調用get()方法。該實現會簡單地返回null；如果程序員希望ThreadLocal擁有一個初始值，而不是null，ThreadLocal需要定義一個子類，並且在子類中重寫initialValue()方法。比較典型的做法是使用一個匿名內部類。該方法由protected修飾，可見其這樣設計通常是為了供用戶重寫，從而自定義初始值。后面會再通過實例來演示該方法的使用。
5、ThreadLocal工作機制
ThreadLocal使用起來非常簡單，但它是如何實現為每一個Thread保存一份獨立的數據的呢？我們先結合實例3.1來看set()方法都做了些什么：
1 //=========ThreadLocal=======源碼5.1 2 public void set(T value) { 3 Thread t = Thread.currentThread(); 4 ThreadLocalMap map = getMap(t); 5 if (map != null) 6 map.set(this, value); 7 else 8 createMap(t, value); 9 }
首先就是獲取當前的線程，然后根據當前線程來獲取一個ThreadLocalMap，如果map不為null，就往map中插入指定值，注意這的key是ThreadLocal實例；如果map為null，就創建一個map。看看第4行getMap(t)做了啥：
1 //=========ThreadLocal=======源碼5.2 2 /** 3 * Get the map associated with a ThreadLocal. 4 * ...... 5 */ 6 ThreadLocalMap getMap(Thread t) { 7 return t.threadLocals; 8 } 9 10 /** 11 * ThreadLocalMap is a customized hash map suitable only for 12 * maintaining thread local values...... 13 */ 14 static class ThreadLocalMap { 15 ...... 16 } 17 18 //==========Thread======== 19 ThreadLocal.ThreadLocalMap threadLocals = null;
getMap()返回的是指定線程（也就是當前線程）的threadLocals變量，這個變量是ThreadLocal.ThreadLocalMap類型的，而ThreadLocalMap是一個僅適用於維護線程本地變量值的自定義的HashMap。簡單來說，就是返回當前線程下的一個自定義HashMap。
下面我抽取了ThreadLocalMap的部分代碼，先來總體上認識它（這里我們不需要讀懂其中的每一行代碼，知道它里面主要做了哪些事就可以了）：
1 //=========源碼5.3======== 2 static class ThreadLocalMap { 3 4 static class Entry extends WeakReference<ThreadLocal<?>> { 5 /** The value associated with this ThreadLocal. */ 6 Object value; 7 8 Entry(ThreadLocal<?> k, Object v) { 9 super(k); 10 value = v; 11 } 12 } 13 14 /** 15 * The initial capacity -- MUST be a power of two. 16 */ 17 private static final int INITIAL_CAPACITY = 16; 18 19 /** 20 * The table, resized as necessary. 21 * table.length MUST always be a power of two. 22 */ 23 private Entry[] table; 24 25 /** 26 * The number of entries in the table. 27 */ 28 private int size = 0; 29 30 /** 31 * The next size value at which to resize. 32 */ 33 private int threshold; // Default to 0 34 35 /** 36 * Set the resize threshold to maintain at worst a 2/3 load factor. 37 */ 38 private void setThreshold(int len) { 39 threshold = len * 2 / 3; 40 } 41 42 ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) { 43 table = new Entry[INITIAL_CAPACITY]; 44 int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1); 45 table[i] = new Entry(firstKey, firstValue); 46 size = 1; 47 setThreshold(INITIAL_CAPACITY); 48 } 49 50 /** 51 * Get the entry associated with key. 52 * ...... 53 */ 54 private Entry getEntry(ThreadLocal<?> key) { 55 int i = key.threadLocalHashCode & (table.length - 1); 56 Entry e = table[i]; 57 if (e != null && e.get() == key) 58 return e; 59 else 60 return getEntryAfterMiss(key, i, e); 61 } 62 63 /** 64 * Set the value associated with key. 65 * ...... 66 */ 67 private void set(ThreadLocal<?> key, Object value) { 68 69 // We don't use a fast path as with get() because it is at 70 // least as common to use set() to create new entries as 71 // it is to replace existing ones, in which case, a fast 72 // path would fail more often than not. 73 74 Entry[] tab = table; 75 int len = tab.length; 76 int i = key.threadLocalHashCode & (len-1); 77 78 for (Entry e = tab[i]; 79 e != null; 80 e = tab[i = nextIndex(i, len)]) { 81 ThreadLocal<?> k = e.get(); 82 83 if (k == key) { 84 e.value = value; 85 return; 86 } 87 88 if (k == null) { 89 replaceStaleEntry(key, value, i); 90 return; 91 } 92 } 93 94 tab[i] = new Entry(key, value); 95 int sz = ++size; 96 if (!cleanSomeSlots(i, sz) && sz >= threshold) 97 rehash(); 98 } 99 100 /** 101 * Remove the entry for key. 102 */ 103 private void remove(ThreadLocal<?> key) { 104 Entry[] tab = table; 105 int len = tab.length; 106 int i = key.threadLocalHashCode & (len-1); 107 for (Entry e = tab[i]; 108 e != null; 109 e = tab[i = nextIndex(i, len)]) { 110 if (e.get() == key) { 111 e.clear(); 112 expungeStaleEntry(i); 113 return; 114 } 115 } 116 } 117 118 /** 119 * Double the capacity of the table. 120 */ 121 private void resize() { 122 ...... 123 } 124 }
這里面維護了一個Entry[] table數組，初始容量為16，當數據超過當前容量的2/3時，就開始擴容，容量增大一倍。每一個Entry的K為ThreadLocal對象，V為要存儲的值。每一個Entry在數組中的位置，是根據其K（即ThreadLocal對象）的hashCode & (len - 1)來確定，如第44行所示，這里K的hashCode是系統給出的一個算法計算得到的。如果碰到K的hashCode值相同，即hash碰撞的場景，會采用尾插法形成鏈表。當對這個map進行set，get，remove操作的時候，也是通過K的hashCode來確定該Entry在table中的位置的，采用hashCode來查找數據，效率比較高。這也是HashMap底層實現的基本原理，如果研究過HashMap源碼，這段代碼就應該比較容易理解了。
繼續看源碼5.1，第一次調用的時候，顯然map應該是null，就要執行第8行createMap了，
1 //==========ThreadLocal=========源碼5.4 2 void createMap(Thread t, T firstValue) { 3 t.threadLocals = new ThreadLocalMap(this, firstValue); 4 }
結合ThreadLocalMap源碼第41行的構造方法，就清楚了這個方法創建了一個ThreadLocalMap對象，並存儲了一個Entry<當前的ThreadLocal對象，value>。此時，在當前的線程下擁有了一個ThreadLocalMap，這個ThreadLocalMap中維護了一個容量為16的table，table中存儲了一個以當前的ThreadLocal對象為K，value值為V的Entry。Thread、ThreadLocalMap、ThreadLocal、Entry之間的關系可以表示為下圖：
圖5.1
而如果當前Thread的map已經存在了，源碼5.1就會執行第6行了，進而執行ThreadLocalMap中的set方法。結合前面對ThreadLocalMap的介紹，想必這個set方法也容易理解了，大致過程是：
1）根據Thread找到map；
2）通過傳入的this(即ThreadLocal對象)，得到hashCode；
3）根據hashCode & (len - 1)確定對應Entry在table中的位置；
4）如果該Entry存在，則替換Value，否則新建（ThreadLocalMap源碼第78~92行表示在具有相同hashCode的Entry鏈表上找到對應的Entry，這和hash碰撞有關）。
在調用ThreadLocal的get方法時又做了什么呢？看看其源碼：
1 //=========ThreadLocal======源碼5.5 2 public T get() { 3 Thread t = Thread.currentThread(); 4 ThreadLocalMap map = getMap(t); 5 if (map != null) { 6 ThreadLocalMap.Entry e = map.getEntry(this); 7 if (e != null) { 8 @SuppressWarnings("unchecked") 9 T result = (T)e.value; 10 return result; 11 } 12 } 13 return setInitialValue(); 14 }
現在，第12行及以前的代碼應該很容易理解了，結合ThreadLocalMap中的get源碼，我們再梳理一下：
1）根據Thread找到自己的map；
2）在map中通過this（即ThreadLocal對象）得到hashCode；
3）通過hashCode & （len-1）找到對應Entry在table中的位置；
4）返回Entry的value。
而如果map為null，或者在map中找到的Entry為null，那么就執行第20行了。
1 //==========ThreadLocal========源碼5.6 2 private T setInitialValue() { 3 T value = initialValue(); 4 Thread t = Thread.currentThread(); 5 ThreadLocalMap map = getMap(t); 6 if (map != null) 7 map.set(this, value); 8 else 9 createMap(t, value); 10 return value; 11 } 12 13 protected T initialValue() { 14 return null; 15 }
第13行的initialValue()方法，前面介紹過，可以讓子類重寫，即給ThreadLocal指定初始值；如果沒有重寫，那返回值就是null。第4~9行前面也介紹過了，使用或者創建map來存入該值。
最后還一個remove()方法
1 //======ThreadLocal====== 2 public void remove() { 3 ThreadLocalMap m = getMap(Thread.currentThread()); 4 if (m != null) 5 m.remove(this); 6 }
結合ThrealLocalMap中的remove方法，完成對ThreadLocal值的刪除。其大致流程為：
1）根據當前Thread找到其map；
2）根據ThreadLocal對象得到hashCode；
3）通過hashCode & (len -1)找到在table中的位置；
4）在table中查找對應的Entry，如果存在則刪除。
總結：通過對提供的4個接口方法的分析，我們應該就能清楚了，ThreadLocal之所以能夠為每一個線程維護一個副本，是因為每個線程都擁有一個map，這個map就是每個線程的專屬空間。也就是存在下面的關系圖（不用懷疑，該圖和圖5.1相比，只是少了容量大小）：
結合這一節對ThreadLocal機制的介紹，實例3.1執行后的就存在如下的數據結構了：
6、ThreadLocal在Looper中的使用
ThreadLocal在系統源碼中有很多地方使用，最典型的地方就是Handler的Looper中了。這里結合Looper中的源碼，來了解一下ThreadLocal在系統源碼中的使用。
我們知道，在一個App進程啟動的時候，會在ActiivtyThread類的main方法，也就是App的入口方法中，會為主線程准備一個Looper，如下代碼所示：
1 //======ActivityTread======源碼6.1 2 public static void main(String[] args) { 3 ...... 4 Looper.prepareMainLooper(); 5 ...... 6 }
而在子線程中實例Handler的時候，總是需要顯示調用Looper.prepare()方法來為當前線程生成一個Looper對象，以及通過Looper.myLooper()來得到自己線程的Looper來傳遞給Handler。
Looper中相關的關鍵源碼如下：
1 //==========Looper========源碼6.2 2 3 // sThreadLocal.get() will return null unless you've called prepare(). 4 static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>(); 5 private static Looper sMainLooper; 6 7 /** 8 * Initialize the current thread as a looper, marking it as an 9 * application's main looper. The main looper for your application 10 * is created by the Android environment, so you should never need 11 * to call this function yourself. See also: {@link #prepare()} 12 */ 13 public static void prepareMainLooper() { 14 prepare(false); 15 synchronized (Looper.class) { 16 if (sMainLooper != null) { 17 throw new IllegalStateException("The main Looper has already been prepared."); 18 } 19 sMainLooper = myLooper(); 20 } 21 } 22 23 /** 24 * Return the Looper object associated with the current thread. Returns 25 * null if the calling thread is not associated with a Looper. 26 */ 27 public static @Nullable Looper myLooper() { 28 return sThreadLocal.get(); 29 } 30 31 /** Initialize the current thread as a looper. 32 * ...... 33 */ 34 public static void prepare() { 35 prepare(true); 36 } 37 private static void prepare(boolean quitAllowed) { 38 if (sThreadLocal.get() != null) { 39 throw new RuntimeException("Only one Looper may be created per thread"); 40 } 41 sThreadLocal.set(new Looper(quitAllowed)); 42 } 43 44 /** 45 * Returns the application's main looper, which lives in the main thread of the application. 46 */ 47 public static Looper getMainLooper() { 48 synchronized (Looper.class) { 49 return sMainLooper; 50 } 51 }
我們可以看到不少ThreadLocal的影子，Looper也正是通過ThreadLocal來為每個線程維護一份Looper實例的。通過我們前文的介紹，這里應該能夠輕而易舉理解其中的運作機制了吧，這里就再不啰嗦了。
7、實踐是檢驗真理的唯一標准
前面介紹了ThreadLocal提供的四個接口，以及詳細講解了它的工作原理。現在我們將實例3.1做一些修改，將各個接口的功能都包含進來，並稍微增加一點復雜度，如果能夠看懂這個實例，就算是真的理解ThreadLocal了。
1 //=========實例7.1======= 2 private ThreadLocal<String> mStrThreadLocal = new ThreadLocal<String>() { 3 @Override 4 protected String initialValue() { 5 Log.i("threadlocaldemo", "initialValue"); 6 return "initName"; 7 } 8 }; 9 private ThreadLocal<Long> mLongThreadLocal = new ThreadLocal<>(); 10 private void testThreadLocal() throws InterruptedException { 11 mStrThreadLocal.set("main-thread"); 12 mLongThreadLocal.set(Thread.currentThread().getId()); 13 Log.i("threadlocaldemo", "result-1:name=" + mStrThreadLocal.get() + ";id=" + mLongThreadLocal.get()); 14 Thread thread_1 = new Thread() { 15 @Override 16 public void run() { 17 super.run(); 18 mStrThreadLocal.set("thread_1"); 19 mLongThreadLocal.set(Thread.currentThread().getId()); 20 Log.i("threadlocaldemo", "result-2:name=" + mStrThreadLocal.get() + ";id=" + mLongThreadLocal.get()); 21 } 22 }; 23 thread_1.start(); 24 //該句表示thread_1執行完后才會繼續執行 25 thread_1.join(); 26 Thread thread_2 = new Thread() { 27 @Override 28 public void run() { 29 super.run(); 30 Log.i("threadlocaldemo", "result-3:name=" + mStrThreadLocal.get() + ";id=" + mLongThreadLocal.get()); 31 } 32 }; 33 thread_2.start(); 34 //該句表示thread_2執行完后才會繼續執行 35 thread_2.join(); 36 mStrThreadLocal.remove(); 37 Log.i("threadlocaldemo", "result-4:name=" + mStrThreadLocal.get() + ";id=" + mLongThreadLocal.get()); 38 }
在主線程中運行該方法，執行結果為：
1 12-14 16:25:40.662 4844-4844/com.example.demos I/threadlocaldemo: result-1:name=main-thread;id=2 2 12-14 16:25:40.668 4844-5351/com.example.demos I/threadlocaldemo: result-2:name=thread_1;id=926 3 12-14 16:25:40.669 4844-5353/com.example.demos I/threadlocaldemo: initialValue 4 12-14 16:25:40.669 4844-5353/com.example.demos I/threadlocaldemo: result-3:name=initName;id=null 5 12-14 16:25:40.669 4844-4844/com.example.demos I/threadlocaldemo: initialValue 6 12-14 16:25:40.669 4844-4844/com.example.demos I/threadlocaldemo: result-4:name=initName;id=2
此時存在的數據結構為：
對於這份log和數據結構圖，這里就不再一一講解了，如果前面都看懂了，這些都是小菜一碟。
結語
對ThreadLocal的講解這里就結束了，能讀到這里，也足以說明你是人才，一定前途無量，祝你好運，早日走上人生巔峰！
由於經驗和水平有限，有描述不當或不准確的地方，還請不吝賜教，謝謝！