ThreadLocal的初步認(rèn)識

在正式解析ThreadLocal之前，我們先來看 一個例子：

public class ThreadLocalTest {
    //創(chuàng)建并初始化一個ThreadLocal變量
    private static ThreadLocal<Integer> cnt = new ThreadLocal<Integer>(){
        @Override
        protected Integer initialValue() {
            return 0;
        }
    };

    public static void main(String[] args){
        System.out.println(Thread.currentThread().getName() + " before write, get cnt " + cnt.get());
        cnt.set(1);
        //創(chuàng)建線程一對ThreadLocal變量進行修改和讀取
        new Thread(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " before write, get cnt : " + cnt.get());
                cnt.set(2);
                System.out.println(Thread.currentThread().getName() + " after write, get cnt : " + cnt.get());
            }
        }.start();
        //創(chuàng)建線程二對ThreadLocal變量進行修改和讀取
        new Thread(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " before write, get cnt : " + cnt.get());
                cnt.set(3);
                System.out.println(Thread.currentThread().getName() + " get cnt : " + cnt.get());

            }
        }.start();
        //主線程進行讀取
        System.out.println(Thread.currentThread().getName() + " after write, get cnt : " + cnt.get());
    }

}
輸出結(jié)果：
main before write, get cnt 0
Thread-0 before write, get cnt : 0
Thread-0 after write, get cnt : 2
main after write, get cnt : 1
Thread-1 before write, get cnt : 0
Thread-1 get cnt : 3

程序中存在三個線程（包括主線程）對變量cnt進行修改并讀取，根據(jù)結(jié)果，我們發(fā)現(xiàn)不同線程之間對變量的修改和讀取都是獨立的，互不影響的。實際上，這就是ThreadLocal的特色。

ThreadLocal在每個線程中對變量會創(chuàng)建一個副本，即每個線程內(nèi)部都會有一個變量，且在線程內(nèi)部任何地方可以使用，線程之間互不影響。

ThreadLocal的深入理解

ThreadLocal類主要提供以下幾個方法：

public T get() {}
public void set(T value) {}
public void remove() {}
protected T initValue() {}

• 我們先看到initValue方法：

protected T initialValue() {
     return null;
}

我們會發(fā)現(xiàn)這是個空方法，因此，我們在進行初始化時，必須重寫該方法才能執(zhí)行初始化操作。

• 接下來，我們繼續(xù)解析get方法：

/**
 * 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) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

首先通過Thread.currentThread()方法獲取到當(dāng)前線程，然后再根據(jù)當(dāng)前線程調(diào)用getMap方法獲取到ThreadLocalMap對象。那么我們來看看getMap方法：

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

我們可以看到它返回的是線程中的一個threadLocals變量，而我們在Thread類中，也可以發(fā)現(xiàn)這個變量：

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

若map不為空，那么將通過map.getEntry(this)方法來獲取到Entry對象，我們來看看Entry對象到底是什么：

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

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

也就是說，Entry對象是ThreadLocal的一個弱引用而已，這里應(yīng)該是方便GC的回收，防止內(nèi)存溢出。我們繼續(xù)看到getEntry方法：

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

看到這里，可能就有些懵逼了，這里的threadLocalHashCode和table完全不知所云。這里，我們就要回頭看ThreadLocal中的一些變量：

private final int threadLocalHashCode = nextHashCode();

/**
  * The next hash code to be given out. Updated atomically. Starts at
  * zero.
  */
private static AtomicInteger nextHashCode =
    new AtomicInteger();

/**
  *The difference between successively generated hash codes - turns
  * implicit sequential thread-local IDs into near-optimally spread
  * multiplicative hash values for power-of-two-sized tables.
  */
private static final int HASH_INCREMENT = 0x61c88647;

/**
 * Returns the next hash code.
 */
private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}

在這里定義了一個類型為AtomicInteger類型的變量，即每次創(chuàng)建一個ThreadLocal對象，都會得到它所對應(yīng)的值，因為它是自增的，然后threadLocalHashCode變量則為該值得一個hash值。而table變量則是聲明在ThreadLocalMap中：

/**
 * The table, resized as necessary.
 * table.length MUST always be a power of two.
 */
private Entry[] table;

它的作用為存儲值，其中threadLocalHashCode經(jīng)過處理后便為ThreadLocal所對應(yīng)的索引。
獲取到Entry對象后，我們就可以通過Entry對象獲取到所對應(yīng)的值，返回即可。

若map為空，則調(diào)用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;
}

方法中，獲取到起初始值，并將當(dāng)前線程與value進行綁定，存入map對象中，以便下一次的調(diào)用，若map為空，則創(chuàng)建map對象。

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

我們可以看到就是返回一個ThreadLocalMap對象。

• 接下來我們看到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);
}

這里的思路很簡單，就是先獲取到map對象，若map不為空，則更新其值，否則創(chuàng)建一個map對象。

• 最后我們看到remove方法：

public void remove() {
   ThreadLocalMap m = getMap(Thread.currentThread());
   if (m != null)
       m.remove(this);
}

即獲取到map對象后，將map中的值移除。

注意：在使用時，若沒有重寫initialValue方法，那么在調(diào)用get方法前，必須調(diào)用set方法，否則會報空指針異常。

TheadLocal的應(yīng)用

通常當(dāng)我們想要共享一個變量，但該變量又不是線程安全的，并且也不想通過加鎖機制來降低并發(fā)性，那么就可以用ThreadLocal來維護一個線程一個實例。

• 應(yīng)用一：數(shù)據(jù)庫連接

public class ConnectionManager {
    private static ThreadLocal<Connection> connectionHolder = 
            new ThreadLocal<Connection>(){
                @Override
                protected Connection initialValue() {
                    try {
                        return DriverManager.getConnection("localhost","username","password");
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                    return null;
                }
            };
    
    public static Connection getConnection(){
        return connectionHolder.get();
    }
}