1.概述
ThreadLocal并不是為了解決保證多線程對共享變量的使用，而是當每個線程需要使用一個變量時，將該變量保存到當前線程中，實現(xiàn)了多副本保存。
這是由于每個線程都維護了一個字段ThreadLocal.ThreadLocalMap threadLocals = null;，在這個map中，key是ThreadLocal的實例的引用，val是set方法傳入的值。如果定義了多個ThreadLocal的實例對象，這個map中就會包含多個值。
2.基本使用
public class ThreadLocalTest {
static ThreadLocal<String> localVar = new ThreadLocal<>();
static void print(String str) {
//打印當前線程中本地內(nèi)存中本地變量的值
System.out.println(str + " :" + localVar.get());
//清除本地內(nèi)存中的本地變量
localVar.remove();
}
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
//設置線程1中本地變量的值
localVar.set("localVar1");
//調(diào)用打印方法
print("thread1");
//打印本地變量
System.out.println("after remove : " + localVar.get());
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
//設置線程1中本地變量的值
localVar.set("localVar2");
//調(diào)用打印方法
print("thread2");
//打印本地變量
System.out.println("after remove : " + localVar.get());
}
});
t1.start();
t2.start();
}
}
輸出結果為：
thread1 :localVar1
after remove : null
thread2 :localVar2
after remove : null
3.應用場景
數(shù)據(jù)塊連接池
Spring中Dao層裝配的Connection,由于Dao層使用單例，那么負責數(shù)據(jù)庫連接的Connection也只有一個， 如果每個請求線程都使用同一個連接去連接數(shù)據(jù)庫，那么就會造成線程不安全的問題。解決方法就是使用ThreadLocal，當每個請求線程使用Connection的時候， 都會從ThreadLocal獲取一次，如果為null，說明沒有進行過數(shù)據(jù)庫連接，連接后存入ThreadLocal中，如此一來，每一個請求線程都保存有一份 自己的Connection。于是便解決了線程安全問題。
4.四大引用
強引用
是指創(chuàng)建一個對象并把這個對象賦給一個引用變量。強引用有引用變量指向時永遠不會被垃圾回收，JVM寧愿拋出OutOfMemory錯誤也不會回收這種對象。
軟引用
垃圾回收時如果內(nèi)存不夠就回收，否則不回收
弱引用
只要觸發(fā)垃圾回收就一定會回收
虛引用
任何時候都會被回收，需要配合Reference使用
例子
public class Reference {
public static void main(String[] args) {
System.out.println("soft");
testSoft();
System.out.println("weak");
testWeak();
System.out.println("Phantom");
testPhantom();
}
static void testSoft(){
SoftReference<String[]> sr = new SoftReference<>(new String[8]);
System.out.println(sr.get());;
System.gc();
System.out.println(sr.get());
}
static void testWeak(){
WeakReference<String[]> sr = new WeakReference<>(new String[8]);
System.out.println(sr.get());;
System.gc();
System.out.println(sr.get());
}
static void testPhantom(){
ReferenceQueue<String[]> q = new ReferenceQueue<>();
PhantomReference<String[]> sr = new PhantomReference<>(new String[8],q);
System.out.println(sr.get());;
System.gc();
System.out.println(sr.get());
}
}
輸出：
soft
[Ljava.lang.String;@1540e19d
[Ljava.lang.String;@1540e19d
weak
[Ljava.lang.String;@677327b6
null
Phantom
null
null
5.弱引用問題
在ThreadLocalMap中每個Entry定義如下：
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
可以看到，其中key是弱引用。其中指向關系如下
問題1.先執(zhí)行set,再gc ,keynull嗎(ThreadLocal對象的實例還存在嗎)？
不會，設A對象中包含一個ThreadLocal對象的實例，因為A對象沒有被回收，ThreadLocal對象不會被回收，key就還存在。
問題2.什么時候key為null
如果A對象被回收，ThreadLocal對象就會被回收，進行一次gc，由于key是弱引用，那么ThreadLocal對象就會被回收，key=null。
問題3.為什么key被設計為弱引用
假設key被設計為強引用，如果讓ThreadLocal這個引用=null，但由于key是強引用，指向?qū)嶋H的ThreadLocal對象，因此ThreadLocal對象不會被回收.我們既不能訪問到ThreadLocal,又不能被回收,因此發(fā)生內(nèi)存泄漏.
而如果key是弱引用，當ThreadLocal這個引用=null，key是弱引用，進行一次gc會讓該引用為null,然后ThreadLocal對象就會被回收.ThreadLocalMap還會根據(jù)Entry!=null && key == null 清理掉無效的value，保證Entry正常回收。
同時我們也看出，如果ThreadLocal實例如果聲明成static會保證正常使用。
6.源碼剖析
1.set方法
步驟一：
獲取當前線程，不存在map則創(chuàng)建，否則調(diào)用map的set方法
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
步驟二：
循環(huán)往后找，如果找到一個key相等的直接替換并返回，如果找到一個待清理（key == null && Entry != null）的,執(zhí)行替換replaceStaleEntry(key, value, i)并返回，否則找到的就是空的，創(chuàng)建新的，執(zhí)行啟發(fā)式清理，如果啟發(fā)式清理沒有清理任何Entry且里面的Entry數(shù)量達到了數(shù)組長度的2/3，進行擴容。
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();
}
步驟三：
替換replaceStaleEntry(key, value, i)
(1)從當前位置向前查找，如果找到前面第一個待回收的，如果到了null，就結束，標記為slotToExpunge
(2)從當前位置向后查找，如果找到了和當前key相等的，替換value,并交換當前Entry[i] 和EntrystaleSlot，(更靠近了)。
如果上一步?jīng)]有找到更前面的待回收的Entry，將slotToExpunge設為i
從slotToExpunge執(zhí)行一次探測式清理，并將返回值返回，進行一次啟發(fā)式清理，并返回.
如果往后找時找到了待回收的,更新slotToExpunge為i,因為循環(huán)外是在傳入?yún)?shù)的位置插入的值。
(3)staleSlot插入新值，如果上面找到了其他待回收的，執(zhí)行cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
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;
if (slotToExpunge == staleSlot)
slotToExpunge = i;
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
return;
}
if (k == null && slotToExpunge == staleSlot)
slotToExpunge = i;
}
tab[staleSlot].value = null;
tab[staleSlot] = new Entry(key, value);
if (slotToExpunge != staleSlot)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}
2.hash算法
下標的計算是通過一個固定值&（len - 1），下一個要添加的值的下標是通過獲取ThreadLocal的屬性private final int threadLocalHashCode = nextHashCode();實現(xiàn)的
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);
}
static class ThreadLocalMap {
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);
}
}
}
public final int getAndAdd(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta);
}
3.hash沖突
每次沖突后采用線性探測，循環(huán)往后找
綠色：key != null & Entry != null
灰色：key = null & Entry != null
白色: Entry != null
4.探測式清理
先直接將Entry和value置空，再探測，如果遇到null，則結束，遇到待回收的，令Entry == null,value == null,遇到正常的，判斷index是否和正常計算的結果一致，不一致則從應該開始的位置遍歷，如果找到null，則放入該位置.返回值為Entry == null 的位置,代表之前的位置都被我清理了.
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
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;
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}
5.擴容機制
在擴容前，先從頭進行一次探測式清理，如果清理結束，當前的size依然大于等于threshold*3/4，則擴容。
private void rehash() {
expungeStaleEntries();
if (size >= threshold - threshold / 4)
resize();
}
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);
}
}
擴容就是將容量擴大為2倍，然后從頭遍歷，對每個元素重新rehash,如果key為null，則置value為null,如果Entry != null && key != null， 則將往后找第一個為null的位置，然后插入
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;
} 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;
}
6.get方法
如果直接定位到，則返回,否則往后找，如果是待清理的則從當前位置執(zhí)行一次探測式清理，清理過程中，在expungeStaleEntry中將不會被回收的往前移動。最后返回
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);
}
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;
}
7.啟發(fā)式清理
至少進行l(wèi)og2len次探測式清理，每次清理都是一段（不包含空），如果當中找到了待清理的對象，重新設置清理次數(shù)為log2len
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;
}
