包括：

一. 什麼是 ThreadLocal

二. ThreadLocal 類中的方法簡介

三. 如何使用ThreadLocal

     3.1 3個執行緒共享一個物件，各自產生序列號

     3.2 例子：共享變數a， 使用ThreadLocal 和沒有使用的區別

四. ThreadLocal 和同步機制的比較

五.參考

一．什麼是ThreadLocal

       ThreadLocal並非一個執行緒，而是一個執行緒區域性變數。它的作用就是為使用該變數的執行緒都提供一個變數值的副本，每個執行緒都可以獨立的改變自己的副本，而不會和其他執行緒的副本造成衝突。

       從執行緒的角度看，每個執行緒都保持一個對其執行緒區域性變數副本的隱式引用，只要執行緒是活動的並且 ThreadLocal 例項是可訪問的；線上程消失之後，其執行緒區域性例項的所有副本都會被垃圾回收（除非存在對這些副本的其他引用）。

       通過ThreadLocal存取的資料，總是與當前執行緒相關，也就是說，JVM 為每個執行的執行緒，綁定了私有的本地例項存取空間，從而為多執行緒環境常出現的併發訪問問題提供了一種隔離機制。

       ThreadLocal是解決執行緒安全問題一個很好的思路，ThreadLocal類中有一個Map，用於儲存每一個執行緒的變數副本，Map中元素的鍵為執行緒物件，而值對應執行緒的變數副本，由於Key值不可重複，每一個“執行緒物件”對應執行緒的“變數副本”，而到達了執行緒安全。

      概括起來說，對於多執行緒資源共享的問題，同步機制採用了“以時間換空間”的方式，而ThreadLocal採用了“以空間換時間”的方式。前者僅提供一份變數，讓不同的執行緒排隊訪問，而後者為每一個執行緒都提供了一份變數，因此可以同時訪問而互不影響。

二．ThreadLocal類中的方法簡介

2.1 get（）方法：

public T get() {

        Thread t = Thread.currentThread();

        ThreadLocalMap map = getMap(t);

        if (map != null) {

            ThreadLocalMap.Entry e = map.getEntry(this);

            if (e != null)

                return (T)e.value;

        }

        return setInitialValue();

}
 

       返回此執行緒區域性變數的當前執行緒副本中的值。首先得到該執行緒t，由於ThreadLocal類中有一個Map，用於儲存每一個執行緒的變數的副本，所以使用ThreadLocalMap map = getMap(t);方法取得當前執行緒副本中的值，如果這是執行緒第一次呼叫該方法，即map為空，那麼呼叫setInitialValue()方法建立並初始化此副本。

2.2 remove()方法

 public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

       移除此執行緒區域性變數當前執行緒的值。這可能有助於減少執行緒區域性變數的儲存需求。如果再次訪問此執行緒區域性變數，那麼在預設情況下它將擁有其 initialValue。

public class SequenceNumber {
	
	//通過一個匿名內部類覆蓋ThreadLocal的initialValue()方法，指定初始值
	private static ThreadLocal<Integer> seqNum = new ThreadLocal<Integer>(){
		public Integer initialValue(){
			return 0;
		}
	};
	
	//獲取下一個序列號
	public int getNextNum(){
		seqNum.set(seqNum.get() + 1);
		return seqNum.get();
	}
	
	public static void main(String args[]){
		
		SequenceNumber sn = new SequenceNumber();
		
		ThreadClient t1 = new ThreadClient(sn);
		ThreadClient t2 = new ThreadClient(sn);
		ThreadClient t3 = new ThreadClient(sn);
		
		t1.start();
		t2.start();
		t3.start();
	}
	
	private static class ThreadClient extends Thread
	{
		private SequenceNumber sn;
		
		public ThreadClient(SequenceNumber sn)
		{
			this.sn = sn;
		}
		
		public void run(){
			for(int i = 0; i < 3; ++i)
			{
				System.out.println("Thread[" + Thread.currentThread().getName() +
						"] sn[" + sn.getNextNum() + "]");
			}
		}
	}
	
}

       那麼，對於這個例子來說，首先是3個執行緒共享了SequenceNumber物件，那麼如何才能保證用同一個東西，但是互不影響，這時候就用到了ThreadLocal來實現這個功能。ThreadLocal類中的Map，儲存每一個執行緒的變數副本，Map中元素的鍵為執行緒物件，而值對應執行緒的變數副本。所以，各個執行緒都是在各自的副本上做操作，互不影響。

概況說下上述程式碼流程：

1. 首先在SequenceNumber類中建立ThreadLocal物件seqNum，用來儲存執行緒間需要隔離處理的物件。
2. 建立一個獲取要隔離訪問的資料的方法getXxx()，比如上述的publicint getNextNum()方法，主要是裡面的seqNum.get()方法。
3. 在run()方法中，通過getXxx()方法獲取要操作的資料，這樣可以保證每個執行緒對應一個數據物件，在任何時刻都操作的是這個物件。

       可能會有個疑問：建立3個執行緒，這3個執行緒是什麼時候存到ThreadLocal的Map裡面的，而且是怎麼存放的，get方法取出的時候怎麼知道取哪一個。

       首先解決是什麼時候這3個執行緒存放到Map裡面的，在上述程式碼呼叫publicint getNextNum()中的seqNum.get()方法，我們看一下這個get方法：

public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null)
                return (T)e.value;
        }
        return setInitialValue();
    }

private T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }

3.2  例子：共享變數a，使用ThreadLocal和沒有使用的區別

public class Test {
	public static int a = 0;
	
	public static void main(String args[])
	{
		MyThread myThread = new MyThread();
		myThread.start();
		
		for(int i = 0; i < 5; ++i)
		{
			a = a + 1;
			System.out.println(Thread.currentThread().getName() + ":" + a);
		}
	}
	
	public static class MyThread extends Thread
	{
		public void run()
		{
			for(int i = 0; i < 5; ++i)
			{
				a = a + 1;
				System.out.println(Thread.currentThread().getName() + ":" + a);
			}
		}
	}
}

輸出結果為：

main:2
main:3
main:4
main:5
main:6
Thread-0:2
Thread-0:7
Thread-0:8
Thread-0:9
Thread-0:10

 public class Test {
	
	private static ThreadLocal<Integer> a = new ThreadLocal<Integer>(){
		public Integer initialValue(){
			return 0;
		}
	};
	
	public static void main(String args[])
	{
		MyThread myThread = new MyThread();
		myThread.start();
		
		for(int i = 0; i < 5; ++i)
		{
			a.set(a.get() + 1);
			System.out.println(Thread.currentThread().getName() + ":" + a.get());
		}
	}
	
	public static class MyThread extends Thread
	{
		public void run()
		{
			for(int i = 0; i < 5; ++i)
			{
				a.set(a.get() + 1);
				System.out.println(Thread.currentThread().getName() + ":" + a.get());
			}
		}
	}
}

輸出結果為：

main:1
main:2
main:3
main:4
main:5
Thread-0:1
Thread-0:2
Thread-0:3
Thread-0:4
Thread-0:5

再次分析下如何使用使用TheadLocal：

1. 在多執行緒的類（如上述的Test類）中，建立一個ThreadLocal物件a.

2. 建立一個獲取要隔離訪問的資料的方法getXxx().(上述直接使用THreadlocal的get方法)。

3. 在ThreadDemo類的run()方法中，通過getXxx()方法獲取要操作的資料，這樣可以保證每個執行緒對應一個數據物件，在任何時刻都操作的是這個物件。（上述例子直接就使用THreadLocal的get方法）

       ThreadLocal和執行緒同步機制相比有什麼優勢呢？ThreadLocal和執行緒同步機制都是為了解決多執行緒中相同變數的訪問衝突問題。

       在同步機制中，通過物件的鎖機制保證同一時間只有一個執行緒訪問變數。這時該變數是多個執行緒共享的，使用同步機制要求程式慎密地分析什麼時候對變數進行讀寫，什麼時候需要鎖定某個物件，什麼時候釋放物件鎖等繁雜的問題，程式設計和編寫難度相對較大。

        而ThreadLocal則從另一個角度來解決多執行緒的併發訪問。ThreadLocal會為每一個執行緒提供一個獨立的變數副本，從而隔離了多個線 程對資料的訪問衝突。因為每一個執行緒都擁有自己的變數副本，從而也就沒有必要對該變數進行同步了。ThreadLocal提供了執行緒安全的共享物件，在編 寫多執行緒程式碼時，可以把不安全的變數封裝進ThreadLocal。

       當 然ThreadLocal並不能替代同步機制，兩者面向的問題領域不同。同步機制是為了 同步多個執行緒對相同資源的併發訪問，是為了多個執行緒之間進行通訊的 有效方式；而ThreadLocal是隔離多個執行緒的資料共享，從根本上就不在多個線 程之間共享資源（變數），這樣當然不需要對多個執行緒進行同步了。所 以，如果你需要進行多個執行緒之間進行通訊，則使用同步機制；如果需要隔離多個執行緒之間 的共享衝突，可以使用ThreadLocal，這將極大地簡化你的程 序，使程式更加易讀、簡潔。

       概括起來說，對於多執行緒資源共享的問題，同步機制採用了“以時間換空間”的方式，而ThreadLocal採用了“以空間換時間”的方式。前者僅提供一份變數，讓不同的執行緒排隊訪問，而後者為每一個執行緒都提供了一份變數，因此可以同時訪問而互不影響。

五．參考

大多數內容都是以下3個網址的內容，然後對其中的一些例子加上自己的理解，有意見或者建議歡迎指出。