摘要：簡要言之往中填充的變量屬于當前線程，該變量對其他線程而言是隔離的。在辦理時又告訴機構(gòu)來，把我的身份證房產(chǎn)證學生證通通給他。

今天要研究的是ThreadLocal，這個我在一年前學習JavaWeb基礎(chǔ)的時候接觸過一次，當時在baidu搜出來的第一篇博文ThreadLocal，在評論下很多開發(fā)者認為那博主理解錯誤，給出了很多有關(guān)的鏈接來指正(可原博主可能沒上博客了，一直沒做修改)。我也去學習了一番，可惜的是當時還沒有記錄的習慣，直到現(xiàn)在僅僅記住了一些當時學過的皮毛。

因此，做一些技術(shù)的記錄是很重要的～同時，ThreadLocal也是面試非常常見的面試題，對Java開發(fā)者而言也是一個必要掌握的知識點～

當然了，如果我有寫錯的地方請大家多多包涵，歡迎在評論下留言指正～

聲明：本文使用的是JDK 1.8

首先我們來看一下JDK的文檔介紹：

/**
 * 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).
 * 
 * 
For example, the class below generates unique identifiers local to each
 * thread.
 * A thread"s id is assigned the first time it invokes {@code ThreadId.get()}
 * and remains unchanged on subsequent calls.
 */      
    

結(jié)合我的總結(jié)可以這樣理解：ThreadLocal提供了線程的局部變量，每個線程都可以通過set()和get()來對這個局部變量進行操作，但不會和其他線程的局部變量進行沖突，實現(xiàn)了線程的數(shù)據(jù)隔離～。

簡要言之：往ThreadLocal中填充的變量屬于當前線程，該變量對其他線程而言是隔離的。

從上面可以得出：ThreadLocal可以讓我們擁有當前線程的變量，那這個作用有什么用呢？？？

最典型的是管理數(shù)據(jù)庫的Connection：當時在學JDBC的時候，為了方便操作寫了一個簡單數(shù)據(jù)庫連接池，需要數(shù)據(jù)庫連接池的理由也很簡單，頻繁創(chuàng)建和關(guān)閉Connection是一件非常耗費資源的操作，因此需要創(chuàng)建數(shù)據(jù)庫連接池～

那么，數(shù)據(jù)庫連接池的連接怎么管理呢？？我們交由ThreadLocal來進行管理。為什么交給它來管理呢？？ThreadLocal能夠?qū)崿F(xiàn)當前線程的操作都是用同一個Connection，保證了事務(wù)！

當時候?qū)懙拇a：

public class DBUtil {
    //數(shù)據(jù)庫連接池
    private static BasicDataSource source;

    //為不同的線程管理連接
    private static ThreadLocal local;


    static {
        try {
            //加載配置文件
            Properties properties = new Properties();

            //獲取讀取流
            InputStream stream = DBUtil.class.getClassLoader().getResourceAsStream("連接池/config.properties");

            //從配置文件中讀取數(shù)據(jù)
            properties.load(stream);

            //關(guān)閉流
            stream.close();

            //初始化連接池
            source = new BasicDataSource();

            //設(shè)置驅(qū)動
            source.setDriverClassName(properties.getProperty("driver"));

            //設(shè)置url
            source.setUrl(properties.getProperty("url"));

            //設(shè)置用戶名
            source.setUsername(properties.getProperty("user"));

            //設(shè)置密碼
            source.setPassword(properties.getProperty("pwd"));

            //設(shè)置初始連接數(shù)量
            source.setInitialSize(Integer.parseInt(properties.getProperty("initsize")));

            //設(shè)置最大的連接數(shù)量
            source.setMaxActive(Integer.parseInt(properties.getProperty("maxactive")));

            //設(shè)置最長的等待時間
            source.setMaxWait(Integer.parseInt(properties.getProperty("maxwait")));

            //設(shè)置最小空閑數(shù)
            source.setMinIdle(Integer.parseInt(properties.getProperty("minidle")));

            //初始化線程本地
            local = new ThreadLocal<>();


        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static Connection getConnection() throws SQLException {
        if(local.get()!=null){
            return local.get();
        }else{
        
          //獲取Connection對象
          Connection connection = source.getConnection();

          //把Connection放進ThreadLocal里面
          local.set(connection);

          //返回Connection對象
          return connection;
       }
    }

    //關(guān)閉數(shù)據(jù)庫連接
    public static void closeConnection() {
        //從線程中拿到Connection對象
        Connection connection = local.get();

        try {
            if (connection != null) {
                //恢復(fù)連接為自動提交
                connection.setAutoCommit(true);

                //這里不是真的把連接關(guān)了,只是將該連接歸還給連接池
                connection.close();

                //既然連接已經(jīng)歸還給連接池了,ThreadLocal保存的Connction對象也已經(jīng)沒用了
                local.remove();

            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }


}

同樣的，Hibernate對Connection的管理也是采用了相同的手法(使用ThreadLocal，當然了Hibernate的實現(xiàn)是更強大的)～

避免一些參數(shù)的傳遞的理解可以參考一下Cookie和Session：

每當我訪問一個頁面的時候，瀏覽器都會幫我們從硬盤中找到對應(yīng)的Cookie發(fā)送過去。

瀏覽器是十分聰明的，不會發(fā)送別的網(wǎng)站的Cookie過去，只帶當前網(wǎng)站發(fā)布過來的Cookie過去

瀏覽器就相當于我們的ThreadLocal，它僅僅會發(fā)送我們當前瀏覽器存在的Cookie(ThreadLocal的局部變量)，不同的瀏覽器對Cookie是隔離的(Chrome,Opera,IE的Cookie是隔離的【在Chrome登陸了，在IE你也得重新登陸】)，同樣地：線程之間ThreadLocal變量也是隔離的....

那上面避免了參數(shù)的傳遞了嗎？？其實是避免了。Cookie并不是我們手動傳遞過去的，并不需要寫來進行傳遞參數(shù)...

在編寫程序中也是一樣的：日常中我們要去辦理業(yè)務(wù)可能會有很多地方用到身份證，各類證件，每次我們都要掏出來很麻煩

    // 咨詢時要用身份證，學生證，房產(chǎn)證等等....
    public void consult(IdCard idCard,StudentCard studentCard,HourseCard hourseCard){

    }

    // 辦理時還要用身份證，學生證，房產(chǎn)證等等....
    public void manage(IdCard idCard,StudentCard studentCard,HourseCard hourseCard) {

    }

    //......

而如果用了ThreadLocal的話，ThreadLocal就相當于一個機構(gòu)，ThreadLocal機構(gòu)做了記錄你有那么多張證件。用到的時候就不用自己掏了，問機構(gòu)拿就可以了。

在咨詢時的時候就告訴機構(gòu)：來，把我的身份證、房產(chǎn)證、學生證通通給他。在辦理時又告訴機構(gòu)：來，把我的身份證、房產(chǎn)證、學生證通通給他。...

    // 咨詢時要用身份證，學生證，房產(chǎn)證等等....
    public void consult(){

        threadLocal.get();
    }

    // 辦理時還要用身份證，學生證，房產(chǎn)證等等....
    public void takePlane() {
        threadLocal.get();
    }

這樣是不是比自己掏方便多了。

當然了，ThreadLocal可能還會有其他更好的作用，如果知道的同學可在評論留言哦～～～

想要更好地去理解ThreadLocal，那就得翻翻它是怎么實現(xiàn)的了～～～

聲明：本文使用的是JDK 1.8

首先，我們來看一下ThreadLocal的set()方法，因為我們一般使用都是new完對象，就往里邊set對象了

    public void set(T value) {

        // 得到當前線程對象
        Thread t = Thread.currentThread();
        
        // 這里獲取ThreadLocalMap
        ThreadLocalMap map = getMap(t);

        // 如果map存在，則將當前對象threadLocal作為key，要存儲的對象作為value存到map里面去
        if (map != null)
            map.set(this, value);
        else
            // 如果map不存在，則在當前線程中創(chuàng)建出一個ThreadLocalMap！
            createMap(t, value);
    }

上面有個ThreadLocalMap，我們?nèi)タ纯催@是什么？

static class ThreadLocalMap {

        /**
         * The entries in this hash map extend WeakReference, using
         * its main ref field as the key (which is always a
         * ThreadLocal object).  Note that null keys (i.e. entry.get()
         * == null) mean that the key is no longer referenced, so the
         * entry can be expunged from table.  Such entries are referred to
         * as "stale entries" in the code that follows.
         */
        static class Entry extends WeakReference> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal k, Object v) {
                super(k);
                value = v;
            }
        }
        //....很長
}

通過上面我們可以發(fā)現(xiàn)的是ThreadLocalMap是ThreadLocal的一個內(nèi)部類。用Entry類來進行存儲

我們的值都是存儲到這個Map上的，key是當前ThreadLocal對象！

如果該Map不存在，則初始化一個：

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

如果該Map存在，則從Thread中獲取！

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

Thread維護了ThreadLocalMap變量

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

從上面又可以看出，ThreadLocalMap是在ThreadLocal中使用內(nèi)部類來編寫的，但對象的引用是在Thread中！

于是我們可以總結(jié)出：Thread為每個線程維護了ThreadLocalMap這么一個Map，而ThreadLocalMap的key是ThreadLocal對象本身，value則是要存儲的對象

有了上面的基礎(chǔ)，我們看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();
    }

每個Thread維護著一個ThreadLocalMap的引用

ThreadLocalMap是ThreadLocal的內(nèi)部類，用Entry來進行存儲

調(diào)用ThreadLocal的set()方法時，實際上就是往ThreadLocalMap設(shè)置值，key是ThreadLocal對象，值是傳遞進來的對象

調(diào)用ThreadLocal的get()方法時，實際上就是往ThreadLocalMap獲取值，key是ThreadLocal對象

ThreadLocal本身并不存儲值，它只是作為一個key來讓線程從ThreadLocalMap獲取value。

正因為這個原理，所以ThreadLocal能夠?qū)崿F(xiàn)“數(shù)據(jù)隔離”，獲取當前線程的局部變量值，不受其他線程影響～

我們來看一下ThreadLocal的對象關(guān)系引用圖：

ThreadLocal內(nèi)存泄漏的根源是：由于ThreadLocalMap的生命周期跟Thread一樣長，如果沒有手動刪除對應(yīng)key就會導致內(nèi)存泄漏，而不是因為弱引用。

想要避免內(nèi)存泄露就要手動remove()掉！

ThreadLocal這方面的博文真的是數(shù)不勝數(shù)，隨便一搜就很多很多～站在前人的肩膀上總結(jié)了這篇博文～

最后要記住的是:ThreadLocal設(shè)計的目的就是為了能夠在當前線程中有屬于自己的變量，并不是為了解決并發(fā)或者共享變量的問題

如果看得不夠過癮，覺得不夠深入的同學可參考下面的鏈接，很多的博主還開展了一些擴展知識，我就不一一展開了～

參考博文：

http://blog.xiaohansong.com/2016/08/06/ThreadLocal-memory-leak/

https://www.cnblogs.com/zhangjk1993/archive/2017/03/29/6641745.html#_label2

http://www.cnblogs.com/dolphin0520/p/3920407.html

http://www.cnblogs.com/dolphin0520/p/3920407.html

http://www.iteye.com/topic/103804

https://www.cnblogs.com/xzwblog/p/7227509.html

https://blog.csdn.net/u012834750/article/details/71646700

https://blog.csdn.net/winwill2012/article/details/71625570

https://juejin.im/post/5a64a581f265da3e3b7aa02d

如果文章有錯的地方歡迎指正，大家互相交流。習慣在微信看技術(shù)文章，想要獲取更多的Java資源的同學，可以關(guān)注微信公眾號:Java3y