深入解析Java中ThreadLocal線程類的作用和用法

ThreadLocal與線程成員變量還有區別，ThreadLocal該類提供了線程局部變量。這個局部變量與一般的成員變量不一樣，ThreadLocal的變量在被多個線程使用時候，每個線程只能拿到該變量的一個副本，這是Java API中的描述，通過閱讀API源碼，發現並非副本，副本什麼概念？克隆品? 或者是別的樣子，太模糊。

準確的說，應該是ThreadLocal類型的變量內部的註冊表（Map<Thread,T>）發生了變化，但ThreadLocal類型的變量本身的確是一個，這才是本質！

下面就做個例子：

一、標準例子

定義了MyThreadLocal類，創建它的一個對象tlt，分別給四個線程使用，結果四個線程tlt變量並沒有出現共用現象，二是各用各的，這說明，四個線程使用的是tlt的副本（克隆品）。

 /** * 使用了ThreadLocal的類*/ public class MyThreadLocal { //定義了一個ThreadLocal變量，用來保存int或Integer數據private ThreadLocal<Integer> tl = new ThreadLocal<Integer>() { @Override protected Integer initialValue() { return 0; } }; public Integer getNextNum() { //將tl的值獲取後加1，並更新設置t1的值tl.set(tl.get() + 1); return tl.get(); } }

 /** * 測試線程*/ public class TestThread extends Thread { private MyThreadLocal tlt = new MyThreadLocal(); public TestThread(MyThreadLocal tlt) { this.tlt = tlt; } @Override public void run() { for (int i = 0; i < 3; i++) { System.out.println(Thread.currentThread().getName() + "/t" + tlt.getNextNum()); } } }

 /** * ThreadLocal測試*/ public class Test { public static void main(String[] args) { MyThreadLocal tlt = new MyThreadLocal(); Thread t1 = new TestThread(tlt); Thread t2 = new TestThread(tlt); Thread t3 = new TestThread(tlt); Thread t4 = new TestThread(tlt); t1.start(); t2.start(); t3.start(); t4.start(); } }

可以看出，三個線程各自獨立編號，互不影響：

 Thread-0 1 Thread-1 1 Thread-0 2 Thread-1 2 Thread-0 3 Thread-1 3 Thread-2 1 Thread-3 1 Thread-2 2 Thread-3 2 Thread-2 3 Thread-3 3 Process finished with exit code 0

tlt對像是一個，廢話tl對像也是一個，因為組合關係是一對一的。但是tl對象內部的Map隨著線程的增多，會創建很多Integer對象。只是Integer和int已經通用了。所以感覺不到Integer的對象屬性。

二、不用ThreadLocal

假如不用ThreadLocal，只需要將MyThreadLocal類重新定義為：

 /** * 使用了ThreadLocal的類*/ public class MyThreadLocal { private Integer t1 = 0; public Integer getNextNum(){ return t1=t1+1; } // 定義了一個ThreadLocal變量，用來保存int或Integer數據// private ThreadLocal<Integer> tl = new ThreadLocal<Integer>() { // @Override // protected Integer initialValue() { // return 0; // } // }; // // public Integer getNextNum() { // //將tl的值獲取後加1，並更新設置t1的值// tl.set(tl.get() + 1); // return tl.get(); // } }

然後運行測試：

 Thread-2 1 Thread-2 2 Thread-1 4 Thread-1 6 Thread-3 3 Thread-3 9 Thread-3 10 Thread-1 8 Thread-0 7 Thread-0 11 Thread-0 12 Thread-2 5 Process finished with exit code 0

從這裡可以看出，四個線程共享了tlt變量，結果每個線程都直接修改tlt的屬性。

三、自己實現個ThreadLocal

 package com.lavasoft.test2; import java.util.Collections; import java.util.HashMap; import java.util.Map; /** * 使用了ThreadLocal的類*/ public class MyThreadLocal { //定義了一個ThreadLocal變量，用來保存int或Integer數據private com.lavasoft.test2.ThreadLocal<Integer> tl = new com.lavasoft.test2.ThreadLocal<Integer>() { @Override protected Integer initialValue() { return 0; } }; public Integer getNextNum() { //將tl的值獲取後加1，並更新設置t1的值tl.set(tl.get() + 1); return tl.get(); } } class ThreadLocal<T> { private Map<Thread, T> map = Collections.synchronizedMap(new HashMap<Thread, T>()); public ThreadLocal() { } protected T initialValue() { return null; } public T get() { Thread t = Thread.currentThread(); T obj = map.get(t); if (obj == null && !map.containsKey(t)) { obj = initialValue(); map.put(t, obj); } return obj; } public void set(T value) { map.put(Thread.currentThread(), value); } public void remove() { map.remove(Thread.currentThread()); } }

運行測試：

 Thread-0 1 Thread-0 2 Thread-0 3 Thread-2 1 Thread-2 2 Thread-3 1 Thread-2 3 Thread-3 2 Thread-1 1 Thread-3 3 Thread-1 2 Thread-1 3 Process finished with exit code 0

很意外，這個山寨版的ThreadLocal也同樣運行很好，實現了JavaAPI中ThreadLocal的功能。

四、透過現像看本質

其實從程序角度看，tlt變量的確是一個，毫無疑問的。但是為什麼打印出來的數字就互不影響呢？
是因為使用了Integer嗎？ -----不是。
原因是：protected T initialValue()和get()，因為每個線程在調用get()時候，發現Map中不存在就創建。調用它的時候，就創建了一個新變量，類型為T。每次都新建，當然各用個的互不影響了。
為了看清本質，將Integer換掉，重寫部分類：

 package com.lavasoft.test2; import java.util.Collections; import java.util.HashMap; import java.util.Map; /** * 使用了ThreadLocal的類*/ public class MyThreadLocal { //定義了一個ThreadLocal變量，用來保存int或Integer數據// private ThreadLocal<Bean> tl = new ThreadLocal<Bean>() { private com.lavasoft.test2.ThreadLocal<Bean> tl = new com.lavasoft.test2.ThreadLocal<Bean>() { @Override protected Bean initialValue() { return new Bean(); } }; @Override public String toString() { return "MyThreadLocal{" + "tl=" + tl + '}'; } public Bean getBean() { return tl.get(); } } class ThreadLocal<T> { private Map<Thread, T> map = Collections.synchronizedMap(new HashMap<Thread, T>()); public ThreadLocal() { } protected T initialValue() { return null; } public T get() { Thread t = Thread.currentThread(); T obj = map.get(t); if (obj == null && !map.containsKey(t)) { obj = initialValue(); map.put(t, obj); } return obj; } public void set(T value) { map.put(Thread.currentThread(), value); } public void remove() { map.remove(Thread.currentThread()); } }

 package com.lavasoft.test2; /** * 測試Bean */ public class Bean { private String id = "0"; private String name = "none"; public Bean() { } public Bean(String id, String name) { this.id = id; this.name = name; } public String getId() { return id; } public void setId(String id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String showinfo() { return "Bean{" + "id='" + id + '/'' + ", name='" + name + '/'' + '}'; } }

 package com.lavasoft.test2; /** * 測試線程*/ public class TestThread extends Thread { private MyThreadLocal tlt = new MyThreadLocal(); public TestThread(MyThreadLocal tlt) { this.tlt = tlt; } @Override public void run() { System.out.println(">>>>>:" + tlt); for (int i = 0; i < 3; i++) { System.out.println(Thread.currentThread().getName() + "/t" +tlt.getBean()+"/t"+tlt.getBean().showinfo()); } } }

然後運行測試：

 >>>>>:MyThreadLocal{tl=com.lavasoft.test2.MyThreadLocal$1@1de3f2d} >>>>>:MyThreadLocal{tl=com.lavasoft.test2.MyThreadLocal$1@1de3f2d} >>>>>:MyThreadLocal{tl=com.lavasoft.test2.MyThreadLocal$1@1de3f2d} >>>>>:MyThreadLocal{tl=com.lavasoft.test2.MyThreadLocal$1@1de3f2d} Thread-1 com.lavasoft.test2.Bean@291aff Bean{id='0', name='none'} Thread-2 com.lavasoft.test2.Bean@fe64b9 Bean{id='0', name='none'} Thread-3 com.lavasoft.test2.Bean@186db54 Bean{id='0', name='none'} Thread-2 com.lavasoft.test2.Bean@fe64b9 Bean{id='0', name='none'} Thread-2 com.lavasoft.test2.Bean@fe64b9 Bean{id='0', name='none'} Thread-0 com.lavasoft.test2.Bean@291aff Bean{id='0', name='none'} Thread-3 com.lavasoft.test2.Bean@186db54 Bean{id='0', name='none'} Thread-3 com.lavasoft.test2.Bean@186db54 Bean{id='0', name='none'} Thread-1 com.lavasoft.test2.Bean@291aff Bean{id='0', name='none'} Thread-0 com.lavasoft.test2.Bean@291aff Bean{id='0', name='none'} Thread-0 com.lavasoft.test2.Bean@291aff Bean{id='0', name='none'} Thread-1 com.lavasoft.test2.Bean@291aff Bean{id='0', name='none'} Process finished with exit code 0

從打印結果很清楚的看到，MyThreadLocal的tlt對象的確是一個，tlt對象裡的ThreadLocal的tl對像也是一個，但是，將t1t給每個線程用的時候，線程會重新創建Bean對象加入到ThreadLocal的Map中去使用。

關於ThreadLocal的幾個誤區：
一、ThreadLocal是java線程的一個實現

ThreadLocal的確是和java線程有關，不過它並不是java線程的一個實現，它只是用來維護本地變量。針對每個線程，提供自己的變量版本，主要是為了避免線程衝突，每個線程維護自己的版本。彼此獨立，修改不會影響到對方。

二、ThreadLocal是相對於每個session的

ThreadLocal顧名思義，是針對線程。在java web編程上，每個用戶從開始到會話結束，都有自己的一個session標識。但是ThreadLocal並不是在會話層上。其實，Threadlocal是獨立於用戶session的。它是一種服務器端行為，當服務器每生成一個新的線程時，就會維護自己的ThreadLocal。

對於這個誤解，個人認為應該是開發人員在本地基於一些應用服務器測試的結果。眾所周知，一般的應用服務器都會維護一套線程池，也就是說，對於每次訪問，並不一定就新生成一個線程。而是自己有一個線程緩存池。對於訪問，先從緩存池裡面找到已有的線程，如果已經用光，才去新生成新的線程。

所以，由於開發人員自己在測試時，一般只有他自己在測，這樣服務器的負擔很小，這樣導致每次訪問可能是共用同樣一個線程，導致會有這樣的誤解：每個session有一個ThreadLocal

三、ThreadLocal是相對於每個線程的，用戶每次訪問會有新的ThreadLocal

理論上來說，ThreadLocal是的確是相對於每個線程，每個線程會有自己的ThreadLocal。但是上面已經講到，一般的應用服務器都會維護一套線程池。因此，不同用戶訪問，可能會接受到同樣的線程。因此，在做基於TheadLocal時，需要謹慎，避免出現ThreadLocal變量的緩存，導致其他線程訪問到本線程變量

四、對每個用戶訪問，ThreadLocal可以多用

可以說，ThreadLocal是一把雙刃劍，用得來的話可以起到非常好的效果。但是，ThreadLocal如果用得不好，就會跟全局變量一樣。代碼不能重用，不能獨立測試。因為，一些本來可以重用的類，現在依賴於ThreadLocal變量。如果在其他沒有ThreadLocal場合，這些類就變得不可用了。個人覺得ThreadLocal用得很好的幾個應用場合，值得參考

1、存放當前session用戶：quake want的jert

2、存放一些context變量，比如webwork的ActionContext

3、存放session，比如Spring hibernate orm的session