ThreadLocal內部機制及使用方法

一、介紹ThreadLocal內部機制之前，先簡單說明一下其特點及用途：

1.ThreadLocal是單線程內共享資源，多線程間無法共享（即線程A訪問不了線程B中ThreadLocal存放的值）；

2.ThreadLocal是本地變量，無法跨jvm傳遞；

3.ThreadLocal的出現可以減少通過參數來傳遞（使代碼更加簡潔，降低耦合性），Hibernate中的OpenSessionInView，就始終保證當前線程只有一個在使用中的Connection（或Hibernate Session），代碼如下：

public class ConnectionManager {  
  
    /** 線程內共享Connection，ThreadLocal通常是全局的，支持泛型 */  
    private static ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();  
      
    public static Connection getCurrConnection() {  
        // 獲取當前線程內共享的Connection  
        Connection conn = threadLocal.get();  
        try {  
            // 判斷連接是否可用  
            if(conn == null || conn.isClosed()) {  
                // 創建新的Connection賦值給conn(略)  
                // 保存Connection  
                threadLocal.set(conn);  
            }  
        } catch (SQLException e) {  
            // 異常處理  
        }  
        return conn;  
    }  
      
    /** 
     * 關閉當前數據庫連接 
     */  
    public static void close() {  
        // 獲取當前線程內共享的Connection  
        Connection conn = threadLocal.get();  
        try {  
            // 判斷是否已經關閉  
            if(conn != null && !conn.isClosed()) {  
                // 關閉資源  
                conn.close();  
                // 移除Connection  
                threadLocal.remove();  
                conn = null;  
            }  
        } catch (SQLException e) {  
            // 異常處理  
        }  
    }  
}  

二、ThreadLocal的內部方法

1.protected T initialValue()

①該方法實現只返回 null，並且修飾符為protected，很明顯，如果用戶想返回初始值不為null，則需要定義線程變量時重寫該方法；

    /**
     * @return the initial value for this thread-local
     */
    protected T initialValue() {
        return null;
    }

//定義ThreadLocal時重寫initialValue方法，返回用戶想要的值
private static ThreadLocal t = new ThreadLocal() {
    public Object initialValue() {
        A a = new A();
        return a;
    }
};

②返回此線程局部變量的當前線程的初始值。最多在每次訪問線程來獲得每個線程局部變量時調用此方法一次，即線程第一次使用 get() 方法訪問變量的時候。如果線程先於 get 方法調用 set(T) 方法，則不會在線程中再調用 initialValue 方法。

    /**
     * Returns the value in the current thread's copy of this
     * thread-local variable.  If the variable has no value for the
     * current thread, it is first initialized to the value returned
     * by an invocation of the {@link #initialValue} method.
     *
     * @return the current thread's value of this thread-local
     */
    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();
    }    

2.public T get()
①在1中已經提到，該方法返回當前線程變量副本。如果這是線程第一次調用該方法，則創建並初始化此副本。

3.public void set(T value)

①ThreadLocal中有個內部靜態類ThreadLocalMap，用來存放當前線程變量副本中的值，鍵為當前線程變量對象，值為用戶設的值；

②當使用ThreadLocal存值時，首先是獲取到當前線程對象，然后獲取到當前線程本地變量Map，最后將當前使用的ThreadLocal和傳入的值放到Map中，也就是說ThreadLocalMap中存的值是[ThreadLocal對象, 存放的值]，這樣做的好處是，每個線程都對應一個本地變量的Map，所以一個線程可以存在多個線程本地變量（即不同的ThreadLocal，就如1中所說，可以重寫initialValue，返回不同類型的子類）。

    /**
     * Sets the current thread's copy of this thread-local variable
     * to the specified value.  Most subclasses will have no need to
     * override this method, relying solely on the {@link #initialValue}
     * method to set the values of thread-locals.
     *
     * @param value the value to be stored in the current thread's copy of
     *        this thread-local.
     */
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

4.public void remove()

①移除此線程中某個ThreadLocal的值，目的是為了減少內存的占用。如果再次訪問此線程局部變量，那么在默認情況下它將擁有其initialValue；

②只有從jdk1.5開始才有該方法；

③當線程結束后，對應該線程的局部變量將自動被垃圾回收，因此顯式調用remove清除線程的局部變量並不是必須的操作，但它可以加快內存回收的速度。

     /**
     * Removes the current thread's value for this thread-local
     * variable.  If this thread-local variable is subsequently
     * {@linkplain #get read} by the current thread, its value will be
     * reinitialized by invoking its {@link #initialValue} method,
     * unless its value is {@linkplain #set set} by the current thread
     * in the interim.  This may result in multiple invocations of the
     * <tt>initialValue</tt> method in the current thread.
     *
     * @since 1.5
     */
     public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

三、ThreadLocal和同步機制synchonzied相比

1.synchonzied同步機制是為了實現同步多線程對相同資源的並發訪問控制。同步的主要目的是保證多線程間的數據共享。同步會帶來巨大的性能開銷，所以同步操作應該是細粒度的（對象中的不同元素使用不同的鎖，而不是整個對象一個鎖）。如果同步使用得當，帶來的性能開銷是微不足道的。使用同步真正的風險是復雜性和可能破壞資源安全,而不是性能。 

2.ThreadLocal以空間換取時間，提供了一種非常簡便的多線程實現方式。因為多個線程並發訪問無需進行等待，所以使用ThreadLocal會獲得更大的性能。

3.ThreadLocal中的對象，通常都是比較小的對象。另外使用ThreadLocal不能使用原子類型，只能使用Object類型。ThreadLocal的使用比synchronized要簡單得多。 

4.synchronized是利用鎖的機制，使變量或代碼塊在某一時該只能被一個線程訪問。而ThreadLocal為每一個線程都提供了變量的副本，使得每個線程在某一時間訪問到的並不是同一個對象，這樣就隔離了多個線程對數據的數據共享。而Synchronized卻正好相反，它用於在多個線程間通信時能夠獲得數據共享。 

5.Synchronized用於線程間的數據共享，而ThreadLocal則用於線程間的數據隔離。