背景
一直以來對ThreadLocal用法模棱兩可，不知道怎么用今天好好研究了下給大家分享下。
-
1、講解ThreadLocal之前先回顧下什么是取模、x^y、弱引用。
1. 取模運(yùn)算實際上是計算兩數(shù)相除以后的余數(shù).
假設(shè)a除以b的商是c，d是相對應(yīng)的余數(shù)，那么幾乎所有的計算機(jī)系統(tǒng)都滿足a = c* b + d。所以d=a-b*c。
?17 % 10 的計算結(jié)果如下：d = (17) - (17 / 10) x 10 = (17) - (1 x 10) = 7
?-17 % 10 的計算結(jié)果如下：d = (-17) - (-17 / 10) x 10 = (-17) - (-1 x 10) = -7
-17 % -10 的計算結(jié)果如下：d = 17 - (17 / -10) x (-10) = (17) - (-1 x -10) = 7
-17 % -10 的計算結(jié)果如下：d= (-17) - (-17 / -10) x (-10) = (-17) - (1 x -10) = -7
可以看出：運(yùn)算結(jié)果的符號始終和被模數(shù)的符號一致。
2. x^y 按位取異或。
如：x是二進(jìn)制數(shù)0101 y是二進(jìn)制數(shù)1011 則結(jié)果為x＾y=1110,0＾1=1,0＾0=0,1＾1=0,1＾0=1！只要有一個為1就取值為1。
3. 弱引用
弱引用也是用來描述非必需對象的，當(dāng)JVM進(jìn)行垃圾回收時，無論內(nèi)存是否充足，都會回收被弱引用關(guān)聯(lián)的對象。在java中，用java.lang.ref.WeakReference類來表示。這里所說的被弱引用關(guān)聯(lián)的對象是指只有弱引用與之關(guān)聯(lián)，如果存在強(qiáng)引用同時與之關(guān)聯(lián)，則進(jìn)行垃圾回收時也不會回收該對象。
-
2、講解之前先問兩個問題
1.什么是ThreadLocal
ThreadLocal從字面意識可以理解為線程本地變量。也就是說如果定義了ThreadLocal，每個線程往這個ThreadLocal中讀寫是線程隔離，互相之間不會影響的。它提供了一種將可變數(shù)據(jù)通過每個線程有自己的獨立副本從而實現(xiàn)線程封閉的機(jī)制。
2.實現(xiàn)的思路是什么
Tread類有一個類型為ThreadLocal.ThreadLocalMap的實例變量threadLocals，我們使用線程的時候有一個自己的ThreadLocalMap。ThreadLocalMap有自己的獨立實現(xiàn)，可以簡單把ThreadLocal視為key，value為代碼中放入的值(實際上key并不是ThreadLocal本身，通過源碼可以知道它是一個弱引用)。調(diào)用ThreadLocal的set方法時候，都會存到ThreadLocalMap里面。調(diào)用ThreadLocal的get方法時候，在自己map里面找key，從而實現(xiàn)線程隔離。
-
3、ThreadLocal最主要的實現(xiàn)在于ThreadLocalMap這個內(nèi)部類里面，我們重點關(guān)注ThreadLocalMap這個類的用法，看看兩位大師Josh Bloch and Doug Lea鬼斧神刀設(shè)計出如此好的類。
-
4、ThreadLocalMap
image.png
上面是ThreadLocalMap所有的API
ThreadLocalMap提供了一種為ThreadLocal定制的高效實現(xiàn)，并且自帶一種基于弱引用的垃圾清理機(jī)制。
- 存儲結(jié)構(gòu)方面
存儲結(jié)構(gòu)可以理解為一個map，但是不要和java.util.Map弄混。
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
從上面代碼可以看出Entry便是ThreadLocalMap里定義的節(jié)點，它繼承了WeakReference類，定義了一個類型為Object的value，用于存放塞到ThreadLocal里的值，key可以視為為ThreadLocal。
- 為什么要用弱引用，因為如果這里使用普通的key-value形式來定義存儲結(jié)構(gòu)，實質(zhì)上就會造成節(jié)點的生命周期與線程強(qiáng)綁定，只要線程沒有銷毀，那么節(jié)點在GC分析中一直處于可達(dá)狀態(tài)，沒辦法被回收，而程序本身也無法判斷是否可以清理節(jié)點。弱引用是Java四種引用的的第三種(其它三種強(qiáng)引用、軟引用、虛引用)，比軟引用更加弱一些，如果一個對象沒有強(qiáng)引用鏈可達(dá)，那么一般活不過下一次GC。當(dāng)某個ThreadLocal已經(jīng)沒有強(qiáng)引用可達(dá)，則隨著它被垃圾回收，在ThreadLocalMap里對應(yīng)的Entry的鍵值會失效，這為ThreadLocalMap本身的垃圾清理提供了便利。
- Entry里面的成員變量和方法
/**
* 初始容量，必須為2的冪.
*/
private static final int INITIAL_CAPACITY = 16;
/**
* 根據(jù)需要調(diào)整大小。
* 長度必須總是2的冪。
*/
private Entry[] table;
/**
* 表中條目的數(shù)量。
*/
private int size = 0;
/**
* 要調(diào)整大小的下一個大小值。默認(rèn)為0
*/
private int threshold; // Default to 0
/**
* 將調(diào)整大小閾值設(shè)置維持最壞2/3的負(fù)載因子。
*/
private 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使用線性探測法來解決散列沖突，所以實際上Entry[]數(shù)組在程序邏輯上是作為一個環(huán)形存在的。
- 構(gòu)造函數(shù)
/**
* Construct a new map initially containing (firstKey, firstValue).
* ThreadLocalMaps are constructed lazily, so we only create
* one when we have at least one entry to put in it.
* 構(gòu)造一個最初包含(firstKey, firstValue)的新映射threadlocalmap是延遲構(gòu)造的，因
* 此當(dāng)我們至少有一個元素可以放進(jìn)去的時候才去創(chuàng)建。
*/
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);
}
重點說下這個hash函數(shù)int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
ThreadLocal類中有一個被final修飾的類型為int的threadLocalHashCode，它在該ThreadLocal被構(gòu)造的時候就會生成，相當(dāng)于一個ThreadLocal的ID，而它的值來源于
private final int threadLocalHashCode = nextHashCode();
/**
* The next hash code to be given out. Updated atomically. Starts at
* zero.
*/
private static AtomicInteger nextHashCode =
new AtomicInteger();
/**
* 連續(xù)生成的哈希碼之間的區(qū)別——循環(huán)隱式順序線程本地id以近乎最優(yōu)的方式展開
* 用于兩倍大小表的乘法哈希值。
*/
private static final int HASH_INCREMENT = 0x61c88647;
/**
* 返回下一個hashcode
*/
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
通過理論和實踐算出通，當(dāng)我們用0x61c88647作為魔數(shù)累加為每個ThreadLocal分配各自的ID也就是threadLocalHashCode再與2的冪取模，得到的結(jié)果分布很均勻。
ThreadLocalMap使用的是線性探測法，均勻分布的好處在于很快就能探測到下一個臨近的可用slot，從而保證效率。這就回答了上文拋出的為什么大小要為2的冪的問題。為了優(yōu)化效率。對于& (INITIAL_CAPACITY - 1)，相信有過算法閱讀源碼較多的程序員，一看就明白，對于2的冪作為模數(shù)取模，可以用&(2^n-1) 來替代%2n，位運(yùn)算比取模效率高很多。至于為什么，因為對2n取模，只要不是低n位對結(jié)果的貢獻(xiàn)顯然都是0，會影響結(jié)果的只能是低n位。
- TreadLocal中的get方法
ThreadLocal中的get方法會調(diào)用這個ThreadLocalMap中的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);
}
/**
* Version of getEntry method for use when key is not found in
* its direct hash slot.
*
* @param key the thread local object
* @param i the table index for key's hash code
* @param e the entry at table[i]
* @return the entry associated with key, or null if no such
*/
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);
else
i = nextIndex(i, len);
e = tab[i];
}
return null;
}
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// expunge entry at staleSlot
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
// Rehash until we encounter null
Entry 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 int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// expunge entry at staleSlot
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
// Rehash until we encounter null
Entry 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;
}
這上面的注釋很清楚，這里都不在多講了
簡單說下當(dāng)調(diào)用get方法時候遇到的情況
根據(jù)入?yún)hreadLocal的threadLocalHashCode對表容量取模得到index如果index對應(yīng)的slot就是要讀的threadLocal，則直接返回結(jié)果
調(diào)用getEntryAfterMiss線性探測，過程中每碰到無效slot，調(diào)用expungeStaleEntry進(jìn)行段清理；如果找到了key，則返回結(jié)果entry
沒有找到key，返回null
- TreadLocal中的set方法
/**
* Set the value associated with key.
*
* @param key the thread local object
* @param value the value to be set
*/
private void set(ThreadLocal<?> key, Object value) {
// We don't use a fast path as with get() because it is at
// least as common to use set() to create new entries as
// it is to replace existing ones, in which case, a fast
// path would fail more often than not.
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();
}
/**
* Replace a stale entry encountered during a set operation
* with an entry for the specified key. The value passed in
* the value parameter is stored in the entry, whether or not
* an entry already exists for the specified key.
*
* As a side effect, this method expunges all stale entries in the
* "run" containing the stale entry. (A run is a sequence of entries
* between two null slots.)
*
* @param key the key
* @param value the value to be associated with key
* @param staleSlot index of the first stale entry encountered while
* searching for key.
*/
private void replaceStaleEntry(ThreadLocal<?> key, Object value,
int staleSlot) {
Entry[] tab = table;
int len = tab.length;
Entry e;
// Back up to check for prior stale entry in current run.
// We clean out whole runs at a time to avoid continual
// incremental rehashing due to garbage collector freeing
// up refs in bunches (i.e., whenever the collector runs).
int slotToExpunge = staleSlot;
for (int i = prevIndex(staleSlot, len);
(e = tab[i]) != null;
i = prevIndex(i, len))
if (e.get() == null)
slotToExpunge = i;
// Find either the key or trailing null slot of run, whichever
// occurs first
for (int i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
// If we find key, then we need to swap it
// with the stale entry to maintain hash table order.
// The newly stale slot, or any other stale slot
// encountered above it, can then be sent to expungeStaleEntry
// to remove or rehash all of the other entries in run.
if (k == key) {
e.value = value;
tab[i] = tab[staleSlot];
tab[staleSlot] = e;
// Start expunge at preceding stale entry if it exists
if (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 slot
tab[staleSlot].value = null;
tab[staleSlot] = new Entry(key, value);
// If there are any other stale entries in run, expunge them
if (slotToExpunge != staleSlot)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}
/**
* Heuristically scan some cells looking for stale entries.
* This is invoked when either a new element is added, or
* another stale one has been expunged. It performs a
* logarithmic number of scans, as a balance between no
* scanning (fast but retains garbage) and a number of scans
* proportional to number of elements, that would find all
* garbage but would cause some insertions to take O(n) time.
*
* @param i a position known NOT to hold a stale entry. The
* scan starts at the element after i.
*
* @param n scan control: {@code log2(n)} cells are scanned,
* unless a stale entry is found, in which case
* {@code log2(table.length)-1} additional cells are scanned.
* When called from insertions, this parameter is the number
* of elements, but when from replaceStaleEntry, it is the
* table length. (Note: all this could be changed to be either
* more or less aggressive by weighting n instead of just
* using straight log n. But this version is simple, fast, and
* seems to work well.)
*
* @return true if any stale entries have been removed.
*/
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 hysteresis
if (size >= threshold - threshold / 4)
resize();
}
/**
* Double the capacity of the table.
*/
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;
}
/**
* Expunge all stale entries in the table.
*/
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);
}
}
簡單總結(jié)下上面的用法
a、探測過程中slot都不無效，并且順利找到key所在的slot，直接替換即可
b、探測過程中發(fā)現(xiàn)有無效slot，調(diào)用replaceStaleEntry，效果是最終一定會把key和value放在這個slot，并且會盡可能清理無效slot
在replaceStaleEntry過程中，如果找到了key，則做一個swap把它放到那個無效slot中，value置為新值
在replaceStaleEntry過程中，沒有找到key，直接在無效slot原地放entry
c、探測沒有發(fā)現(xiàn)key，則在連續(xù)段末尾的后一個空位置放上entry，這也是線性探測法的一部分。放完后，做一次啟發(fā)式清理，如果沒清理出去key，并且當(dāng)前table大小已經(jīng)超過閾值了，則做一次rehash，rehash函數(shù)會調(diào)用一次全量清理slot方法也expungeStaleEntries，如果完了之后table大小超過了threshold - threshold / 4，則進(jìn)行擴(kuò)容2倍
6、ThreadLocal中的remove方法調(diào)用TreadLocalMap中的remove
/**
* Remove the entry for key.
*/
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;
}
}
}
這個方法比較簡單，找到key就清除
- ThreadLocal會不會遇到內(nèi)存泄漏問題
有關(guān)于內(nèi)存泄露是因為在有線程復(fù)用如線程池的場景中，一個線程的生命周期很長，大對象長期不被回收影響系統(tǒng)運(yùn)行效率與安全。如果線程不會復(fù)用，用完即銷毀了也不會有ThreadLocal引發(fā)內(nèi)存泄露的問題。
仔細(xì)讀過ThreadLocalMap的源碼，可以推斷，如果在使用的ThreadLocal的過程中，習(xí)慣加上remove，這樣是不會引起內(nèi)存泄漏。
如果沒有進(jìn)行remove呢？如果對應(yīng)線程之后調(diào)用ThreadLocal的get和set方法都有很高的概率會順便清理掉無效對象，斷開value強(qiáng)引用，從而大對象被收集器回收。
我們應(yīng)該考慮到何時調(diào)用ThreadLocal的remove方法。一個比較熟悉的場景就是對于一個請求一個線程的server如tomcat，在代碼中對web api作一個切面，存放一些如用戶名等用戶信息，在連接點方法結(jié)束后，再顯式調(diào)用remove。
以上都是理論，我們做一個小實驗
/**
* @author shuliangzhao
* @Title: ThreadLocalDemo
* @ProjectName design-parent
* @Description: TODO
* @date 2019/6/1 0:00
*/
public class ThreadLocalDemo {
private static ThreadLocal<ThreadLocalDemo> t = new ThreadLocal<>();
private ThreadLocalDemo() {}
public static ThreadLocalDemo getInstance() {
ThreadLocalDemo threadLocalDemo = ThreadLocalDemo.t.get();
if (null == threadLocalDemo) {
threadLocalDemo = new ThreadLocalDemo();
t.set(threadLocalDemo);
}
return threadLocalDemo;
}
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public static void main(String[] args) {
long i = (1L << 32) - (long) ((1L << 31) * (Math.sqrt(5) - 1));
System.out.println(i);
int i1 = 55&(2^2-1);
System.out.println(55%2^2);
System.out.println(i1);
}
}
/**
* @author shuliangzhao
* @Title: ThreadLocalTest
* @ProjectName design-parent
* @Description: TODO
* @date 2019/6/1 0:03
*/
public class ThreadLocalTest {
public static void main(String[] args) {
for(int i=0; i<2;i++){
new Thread(new Runnable() {
@Override
public void run() {
Double d = Math.random()*10;
ThreadLocalDemo.getInstance().setName("name "+d);
new A().get();
new B().get();
}
}).start();
}
}
static class A{
public void get(){
System.out.println(ThreadLocalDemo.getInstance().getName());
}
}
static class B{
public void get(){
System.out.println(ThreadLocalDemo.getInstance().getName());
}
}
}
運(yùn)行結(jié)果
image.png
到這里我們就把ThreadLocal講完了，可以多看看源碼，看看大牛們是怎么設(shè)計出如此優(yōu)美的代碼。
