文章轉(zhuǎn)自http://duanqz.github.io/2018-03-15-Java-ThreadLocal
ThreadLocal菲驴，在沒有任何背景知識的情況下荐吵，我們從英文單詞的意思上理解它：

• Thread：跟線程相關(guān)。Java語言中赊瞬，表示線程的類就是Thread先煎，是程序最小的執(zhí)行單元，多個線程可以并發(fā)執(zhí)行巧涧。
• Local：本地薯蝎、局部，與之相對的概念就是遠程褒侧、全局良风。Java語言中，通常用Local表示局部變量闷供。

這兩個概念一組合，拼成了英文單詞ThreadLocal统诺，線程局部歪脏？局部線程？究竟要表達什么意思粮呢，為什么不叫LocalThread婿失，完全找不著北啊啄寡！

筆者搜羅了網(wǎng)上對ThreadLocal的一些解讀：

• ThreadLocal為解決多線程程序的并發(fā)問題提供了一種新的思路豪硅。使用這個工具類可以很簡潔地編寫出優(yōu)美的多線程程序，ThreadLocal并不是一個Thread挺物，而是Thread的局部變量懒浮，把它命名為ThreadLocalVariable更容易讓人理解一些

• ThreadLocal并不是用來并發(fā)控制訪問一個共同對象，而是為了給每個線程分配一個只屬于該線程的變量。它的功用非常簡單砚著，就是為每一個使用該變量的線程都提供一個變量值的副本次伶，是每一個線程都可以獨立地改變自己的副本，而不會和其它線程的副本沖突稽穆，實現(xiàn)線程間的數(shù)據(jù)隔離冠王。從線程的角度看，就好像每一個線程都完全擁有該變量

• ThreadLocal類用來提供線程內(nèi)部的局部變量舌镶。這種變量在多線程環(huán)境下訪問(通過get或set方法訪問)時能保證各個線程里的變量相對獨立于其他線程內(nèi)的變量柱彻。ThreadLocal實例通常來說都是private static類型的，用于關(guān)聯(lián)線程和線程的上下文

• 引入ThreadLocal的初衷是為了提供線程內(nèi)的局部變量餐胀，而不是為了解決共享對象的多線程訪問問題哟楷。實際上，ThreadLocal根本就不能解決共享對象的多線程訪問問題

這些解釋都沒錯骂澄，但并不是很好理解吓蘑，而且大多數(shù)讀者也沒有真正使用過ThreadLocal，字面意思看上去理解了坟冲，真正到用的時候又不知從何下手磨镶。 筆者試圖由簡入繁，通過生活中的例子健提，來描述ThreadLocal的演化琳猫、實現(xiàn)和使用場景。

1. 演化過程

以實際生活中的銀行業(yè)務(wù)辦理模型私痹，解釋ThreadLocal的誕生過程脐嫂。讀者們可以看到：隨著業(yè)務(wù)模型的不斷擴展，代碼邏輯變得更加復(fù)雜紊遵，經(jīng)過不斷優(yōu)化代碼結(jié)構(gòu)的過程账千，演化出了ThreadLocal這個編程工具。

1.1 初始形態(tài)

大家去銀行辦理業(yè)務(wù)時暗膜，如果需要排隊等候匀奏，則會領(lǐng)取一個排隊號，直到叫號才能辦理業(yè)務(wù)学搜。

我們把每一筆業(yè)務(wù)(Transaction)抽象為一個線程娃善，每一筆業(yè)務(wù)都有一個唯一的標識(id)。

class Transaction extends Thread {
    private int id;

    public void run() {
        if (wait) {
            ... // Waiting
        } else {
            ... // Start transaction
        }
    }
}

在這個模型里面瑞佩，每新來一筆業(yè)務(wù)聚磺，都需要運行一個線程，然后分配一個全局唯一的業(yè)務(wù)標識(id)給這個新的線程炬丸，簡化以后的代碼邏輯如下：

int id = nextTransactionId();
new Transaction(id).start();

1.2 擴展形態(tài)

現(xiàn)在瘫寝，需要把業(yè)務(wù)模型擴展一下，每一筆業(yè)務(wù)還需要知道等待時間(waitTime)，等待人數(shù)(waitPeople)等矢沿。

于是乎滥搭，在原有的線程里面，又增加了一些局部變量和控制邏輯捣鲸，線程運行以后便會對這些局部變量進行讀寫操作瑟匆。

class Transaction extends Thread {
    private int id;
    private long waitTime;
    private long waitPeople;
    private int serviceWindow;
    ... // Other extension

    public void run() {
        if (wait) {
            waitTime increasing
            ... // Waiting
        } else {
            serviceWindow assigned
            ... // Start transaction
            waitPeople decreasing
        }
    }
}

添加完擴展的代碼邏輯之后，我們發(fā)現(xiàn)這種編程方法并不好：譬如栽惶，要擴展一個業(yè)務(wù)辦理時長(serviceTime)愁溜，又得新增一個局部變量⊥獬В可以想象冕象，類似的擴展還有很多。于是乎汁蝶，我們想到把這些零散的字段封裝成一個類渐扮，這里我們命名為Session，表示一個事務(wù)所需要操作的數(shù)據(jù)集合:

class Transaction extends Thread {
    private Session session;

    public void run() {
        if (wait) {
            ... // Waiting
            Read/Write session
        } else {
            ... // Start transaction
            Read/Write session
        }
    }
}

class Session {
    private int id;
    private long waitTime;
    private long waitPeople;
    private int serviceWindow;
    ... // Other extension
}

這樣一來掖棉，每個線程都擁有一個局部變量Session墓律，后續(xù)可以在Session的基礎(chǔ)上進行擴展，降低Transaction的復(fù)雜度幔亥，當線程運行時耻讽，需要對Session對象進行讀寫。

注意帕棉，銀行的業(yè)務(wù)是多窗口同時辦理的针肥，意味著這些線程可以并發(fā)執(zhí)行。以上代碼并沒有鎖控制香伴，因為每個線程都是修改自己的局部變量慰枕，并不影響其他線程。

隨著銀行的業(yè)務(wù)變得愈加復(fù)雜即纲，譬如：客戶可以買賣理財產(chǎn)品捺僻，繳納日常生活費用。

Transaction的代碼量變得越來越大崇裁，于是乎，又把與理財業(yè)務(wù)相關(guān)的代碼封裝到FinancialService束昵。

class Transaction extends Thread {
    private Session session;

    public void run() {
        if (wait) {
            ... // Waiting
            Read/Write session
        } else {
            ... // Start transaction
            Read/Write session
        }
    }
}

class Session {
    private int id;
    private long waitTime;
    private long waitPeople;
    private int serviceWindow;
    private long serviceTime;
    ... // Other extension
}

class FinancialService {
    Session session;

    public void setSession(Session session) {
        this.session = session;
    }

    public void doService() {
        Read/Write session
        ... // Do financial service
    }
}

擴展出來的FinancialService需要讀寫Session中的數(shù)據(jù)拔稳，譬如：獲取分配的服務(wù)窗口(serviceWindow)、更新服務(wù)時間(serviceTime)锹雏，所以巴比，在FinancialService類中也會有一個局部變量Session，它是外部傳入進來的。

可以這么來理解：FinancialService屬于一個具體的事務(wù)轻绞，F(xiàn)inancialService對象仍然屬于Transaction這個線程的生命周期采记，在Transaction線程的生命周期內(nèi)韧拒，需要將Session對象傳入FinancialService對象砍聊。

1.3 改良形態(tài)

Transaction線程的代碼邏輯已經(jīng)很復(fù)雜了，涉及到很多類的封裝和數(shù)據(jù)傳遞蔚润，在線程運行時奸远，有一些變量是在整個線程的生命都存在的既棺，如果線程中某些對象需要使用這些變量，就需要封裝一些接口進行數(shù)據(jù)傳遞懒叛。有沒有一種便捷的方式來訪問這些變量呢丸冕？

在Transaction中創(chuàng)建一個Map類型的局部變量，通過一個全局可以訪問的Key薛窥，便可對Session進行存取操作胖烛。在線程生命周期的任何地方，只需要通過Key诅迷，就可以獲取到Session

// 全局可以訪問的Key
static SessionKey globalKey = new SessionKey();

class Transaction extends Thread {
    Map<SessionKey, Session> map;

    public void run() {
        // 將Session保存到線程的局部變量map中
        map.put(globalKey, session);
        if (wait) {
            ... // Waiting
            Read/Write session
        } else {
            ... // Start transaction
            Read/Write session
        }
    }
}

class FinancialService {
    public void doService() {
        // 獲取當前運行的線程
        Thread t = Thread.currentThread();
        // 通過全局的globalKey從線程的Map中取出Session
        Session session = t.map.get(globalSessionKey);
        ... // Do financial service
    }
}

注意：此處有兩個關(guān)鍵點：

1. 全局變量Key佩番，所有線程都可以訪問
2. 局部變量Map，屬于每個線程竟贯，這個Map中每一項的Key是全局的答捕，而Value是局部的

把上述兩者之間的關(guān)系圖示出來：

image

線程類Transaction中定義了一個類型為Map的變量，其中每一項的Key為SessionKey屑那，Value為Session拱镐。

讀者一定心生疑問了，直接將Session作為全局變量不就可以了嗎持际？為什么還要搞一個線程的局部變量Map沃琅？

這就涉及到多線程數(shù)據(jù)訪問了：對于Session而言，每個線程都各自維護自己的蜘欲，修改了也不需要告訴其他線程益眉。如果將Session直接作為全局變量，那每個線程都改的是同一份數(shù)據(jù)姥份，還需要進行多線程的鎖控制郭脂。

演化到這一步，ThreadLocal就呼之欲出了澈歉。

2. 實現(xiàn)原理

先直接把Thread與ThreadLocal之間關(guān)系圖示出來：

image

這個結(jié)構(gòu)圖跟上面改良形態(tài)的Transaction結(jié)構(gòu)圖簡直如出一轍展鸡，只不過ThreadLocal做了更多的封裝：

• 線程類Thread中有一個類型為ThreadLocalMap的變量為threadLocals
• ThreadLocalMap是一個映射表，內(nèi)部實現(xiàn)是一個數(shù)組埃难，每一個元素的類型為Entry
• Entry就是一個鍵值對(Key-Value Pair)莹弊，其 Key 就是ThreadLocal涤久，其 Value 可以是任何對象

接下來，我們深入到源碼忍弛，窺探一下ThreadLocal的奧妙响迂。

2.1 ThreadLocal的主要接口

ThreadLocal對外提供的接口并不多：JDK 1.8以前，僅set()细疚、get()和remove()三個接口蔗彤；JDK 1.8以來，多提供了一個withInitial()接口惠昔。這些接口其實就是針對線程中ThreadLocalMap的增刪改查操作幕与。

• set()，表示要往當前線程中設(shè)置“本地變量”镇防，最終的結(jié)果是將變量設(shè)置到了線程的映射表啦鸣。

    // ThreadLocal.set()
    public void set(T value) {
        // 獲取當前線程
        Thread t = Thread.currentThread();
        // 獲取線程中的映射表
        ThreadLocalMap map = getMap(t);
        if (map != null)
            // 設(shè)置映射表的Key-Value，Key就是當前ThreadLocal對象
            map.set(this, value);
        else
            createMap(t, value);
    }
  
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }
  
  

• get()来氧，表示要從當前線程中取出“本地變量”诫给，最終的結(jié)果是在當前線程的映射表中，以調(diào)用get()方法的ThreadLocal對象為Key啦扬，查詢出對應(yīng)的Value中狂。

    // ThreadLocal.get()
    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            // 獲取映射表中當前ThreadLocal對應(yīng)的Value
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        // 如果Map還未初始化或者Map中沒有找到Key，則設(shè)置一個初始值
        return setInitialValue();
    }
  
    private T setInitialValue() {
        // 獲取初始值扑毡，這個方法通常由ThreadLocal的泛型實例化類去實現(xiàn)
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }
  
  

ThreadLocal的set()和get()方法的主體邏輯算是比較簡單了胃榕，圍繞主體邏輯，還做了一些特殊處理瞄摊，譬如：線程中的映射表還未初始化時勋又，調(diào)用createMap()進行初始化；在映射表中沒有獲取到Value時换帜，通過setInitialValue()設(shè)置一個初始值楔壤，這種場景下，只需要實現(xiàn)initialValue()函數(shù)就可以了惯驼，這種ThreadLocal的使用方式很常見蹲嚣。本文不再展開這些細枝末節(jié)的邏輯，讀者自行閱讀源碼即可祟牲。

2.2 ThreadLocalMap映射表

ThreadLocal并不是一個存儲容器隙畜，往ThreadLocal中讀(get)和寫(set)數(shù)據(jù)，其實都是將數(shù)據(jù)保存到了每個線程自己的存儲空間说贝。

線程中的存儲空間是一個映射表(ThreadLocalMap)禾蚕，TheadLocal其實就是這個映射表每一項的Key，通過ThreadLocal讀寫數(shù)據(jù)狂丝，其實就是通過Key在一個映射表中讀寫數(shù)據(jù)换淆。

上文中圖示中，我們見過映射表的結(jié)構(gòu)几颜，它是一個名為table的數(shù)組倍试，每一個元素都是Entry對象，而Entry對象包含key和value兩個屬性蛋哭，其代碼如下所示：

static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;

    Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }
}

ThreadLocalMap的Entry是WeakReference的子類县习，這樣能保證線程中的映射表的每一個Entry可以被垃圾回收，而不至于發(fā)生內(nèi)存泄露谆趾。因為ThreadLocal作為全局的Key躁愿，其生命周期很可能比一個線程要長，如果Entry是一個強引用沪蓬，那么線程對象就一直持有ThreadLocal的引用彤钟，而不能被釋放。隨著線程越來越多跷叉，這些不能被釋放的內(nèi)存也就越來越多逸雹。

ThreadLocal作為映射表的Key，需要具備唯一的標識云挟，每創(chuàng)建一個新的ThreadLocal梆砸，這個標識就變的跟之前不一樣了。 如何保證每一個ThreadLocal的唯一性呢园欣？

public class ThreadLocal<T> {
    private static final int HASH_INCREMENT = 0x61c88647;
    // 每一個ThreadLocal對象的HashCode都不一樣
    private final int threadLocalHashCode = nextHashCode();
    private static int nextHashCode() {
        // 下一個HashCode帖世，是在已有基礎(chǔ)上增加0x61c88647
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }
}

ThreadLocal內(nèi)部有一個名為threadLocalHashCode的變量，每創(chuàng)建一個新的ThreadLocal對象沸枯，這個變量的值就會增加0x61c88647日矫。 正是因為有這么一個神奇的數(shù)字，它能夠保證生成的Hash值可以均勻的分布在0~(2^N-1)之間辉饱，N是數(shù)組長度搬男。 更多關(guān)于數(shù)字0x61c88647，可以參考Why 0x61c88647?

3. 使用場景

在介紹具體的使用場景之前彭沼，我們先來抽象一下：

image

這個圖表示：多個線程的生命周期不同缔逛，當一個線程在其生命周期內(nèi)的某個時候，調(diào)用ThreadLocal.set()方法姓惑，其實就在該線程內(nèi)部啟用了一個局部變量褐奴，而后這個局部變量可以在該線程生命周期的任何時候被獲取，直到調(diào)用ThreadLocal.remove()方法或者線程消亡于毙。

線程通過ThreadLocal提供的接口來操作自己內(nèi)部的映射表敦冬，或者可以在語意上這么理解：線程把ThreadLocal當做自己的局部變量，不過對這個變量的賦值操作是set()唯沮，讀取操作是get()脖旱，清空操作是remove()堪遂。

3.1 Android Looper

Android中有一個很常見的操作：使用Handler將消息拋送到線程的消息隊列∶惹欤控制消息隊列的類是Looper溶褪，每個擁有消息隊列的線程，都會有一個獨立的Looper類践险，用于處理本線程的消息猿妈。 一種實現(xiàn)方式是：在線程類中，聲明一個Looper類型的局部變量巍虫，當線程運行起來時彭则，創(chuàng)建Looper對象，并開始進行無限循環(huán)占遥，代碼示意如下：

public class LooperThread extends Thread {
    private Looper mLooper;

    @Override
    public void run() {
        // 創(chuàng)建Looper對象(實際上俯抖，Looper類的構(gòu)造器是私有的)
        mLooper = new Looper();
        // 開始無限循環(huán)處理消息
        mLooper.loop();
    }

    public Looper getLooper() {
        return mLooper;
    }
}

注意到，這種實現(xiàn)方式需要增加一個方法：getLooper()筷频，因為其他線程可能需要獲取LooperThread的消息隊列蚌成。 然而，Android并不是采用的上述實現(xiàn)方式凛捏，而是利用ThreadLocal來保存Looper對象担忧，當一個線程想要擁有消息隊列時，調(diào)用Looper.prepare()方法便可完成消息隊列的初始化坯癣，然后調(diào)用Looper.loop()便會開始無限循環(huán)瓶盛，不斷從消息隊列上取出消息進行處理。先來看Looper的代碼實現(xiàn)片段：

public final class Looper {
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
    // 私有構(gòu)造器示罗，意味著外部不能調(diào)用
    private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }

    public static void prepare() {
        prepare(true);
    }

    private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        // 通過ThreadLocal保存新建的Looper對象
        sThreadLocal.set(new Looper(quitAllowed));
    }

    public static Looper myLooper() {
        // 返回實際線程的Looper對象
        return sThreadLocal.get();
    }
}

Looper中定義了一個靜態(tài)變量sThreadLocal惩猫，構(gòu)造器都是私有的(private)，即外部無法調(diào)用蚜点，然后提供了一個prepare()方法轧房，當該方法被調(diào)用時，便往sThreadLocal中設(shè)置一個Looper對象绍绘。

上文剖析過ThreadLocal的實現(xiàn)奶镶，可以知道：哪個線程調(diào)用了prepare()方法，Looper對象就添加到了那個具體線程的ThreadLocalMap映射表中陪拘，表中每一項的Key是sLocalThread厂镇，Value是Looper對象，這樣一來左刽，就等價于線程擁有了Looper這個局部變量捺信。如何獲取線程中的Looper對象呢？在線程中直接調(diào)用ThreadLocal.get()方法就可以了欠痴，所以Looper類封裝了一個靜態(tài)方法myLooper()迄靠，做的就是獲取當前線程Looper對象的買賣秒咨。

Android中，真正帶消息隊列的線程實現(xiàn)是HandlerThread梨水，與上文中模擬的LooperThread的實現(xiàn)方式如出一轍拭荤，不過是利用了ThreadLocal這個編程工具：

public class HandlerThread extends Thread {
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();  // 初始化消息隊列，即將Looper對象添加到實際線程的ThreadLocalMap中
        synchronized (this) {
            mLooper = Looper.myLooper(); // 獲取實際線程的Looper對象
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();  // 開始無限循環(huán)處理消息
        mTid = -1;
    }

    public Looper getLooper() {
        if (!isAlive()) {
            return null;
        }

        // If the thread has been started, wait until the looper has been created.
        synchronized (this) {
            while (isAlive() && mLooper == null) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
        }
        return mLooper;
    }
}

當線程運行起來時疫诽，往ThreadLocal中添加了一個Looper對象，然后開始無限循環(huán)處理消息旦委。往ThreadLocal中添加對象的行為奇徒，就意味著這個對象是屬于每個線程的局部變量。

當有多個HandlerThread同時運行時缨硝，它們的關(guān)系如下圖所示：

image

每一個HandlerThread線程內(nèi)部都有Key-Value Pairs摩钙，Value是不同的Looper對象，而Key是指向同一個靜態(tài)ThreadLocal對象的弱引用查辩。

3.2 Android SQLiteDatabase

Android中進行數(shù)據(jù)庫的事務(wù)操作時胖笛，通常都會在某個工作線程中調(diào)用SQLiteDatabase.beginTransaction()方法，然后開始具體的數(shù)據(jù)庫操作宜岛。有些時候长踊，并發(fā)操作數(shù)據(jù)庫的線程會存在多個，要操作數(shù)據(jù)庫萍倡，是要發(fā)起連接的身弊，Android封裝了一個類SQLiteSession，專門來管理數(shù)據(jù)庫連接列敲，每個線程都需要SQLiteSession對象阱佛，那線程怎樣才能獲取到一個獨立的SQLiteSession對象呢？這種場景下戴而，便有了ThreadLocal的用武之地了凑术。

public final class SQLiteDatabase extends SQLiteClosable {
    // 定義ThreadLocal，存儲的對象類型是SQLiteSession
    private final ThreadLocal<SQLiteSession> mThreadSession = new ThreadLocal<SQLiteSession>() {
        @Override
        protected SQLiteSession initialValue() {
            return createSession();
        }
    };

    SQLiteSession getThreadSession() {
        // 通過ThreadLocal獲取SQLiteSession對象
        return mThreadSession.get(); // initialValue() throws if database closed
    }

    private void beginTransaction(SQLiteTransactionListener transactionListener,
            boolean exclusive) {
        acquireReference();
        try {
            // 獲取SQLiteSession對象后所意，開始數(shù)據(jù)庫的事務(wù)操作
            getThreadSession().beginTransaction(
                    exclusive ? SQLiteSession.TRANSACTION_MODE_EXCLUSIVE :
                            SQLiteSession.TRANSACTION_MODE_IMMEDIATE,
                    transactionListener,
                    getThreadDefaultConnectionFlags(false /*readOnly*/), null);
        } finally {
            releaseReference();
        }
    }

}

SQLiteDatabase中定義了ThreadLocal淮逊，所存儲對象的類型是SQLiteSession。每當在線程中調(diào)用SQLiteDatabase.beginTransaction()方法時扁眯，表示要開始數(shù)據(jù)庫的事務(wù)操作了壮莹，這時候會先從ThreadLocal中取出屬于當前線程的SQLiteSession對象。

在多進程多線程訪問數(shù)據(jù)庫的情況下姻檀，它們的關(guān)系圖如下所示：

image

3.4 總結(jié)

通過上述使用場景可以發(fā)現(xiàn)命满，ThreadLocal確實提供了一種編程手段，本來需要在線程中顯示聲明的局部變量绣版，像是被ThreadLocal隱藏了起來胶台，當多個線程運行起來時歼疮，每個線程都往相同的ThreadLocal中存取所需要的變量就可以了，使用ThreadLocal存取的變量诈唬，就像是每個線程自己的局部變量韩脏，不受其他線程運行狀態(tài)的影響。

通過ThreadLocal可以解決多線程讀共享數(shù)據(jù)的問題铸磅，因為共享數(shù)據(jù)會被復(fù)制到每個線程赡矢，不需要加鎖便可同步訪問。但ThreadLocal解決不了多線程寫共享數(shù)據(jù)的問題阅仔，因為每個線程寫的都是自己本線程的局部變量吹散，并沒將寫數(shù)據(jù)的結(jié)果同步到其他線程。理解了這一點八酒，才能理解所謂的：

• ThreadLocal以空間換時間空民，提升多線程并發(fā)的效率。什么意思呢羞迷？每個線程都有一個ThreadLocalMap映射表界轩，正是利用了這個映射表所占用的空間，使得多個線程都可以訪問自己的這片空間衔瓮，不用擔心考慮線程同步問題浊猾，效率自然會高。
• ThreadLocal并不是為了解決共享數(shù)據(jù)的互斥寫問題报辱，而是通過一種編程手段与殃，正好提供了并行讀的功能。什么意思呢碍现？ThreadLocal并不是萬能的幅疼，它的設(shè)計初衷只是提供一個便利性，使得線程可以更為方便地使用局部變量昼接。
• ThreadLocal提供了一種線程全域訪問功能爽篷，什么意思呢？一旦將一個對象添加到ThreadLocal中慢睡，只要不移除它逐工，那么，在線程的生命周期內(nèi)的任何地方漂辐，都可以通過ThreadLocal.get()方法拿到這個對象泪喊。有時候，代碼邏輯比較復(fù)雜髓涯，一個線程的代碼可能分散在很多地方袒啼，利用ThreadLocal這種便利性，就能簡化編程邏輯。