徹底理解ThreadLocal

知其然

來看一個運用ThreadLocal來實現資料庫連線Connection物件執行緒隔離的例子。

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class ConnectionManager {

	private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>() {
		@Override
		protected Connection initialValue() {
			Connection conn = null;
			try {
				conn = DriverManager.getConnection(
						"jdbc:mysql://localhost:3306/test", "username",
						"password");
			} catch (SQLException e) {
				e.printStackTrace();
			}
			return conn;
		}
	};

	public static Connection getConnection() {
		return connectionHolder.get();
	}

	public static void setConnection(Connection conn) {
		connectionHolder.set(conn);
	}
}
 

知其所以然

那麼到底ThreadLocal類是如何實現這種“為每個執行緒提供不同的變數拷貝”的呢？先來看一下ThreadLocal的set()方法的原始碼是如何實現的：

    /**
     * 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);
    }

    /**
     * Get the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param  t the current thread
     * @return the map
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

    /**
     * Create the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param t the current thread
     * @param firstValue value for the initial entry of the map
     * @param map the map to store.
     */
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

    /* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;

    /**
     * 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();
    }

    /**
     * Variant of set() to establish initialValue. Used instead
     * of set() in case user has overridden the set() method.
     *
     * @return the initial value
     */
    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物件是以this指向的ThreadLocal物件為鍵進行查詢的，這當然和前面set()方法的程式碼是相呼應的。


進一步地，我們可以建立不同的ThreadLocal例項來實現多個變數在不同執行緒間的訪問隔離，為什麼可以這麼做？因為不同的ThreadLocal物件作為不同鍵，當然也可以線上程的ThreadLocalMap物件中設定不同的值了。通過ThreadLocal物件，在多執行緒中共享一個值和多個值的區別，就像你在一個HashMap物件中儲存一個鍵值對和多個鍵值對一樣，僅此而已。


設定到這些執行緒中的隔離變數，會不會導致記憶體洩漏呢？ThreadLocalMap物件儲存在Thread物件中，當某個執行緒終止後，儲存在其中的執行緒隔離的變數，也將作為Thread例項的垃圾被回收掉，所以完全不用擔心記憶體洩漏的問題。在多個執行緒中隔離的變數，光榮的生，合理的死，真是圓滿，不是麼？


最後再提一句，ThreadLocal變數的這種隔離策略，也不是任何情況下都能使用的。如果多個執行緒併發訪問的物件例項只允許，也只能建立那麼一個，那就沒有別的辦法了，老老實實的使用同步機制來訪問吧。

參考地址：https://my.oschina.net/lichhao/blog/111362