前言
前面的文章里，我們學習了有關鎖的使用，鎖的機制是保證同一時刻只能有一個線程訪問臨界區的資源，也就是通過控制資源的手段來保證線程安全，這固然是一種有效的手段，但程序的運行效率也因此大大降低。那么，有沒有更好的方式呢？答案是有的，既然鎖是嚴格控制資源的方式來保證線程安全，那我們可以反其道而行之，增加更多資源，保證每個線程都能得到所需對象，各自為營，互不影響，從而達到線程安全的目的，而ThreadLocal便是采用這樣的思路。
ThreadLocal實例
ThreadLocal翻譯成中文的話大概可以說是：線程局部變量，也就是只有當前線程能夠訪問。它的設計作用是為每一個使用該變量的線程都提供一個變量值的副本，每個線程都是改變自己的副本並且不會和其他線程的副本沖突，這樣一來，從線程的角度來看，就好像每個線程都擁有了該變量。
下面是一個簡單的實例：
public class ThreadLocalDemo {
static ThreadLocal<Integer> local = new ThreadLocal<Integer>(){
@Override
protected Integer initialValue() {
return 0;
}
};
public static class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0;i<3;i++){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
int value = local.get();
System.out.println(Thread.currentThread().getName() + ":" + value);
local.set(value + 1);
}
}
}
public static void main(String[] args) {
MyRunnable runnable = new MyRunnable();
Thread t1 = new Thread(runnable);
Thread t2 = new Thread(runnable);
t1.start();
t2.start();
}
}
上面的代碼不難理解，首先是定義了一個名為 local 的ThreadLocal變量，並初識變量的值為0，然后是定義了一個實現Runnable接口的內部類，在其run方法中對local 的值做讀取和加1的操作，最后是main方法中開啟兩個線程來運行內部類實例。
以上就是代碼的大概邏輯，運行main函數后，程序的輸出結果如下：
Thread-0:0
Thread-1:0
Thread-1:1
Thread-0:1
Thread-1:2
Thread-0:2
從結果可以看出，雖然兩個線程都共用一個Runnable實例，但兩個線程中所展示的ThreadLocal的數據值並不會相互影響，也就是說這種情況下的local 變量保存的數據相當於是線程安全的，只能被當前線程訪問。
ThreadLocal實現原理
那么ThreadLocal內部是怎么保證對象是線程私有的呢？毫無疑問，答案需要從源碼中查找。回顧前面的代碼，可以發現其中調用了ThreadLocal的兩個方法set 和 get，我們就從這兩個方法入手。
先看 set() 的源碼：
public void set(T value) {
Thread t = Thread.currentThread();
// 獲取線程的ThreadLocalMap，返回map
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
//map為空，創建
createMap(t, value);
}
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
set的代碼邏輯比較簡單，主要是把值設置到當前線程的一個ThreadLocalMap對象中，而ThreadLocalMap可以理解成一個Map，它是定義在Thread類中內部的成員，初始化是為null，
ThreadLocal.ThreadLocalMap threadLocals = null;
不過，與常見的Map實現類，如HashMap之類的不同的是，ThreadLocalMap中的Entry是繼承於WeakReference類的，保持了對 “鍵” 的弱引用和對 “值” 的強引用，這是類的源碼：
static class ThreadLocalMap {
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
//省略剩下的源碼
....................
}
從源碼中中可以看出，Entry構造函數中的參數 k 就是ThreadLocal實例，調用super(k) 表明對 k 是弱引用，使用弱引用的原因在於，當沒有強引用指向 ThreadLocal 實例時，它可被回收，從而避免內存泄露，那么為何需要防止內存泄露呢？原因下面會說到。
接着說set方法的邏輯，當調用set方法時，其實是將數據寫入threadLocals這個Map對象中，這個Map的key為ThreadLocal當前對象，value就是我們存入的值。而threadLocals本身能保存多個ThreadLocal對象，相當於一個ThreadLocal集合。
接着看 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;
}
}
//設置初識值到ThreadLocal中並返回
return setInitialValue();
}
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;
}
get方法的邏輯也是比較簡單的，就是直接獲取當前線程的ThreadLocalMap對象，如果該對象不為空就返回它的value值，否則就把初始值設置到ThreadLocal中並返回。
看到這，我們大概就能明白為什么ThreadLocal能實現線程私有的原理了，其實就是每個線程都維護着一個ThreadLocal的容器，這個容器就是ThreadLocalMap，可以保存多個ThreadLocal對象。而調用ThreadLocal的set或get方法其實就是對當前線程的ThreadLocal變量操作，與其他線程是分開的，所以才能保證線程私有，也就不存在線程安全的問題了。
然而，該方案雖然能保證線程私有，但卻會占用大量的內存，因為每個線程都維護着一個Map，當訪問某個ThreadLocal變量后，線程會在自己的Map內維護該ThreadLocal變量與具體實現的映射，如果這些映射一直存在，就表明ThreadLocal 存在引用的情況，那么系統GC就無法回收這些變量，可能會造成內存泄露。
針對這種情況，上面所說的ThreadLocalMap中Entry的弱引用就起作用了。
TheadLocal與同步機制的區別
最后，總結一下ThreadLocal和同步機制之間的區別吧。
實現機制：
同步機制采用了“以時間換空間”的方式，控制資源保證同一時刻只能有一個線程訪問。
ThreadLocal采用了“以空間換時間”的方式，為每一個線程都提供一份變量的副本，從而實現同時訪問而互不影響，但因為每個線程都維護着一份副本，對內存空間的占用會增加。
數據共享：
同步機制是對公共資源做控制訪問的方式來保證線程安全，但資源仍是共享狀態，可用於線程間的通信；
ThreadLocal是每個線程都有自己的資源(變量)副本，互相之間不影響，也就不存在共享的說法了。