JAVA并发编程（四）ThreadLocal

ThreadLocal

在多线程编程中，我们使用锁来确保多个线程共享的变量能被安全的访问。但是还有一些变量，我们希望每一个线程都能保存一份独立的值而不受其他线程的影响。这个时候我们就需要用到ThreadLocal这个类来完成相关操作。

现有两个线程A和B，它们都能访问到一个变量str_c。在不经过任何处理时，str_c的值可以被A和B两个线程访问和修改。使用了ThreadLocal后将str_c作为一个线程的局部变量，对于每一个线程，通过ThreadLocal方法得到的str_c的值是该线程的str_c的值，这个值不会被其他线程修改，其他线程只能修改他们自己的str_c的值。在并发的代码中的任何一点我们都能访问ThreadLocal而获取str_c的值，但是获取的值是该线程的值，其他线程的str_c在这个时候被“屏蔽”了，一般情况下我们看不见且访问不到。

在工作项目中举例。在Java ee的springMVC框架中，我们在封装Controller时习惯于将request、response两个对象通过ThreadLocal封装，因为这两个对象在每个线程中的内容肯定不同，通过这种技术，可以确保在高并发情况下的安全性。

ThreadLocal与Synchronized

网上的部分博客对ThreadLocal与Synchronized的概念混淆不清。ThreadLocal的作用并不是取代Synchronized，这两种方法从初衷上就完全不同。不仅仅是初衷，这两种技术的实现方法也不同，不存在可比性。

ThreadLocal： 将每个线程持有的变量安全的存放起来，不被其他线程访问。
synchronized： 让多个线程并发访问的变量能够安全的被访问和操作。

举例

package Main;/*** Title: ThreadLocalEx* Description:* Company: www.QuinnNorris.com** @date: 2018/2/4 下午5:32 星期日* @author: quinn_norris* @version: 1.0*/
class ThreadLocalEx {public static void main(String[] args) throws InterruptedException {final TastClass tastClass = new TastClass();Runnable threadLocalThread = new Runnable() {@Overridepublic void run() {//TastClass tastClass = new TastClass();tastClass.getThreadLocal().set((int) (Math.random() * 100));tastClass.setValue((int) (Math.random() * 100));try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " " + tastClass.getValue() + " " + tastClass.getThreadLocal().get());}};Thread thread = new Thread(threadLocalThread);Thread thread2 = new Thread(threadLocalThread);thread.start();thread2.start();}
}
class TastClass {private ThreadLocal<Integer> threadLocal = new ThreadLocal<>();private int value = 0;public ThreadLocal<Integer> getThreadLocal() {return threadLocal;}public int getValue() {return value;}public void setValue(int value) {this.value = value;}
}

输出结果：
Thread-1 15 80
Thread-0 15 87

两个线程操作一份TastClass对象，对于此对象中的共享变量value，经过两次修改并间隔2秒之后，输出了同样的数字15，说明两线程读取到同一变量，而ThreadLocal不同读取到两个数据。

如果将上述例子中

final TastClass tastClass = new TastClass();

打上注释，并将下面的注释去掉

//TastClass tastClass = new TastClass();

那么输出的四个数字将都不相同。原因是此时产生了两个TastClass对象。两个线程分别操作不同对象，没有操作共享数据。在使用ThreadLocal时，这一点需要注意。

ThreadLocal类 源代码

public class ThreadLocal<T> {private final int threadLocalHashCode = nextHashCode();private static AtomicInteger nextHashCode =new AtomicInteger();private static final int HASH_INCREMENT = 0x61c88647;private static int nextHashCode() {return nextHashCode.getAndAdd(HASH_INCREMENT);}protected T initialValue() {return null;}public ThreadLocal() {}public T get() {Thread t = Thread.currentThread();ThreadLocalMap map = getMap(t);if (map != null) {ThreadLocalMap.Entry e = map.getEntry(this);if (e != null)return (T)e.value;}return setInitialValue();}private T setInitialValue() {T value = initialValue();Thread t = Thread.currentThread();ThreadLocalMap map = getMap(t);if (map != null)map.set(this, value);elsecreateMap(t, value);return value;}public void set(T value) {Thread t = Thread.currentThread();ThreadLocalMap map = getMap(t);if (map != null)map.set(this, value);elsecreateMap(t, value);}public void remove() {ThreadLocalMap m = getMap(Thread.currentThread());if (m != null)m.remove(this);}ThreadLocalMap getMap(Thread t) {return t.threadLocals;}void createMap(Thread t, T firstValue) {t.threadLocals = new ThreadLocalMap(this, firstValue);}static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {return new ThreadLocalMap(parentMap);}T childValue(T parentValue) {throw new UnsupportedOperationException();}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;}}private static final int INITIAL_CAPACITY = 16;private Entry[] table;private int size = 0;private int threshold; // Default to 0private void setThreshold(int len) {threshold = len * 2 / 3;}private static int nextIndex(int i, int len) {return ((i + 1 < len) ? i + 1 : 0);}private static int prevIndex(int i, int len) {return ((i - 1 >= 0) ? i - 1 : len - 1);}ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {table = new Entry[INITIAL_CAPACITY];int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);table[i] = new Entry(firstKey, firstValue);size = 1;setThreshold(INITIAL_CAPACITY);}private ThreadLocalMap(ThreadLocalMap parentMap) {Entry[] parentTable = parentMap.table;int len = parentTable.length;setThreshold(len);table = new Entry[len];for (int j = 0; j < len; j++) {Entry e = parentTable[j];if (e != null) {ThreadLocal key = e.get();if (key != null) {Object value = key.childValue(e.value);Entry c = new Entry(key, value);int h = key.threadLocalHashCode & (len - 1);while (table[h] != null)h = nextIndex(h, len);table[h] = c;size++;}}}}private Entry getEntry(ThreadLocal key) {int i = key.threadLocalHashCode & (table.length - 1);Entry e = table[i];if (e != null && e.get() == key)return e;elsereturn getEntryAfterMiss(key, i, e);}private Entry getEntryAfterMiss(ThreadLocal key, int i, Entry e) {Entry[] tab = table;int len = tab.length;while (e != null) {ThreadLocal k = e.get();if (k == key)return e;if (k == null)expungeStaleEntry(i);elsei = nextIndex(i, len);e = tab[i];}return null;}private void set(ThreadLocal key, Object value) {Entry[] tab = table;int len = tab.length;int i = key.threadLocalHashCode & (len-1);for (Entry e = tab[i];e != null;e = tab[i = nextIndex(i, len)]) {ThreadLocal k = e.get();if (k == key) {e.value = value;return;}if (k == null) {replaceStaleEntry(key, value, i);return;}}tab[i] = new Entry(key, value);int sz = ++size;if (!cleanSomeSlots(i, sz) && sz >= threshold)rehash();}private void remove(ThreadLocal key) {Entry[] tab = table;int len = tab.length;int i = key.threadLocalHashCode & (len-1);for (Entry e = tab[i];e != null;e = tab[i = nextIndex(i, len)]) {if (e.get() == key) {e.clear();expungeStaleEntry(i);return;}}}private void replaceStaleEntry(ThreadLocal key, Object value,int staleSlot) {Entry[] tab = table;int len = tab.length;Entry e;int slotToExpunge = staleSlot;for (int i = prevIndex(staleSlot, len);(e = tab[i]) != null;i = prevIndex(i, len))if (e.get() == null)slotToExpunge = i;for (int i = nextIndex(staleSlot, len);(e = tab[i]) != null;i = nextIndex(i, len)) {ThreadLocal k = e.get();if (k == key) {e.value = value;tab[i] = tab[staleSlot];tab[staleSlot] = e;// Start expunge at preceding stale entry if it existsif (slotToExpunge == staleSlot)slotToExpunge = i;cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);return;}// If we didn't find stale entry on backward scan, the// first stale entry seen while scanning for key is the// first still present in the run.if (k == null && slotToExpunge == staleSlot)slotToExpunge = i;}// If key not found, put new entry in stale slottab[staleSlot].value = null;tab[staleSlot] = new Entry(key, value);// If there are any other stale entries in run, expunge themif (slotToExpunge != staleSlot)cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);}private int expungeStaleEntry(int staleSlot) {Entry[] tab = table;int len = tab.length;// expunge entry at staleSlottab[staleSlot].value = null;tab[staleSlot] = null;size--;// Rehash until we encounter nullEntry e;int i;for (i = nextIndex(staleSlot, len);(e = tab[i]) != null;i = nextIndex(i, len)) {ThreadLocal k = e.get();if (k == null) {e.value = null;tab[i] = null;size--;} else {int h = k.threadLocalHashCode & (len - 1);if (h != i) {tab[i] = null;// Unlike Knuth 6.4 Algorithm R, we must scan until// null because multiple entries could have been stale.while (tab[h] != null)h = nextIndex(h, len);tab[h] = e;}}}return i;}private boolean cleanSomeSlots(int i, int n) {boolean removed = false;Entry[] tab = table;int len = tab.length;do {i = nextIndex(i, len);Entry e = tab[i];if (e != null && e.get() == null) {n = len;removed = true;i = expungeStaleEntry(i);}} while ( (n >>>= 1) != 0);return removed;}private void rehash() {expungeStaleEntries();// Use lower threshold for doubling to avoid hysteresisif (size >= threshold - threshold / 4)resize();}private void resize() {Entry[] oldTab = table;int oldLen = oldTab.length;int newLen = oldLen * 2;Entry[] newTab = new Entry[newLen];int count = 0;for (int j = 0; j < oldLen; ++j) {Entry e = oldTab[j];if (e != null) {ThreadLocal k = e.get();if (k == null) {e.value = null; // Help the GC} else {int h = k.threadLocalHashCode & (newLen - 1);while (newTab[h] != null)h = nextIndex(h, newLen);newTab[h] = e;count++;}}}setThreshold(newLen);size = count;table = newTab;}private void expungeStaleEntries() {Entry[] tab = table;int len = tab.length;for (int j = 0; j < len; j++) {Entry e = tab[j];if (e != null && e.get() == null)expungeStaleEntry(j);}}}
}

ThreadLocal原理

Thread类有一个类型为ThreadLocal.ThreadLocalMap的实例变量threadLocals，也就是说每个线程有一个自己的ThreadLocalMap。ThreadLocalMap有自己的独立实现，可以简单地将它的key视作ThreadLocal的一个弱饮用：WeakReference < ThreadLocal < ? > >，value为代码中放入的值。实际上内部实现是一个数组并不是Map，不过起到的效果是相似的。每个线程在往某个ThreadLocal里塞值的时候，都会往自己的ThreadLocalMap里存值和自己线程的ThreadLocal引用，读也是以某个ThreadLocal作为引用，在自己的map里找对应的key，从而实现了线程隔离。

会不会发生内存泄漏

这也是关注比较多的一个点。关于ThreadLocal是否会引起内存泄漏也是一个比较有争议性的问题，其实就是要看对内存泄漏的准确定义是什么。认为ThreadLocal会引起内存泄漏的说法是因为如果一个ThreadLocal对象被回收了，我们往里面放的value对于threadLocals、Entry数组、value这样一条强引用链是可达的，因此value不会被回收。但是在使用get、set方法是，很有可能触发它本身的清理函数，实际上可能会存在内存泄漏问题，但是问题不大。