前段時間面試都遇到了有關ThreadLocal有關的問題，今天正好寫到了多執行緒,乾脆對ThreadLocal進行一個從簡單理解，到使用，到原始碼理解的學習和分析。

              1.ThreadLocal是什麼

              ThreadLocal正如他的中文翻譯 執行緒本地變數所說，顧名思義，就是每個執行緒自己的本地變數。簡單的來說，就是在多執行緒的程式中，我們一般會申請共享變數。給所有執行緒使用。但是很多情況下，每個執行緒會對共享變數進行改變。比如，一個String 型別的static變數，執行緒一將String 賦值為 “執行緒一”

，然後在跑其他的邏輯的時候，第二個執行緒將String 又改成了“執行緒二”，那麼就會出個問題，執行緒一跑到後面在對該String進行使用的時候，就發現值已經被改變了。

                       ThreadLocal的價值就體現了出來。就是在每個執行緒裡面對變數單獨記錄儲存。這樣，執行緒二對String的改變就是對自己內部改變，不會影響別的執行緒中的String值。

              針對這個，寫個程式碼進行了一個測試，方便理解。

package zxy.maven.product;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//
public class ThreadTest {
	// threadLocal Test
	public static ThreadLocal<String> threadLocal = new ThreadLocal<String>();
    
	public static String baseString ="";
	
	
	public static ExecutorService  executorService=Executors.newFixedThreadPool(4);

	
	private static void setTLocal(String value) {
		threadLocal.set(value);
	}

	private static String getTlocal() {
		return "ThreadLocal儲存:"+Thread.currentThread().getName()+" : "+ threadLocal.get();
	}
	
	private static void setBLocal(String value) {
		baseString=value;
	}

	private static String getBlocal() {
		return "Baseocal儲存:   "+Thread.currentThread().getName()+" : "+baseString;
	}
	
	
	
	public static void main(String[] args) throws InterruptedException {

		Thread thread=new Thread(new Runnable() {
			public void run() {
				setTLocal("子執行緒一儲存變數");
				try {
					//睡眠一秒，模擬在處理某些程式
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(getTlocal());
			}
		});
		
		Thread thread2=new Thread(new Runnable() {
			public void run() {
				setTLocal("子執行緒二儲存變數");
				System.out.println(getTlocal());
			}
		});
		
		executorService.execute(thread);
		executorService.execute(thread2);
		
		setTLocal("主執行緒儲存變數");
		System.out.println(getTlocal());
		
		Thread.sleep(1000);
		
		
		
		Thread thread3=new Thread(new Runnable() {
			public void run() {
				setBLocal("子執行緒一儲存變數");
				try {
					//睡眠一秒，模擬在處理某些程式
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.err.println(getBlocal());
			}
		});
		
		Thread thread4=new Thread(new Runnable() {
			public void run() {
				setBLocal("子執行緒二儲存變數");
				System.err.println(getBlocal());
			}
		});
		
		executorService.execute(thread3);
		executorService.execute(thread4);
		
		setBLocal("主執行緒儲存變數");
		System.err.println(getBlocal());	
	}	
}
 

           

                     看到結果，ThreadLocal儲存的變數沒有因為其他原因改變。但是Basecal的變了，因為當執行的時候，主執行緒執行完了輸出，執行緒一將String 修改為“子執行緒一儲存變數”，進入睡眠,執行緒二進行修改，改String 為子執行緒二，這時候輸出的時候，就變成了兩個子執行緒二了。

                    如此就體現了ThreadLocal的價值，就是保證執行緒之間的變數處理互不影響。

                   2.ThreadLocal是怎麼實現的執行緒本地

 從程式碼上來看看怎麼實現了這個功能吧。

                    ThreadLocal內部主要的幾個方法就是   public T get()， public void set(T value)， public void remove()，分別是獲取本地變數，儲存本地變數和刪除變數                    從get方法開始看       public T get()：

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

    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

               很簡單，就是先獲取當前正在執行的執行緒，獲取當前執行的執行緒的ThreadLocalMap(每個Thread都有一個名字叫threadLocals  型別為ThreadLocal.ThreadLocalMap的變數)。如果，當前Thread的ThreadLocalMap不為空，即已經通過set或者initialValue初始化過，則直接返回有關物件型別。                如果當前執行緒的ThreadLocalMap為空，則處理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;
    }

                       該方法的作用是對ThreadLocalMap進行初始化。首先如果有重寫initialValue方法，則將重寫的初始化物件給T，然後在嘗試查一下當前執行緒ThreadLocalMap有沒有值，有值則將初始化的值也set進去，沒有值得話就建立一個新的map,把當前執行緒和T當做引數傳遞給createMap。

  void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

            createMap很簡單，就是把當前執行緒的ThreadLocalMap用初始化的值儲存一下。               public void set(T value)

    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

         看完了setInitialValue方法，其實這個就太簡單了，只是把初始化的那個值換成了set 的value值，儲存在了ThreadLocalMap裡面，其他沒有變化。     public void remove()

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

                   remove方法也非常簡單，就是獲取當前執行緒的ThreadLocalMap，如果不為空的話，把他清除掉。

                 看完了這些方法，基本上ThreadLocal也就完全明白了，其實還是比較簡單的一個實現的東西。