看到ThreadLocal的時候多少總會跟線程安全關(guān)聯(lián)在一起，因為在線程安全中涉及到共享數(shù)據(jù)，但是如果不使用共享數(shù)據(jù)如何來保證線程安全呢？網(wǎng)上有文章分析說，ThreadLocal的出現(xiàn)是為了從另外的一個角度來解決線程安全的問題，以空間換時間，每個線程擁有一份屬于自己的數(shù)據(jù)副本，線程在運行過程中彼此不互相打擾，進(jìn)水不犯河水。
這是對ThreadLocal的一個初步感性的認(rèn)識，但是真正去理解的時候，又發(fā)現(xiàn)了ThreadLocalMap這個玩意，它到底和ThreadLocal是什么關(guān)系呢，一剛開始接觸的時候確實會半天不知道在說什么，希望本文能夠整理出一份清晰的脈絡(luò)，以饗自己和其他人。

ThreadLocal的應(yīng)用場景

很多時候當(dāng)我們知道知識、技術(shù)或者其他等等在什么時候會用到的時候，往往會理解的更加迅速與透徹。這一小節(jié)會給出兩個應(yīng)用案例，一個是JDK注釋文檔上的官方案例，一個是借鑒的網(wǎng)上的資料。
在這之前先來看看，JDK源代碼ThreadLocal類最開始的英文注釋：

This class provides thread-local variables. These variables differ from their normal counterparts in that each thread that accesses one (via its {@code get} or {@code set} method) has its own, independently initialized copy of the variable. {@code ThreadLocal} instances are typically private static fields in classes that wish to associate state with a thread (e.g. a user ID or Transaction ID).

翻譯過來大概意思就是ThreadLocal提供了線程本地的變量（可以理解為數(shù)據(jù)），不同“線程同行”有不同的變量，那怎么拿到自己的那一份呢？就是通過通過ThreadLocal對象的get方法獲取每個線程自己的數(shù)據(jù)，當(dāng)然了，設(shè)置的話通過set方法。
好了，那這個ThreadLocal對象一般怎么用呢，怎么玩呢？最后一句說了，ThreadLocal實例對象一般典型的是作為一個類的私有的靜態(tài)field，與線程的一些狀態(tài)（這里的狀態(tài)是個廣義的狀態(tài)，意思應(yīng)該就是跟線程相關(guān)的數(shù)據(jù)）關(guān)系起來。更好的是官方JDK注釋給了使用案例。

case x0

public class ThreadId {
    // Atomic integer containing the next thread ID to be assigned
    private static final AtomicInteger nextId = new AtomicInteger(0);
 
    // ThreadLocal作為靜態(tài)私有變量，就是用來獲取和存儲每個線程自己的線程ID，幫你屏蔽了內(nèi)部的實現(xiàn)，壓根不用管為什么每個線程能獲取到自己的不同ID。
    private static final ThreadLocal<Integer> threadId = new ThreadLocal<Integer>() {
        //第一次get時候，會默認(rèn)調(diào)用該方法初始化,暫時不理解沒關(guān)系，你可以當(dāng)成是默認(rèn)值，后面會繼續(xù)從源碼角度分析。
        protected Integer initialValue() {
            return nextId.getAndIncrement();
        }
    };
 
    // Returns the current thread's unique ID, assigning it if necessary
    public static int get() {
          return threadId.get();
    }
    //還可以實現(xiàn)set方法，手動設(shè)置線程本地變量
}

這個官方給出的案例，相當(dāng)于ThreadId類包裹了ThreadLocal，給我們提供了一種方便的獲取和設(shè)置線程本地數(shù)據(jù)的途徑。

case x1

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

public class ConnectionManager {
    //靜態(tài)私有的ThreadLocal對象
    private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>() {
        //設(shè)置默認(rèn)值
        @Override
        protected Connection initialValue() {
            Connection conn = null;
            try {
                Class.forName("oracle.jdbc.driver.OracleDriver");
                conn = DriverManager.getConnection(
                        "jdbc:oracle:thin:@localhost:13002:orcl", "root",
                        "root");
            } catch (SQLException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            return conn;
        }
    };

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

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

按照我們前面的思路來看的話，不同的線程通過getConnection()獲取到的connection是不同的，各自使用各自不同的鏈接來操作數(shù)據(jù)庫，而每個線程總是會用自己一開始獲取的connection，只要這個connection不被清掉。

多個線程

我們先不管內(nèi)部實現(xiàn)，先來測試看看，用多個線程去獲取鏈接看是什么情況：

    public static void main(String[] args) throws SQLException {
        for (int i=0;i<10;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Connection conn=ConnectionManager.getConnection();
                    System.out.println(conn.toString());
                    try {
                        conn.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }

測試數(shù)據(jù)結(jié)果如下：

oracle.jdbc.driver.T4CConnection@5b51da40
oracle.jdbc.driver.T4CConnection@3b0b482d
oracle.jdbc.driver.T4CConnection@37acaf5
oracle.jdbc.driver.T4CConnection@6f2f3e6a
oracle.jdbc.driver.T4CConnection@2b7e572f
oracle.jdbc.driver.T4CConnection@42d1696b
oracle.jdbc.driver.T4CConnection@2b8f0eac
oracle.jdbc.driver.T4CConnection@87d61dc
oracle.jdbc.driver.T4CConnection@a84b73
oracle.jdbc.driver.T4CConnection@747870b0

單個線程

    public static void main(String[] args) throws SQLException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    Connection conn=ConnectionManager.getConnection();
                    System.out.println(conn.toString());
                    try {
                        conn.close();
                        //ConnectionManager.removeConnection();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }

測試數(shù)據(jù)：

oracle.jdbc.driver.T4CConnection@3975fb62
oracle.jdbc.driver.T4CConnection@3975fb62
oracle.jdbc.driver.T4CConnection@3975fb62

通過上面的測試正面我們前面的猜想是正確的，這樣也就實現(xiàn)了Connection對象在多個線程中的完全隔離。據(jù)說在Spring容器中管理多線程環(huán)境下的Connection對象時，采用的思路和以上代碼非常相似，但是還沒有進(jìn)行驗證。

ThreadLocal源碼探析

get方法

在ThreadLocal的使用過程，用到的最多的就是get和set方法，其實就是存取每個線程自己的本地變量數(shù)據(jù)。先看get方法的源碼是如何實現(xiàn)的：

    public T get() {
        Thread t = Thread.currentThread();
        //獲得當(dāng)前這個線程自己的ThreadLocalMap
        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浮出水面，這個到底是什么呢？其實很簡單，說白了就是當(dāng)前這個線程自己內(nèi)部的一個屬性變量threadLocals，在Thread線程類中，代碼如下：

public class Thread implements Runnable {
    ...
    ThreadLocal.ThreadLocalMap threadLocals = null;
}

拿到這個map之后（假設(shè)已經(jīng)被初始化過不為null），這個時候還沒結(jié)束，真正取出這個存放的值是通過this取出來的，this是什么？this在前兩個案例中就是這個靜態(tài)的私有的nextId和connectionHolder，也就是ThreadLocal對象，通過它作為key，在每個線程自己的ThreadLocalMap中取出了線程本地的變量值。
所以思路還是很清晰的，每個線程有個map，我們在類似于connectionManager這些類中可以定義很多個ThreadLocal對象，所以根據(jù)不同的ThreadLocal對象作為key值，可以在map拿到對應(yīng)的值。
到這兒其實get方法的分析可以結(jié)束了，但是其實可以繼續(xù)看看getEntry的構(gòu)造：

    private Entry getEntry(ThreadLocal<?> key) {
        int i = key.threadLocalHashCode & (table.length - 1);
        Entry e = table[i];
        if (e != null && e.get() == key)
            return e;
        else
            return getEntryAfterMiss(key, i, e);
    }

setInitialValue設(shè)置默認(rèn)值

在剛才的get方法中，是假設(shè)線程所擁有的ThreadLocalMap已經(jīng)被初始化，但是如果當(dāng)?shù)谝淮握{(diào)用get方法時候，還沒有初始化呢？根據(jù)上面的代碼片段可以看到是調(diào)用setInitialValue()方法，方法源代碼如下：

    private T setInitialValue() {
        //調(diào)用我們覆蓋重寫的initialValue()，返回一個默認(rèn)值
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            //創(chuàng)建一個新的ThreadLocalMap，并且賦值給當(dāng)前的線程
            createMap(t, value);
        return value;
    }
    void createMap(Thread t, T firstValue) {
        //以this作為key值，放進(jìn)map中
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

以上兩小節(jié)就是關(guān)于get方法的這個流程中主要代碼實現(xiàn)。

set方法

set方法就更簡單了，跟setInitialValue相比就是自己手動設(shè)置線程本地變量，而不是通過默認(rèn)值的方式。

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

關(guān)于ThreadLocal是否存在內(nèi)存泄漏問題

從上面源碼分析中，我們大致可以看出引用關(guān)系，當(dāng)前線程>ThreadLocalMap>table>Entry>弱引用ThreadLocal和強引用value。當(dāng)線程運行結(jié)束的時候，線程對象會被回收，線程內(nèi)部的ThreadLocalMap也會被回收，table和Entry更不用說的，也會被回收，因此value回收。
但是也有一種情況值得考慮，就是當(dāng)時線程池的時候，這個時候線程池里面的線程有的是經(jīng)?；钴S的，就不能這么來了，具體可以參考這篇文章，博主做了一個關(guān)于用線程池的測驗，就是在最后不使用線程本地變量的時候，通過ThreadLocal的remove方法清除變量，這樣也就解決了線程池可能存在的內(nèi)存泄漏問題。

小結(jié)

其實問題也沒我們想象的那么復(fù)雜，我們使用線程本地變量就是跟ThreadLocal打交道就行了，至于ThreadLocalMap只是每個線程Thread內(nèi)部維護的一個map屬性。
內(nèi)部get實現(xiàn)的時候就是通過當(dāng)前線程拿到自己的map，然后以ThreadLocal的實例為key值拿到屬于自己線程的value值，就這樣了。

原文首發(fā)于博客：http://zouzls.github.io/

-EOF-