共计 10653 个字符，预计需要花费 27 分钟才能阅读完成。
敌人们在遇到线程平安问题的时候，大多数状况下可能会应用 synchronized 关键字，每次只容许一个线程进入锁定的办法或代码块，这样就能够保障操作的原子性，保障对公共资源的批改不会呈现莫名其妙的问题。这种加锁的机制，在并发量小的状况下还好，如果并发量较大时，会有大量的线程期待同一个对象锁，会造成零碎吞吐量直线降落。
JDK 的开发者可能也思考到应用 synchronized 的弊病，于是呈现了 volatile 和 ThreadLocal 等另外的思路解决线程平安问题。volatile 它所润饰的变量不保留拷贝，间接拜访主内存，次要用于一写多读的场景。ThreadLocal 是给每一个线程都创立变量的正本，保障每个线程拜访都是本人的正本，互相隔离，就不会呈现线程平安问题，这种形式其实用空间换工夫的做法。其余的内容当前有空再探讨，明天咱们重点聊一下 ThreadLocal。
接下来，咱们将从以下几个方面介绍 ThreadLocal
- 如何应用 ThreadLocal？
- ThreadLocal 的工作原理
- ThreadLocal 源码解析
- ThreadLocal 有哪些坑
1. 如何应用 ThreadLocal？
在应用 ThreadLocal 之前咱们先一起看个例子
/**
* 不平安线程场景
*
* @author sue
* @date 2020/8/12 21:21
*/
public class TestThread {
private int count = 0;
public void calc() {count++;}
public int getCount() {return count;}
public static void main(String[] args) throws InterruptedException {TestThread testThread = new TestThread();
for (int i = 0; i < 20; i++) {new ThreadA(i, testThread).start();}
Thread.sleep(200);
System.out.println("realCount:" + testThread.getCount());
}
}
class ThreadA extends Thread {
private int i;
private TestThread testThread;
ThreadA(int i, TestThread testThread) {
this.i = i;
this.testThread = testThread;
}
public void run() {
try {Thread.sleep(10);
} catch (InterruptedException e) {e.printStackTrace();
}
testThread.calc();
System.out.println("i:" + i + ",count:" + testThread.getCount());
}
}运行后果：
i:8,count:8
i:7,count:8
i:11,count:10
i:4,count:11
i:13,count:12
i:2,count:8
i:0,count:8
i:9,count:8
i:3,count:8
i:1,count:8
i:5,count:8
i:6,count:8
i:12,count:11
i:10,count:9
i:14,count:15
i:18,count:17
i:15,count:18
i:17,count:16
i:16,count:15
i:19,count:18
realCount:18咱们能够看到，realCount 最终呈现谬误，预计的后果应该是 20，理论状况却是 18，呈现了线程平安问题。
接下来，把程序改成 ThreadLocal 运行后果会怎么？
/**
* ThreadLocal 场景
*
* @author sue
* @date 2020/8/12 21:21
*/
public class TestThreadLocal {private ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
public void calc() {threadLocal.set(getCount() + 1);
}
public int getCount() {Integer integer = threadLocal.get();
return integer != null ? integer : 0;
}
public static void main(String[] args) throws InterruptedException {TestThreadLocal testThreadLocal = new TestThreadLocal();
for (int i = 0; i < 20; i++) {new ThreadB(i, testThreadLocal).start();}
Thread.sleep(200);
System.out.println("realCount:" + testThreadLocal.getCount());
}
}
class ThreadB extends Thread {
private int i;
private TestThreadLocal testThreadLocal;
ThreadB(int i, TestThreadLocal testThreadLocal) {
this.i = i;
this.testThreadLocal = testThreadLocal;
}
public void run() {
try {Thread.sleep(10);
} catch (InterruptedException e) {e.printStackTrace();
}
testThreadLocal.calc();
System.out.println("i:" + i + ",count:" + testThreadLocal.getCount());
}
}运行后果：
i:6,count:1
i:10,count:1
i:3,count:1
i:0,count:1
i:7,count:1
i:11,count:1
i:9,count:1
i:5,count:1
i:8,count:1
i:1,count:1
i:4,count:1
i:2,count:1
i:13,count:1
i:15,count:1
i:14,count:1
i:19,count:1
i:18,count:1
i:17,count:1
i:12,count:1
i:16,count:1
realCount:0咱们能够看到，跟之前的例子运行后果差异很大，首先当初 count 全部都是 1，之前 count 有 8，10，11，12 等很多值。其次 realCount 之前是 18，当初的 realCount 却是 0。为什么会造成这样的差别呢？
2.ThreadLocal 的工作原理
先看看示例 1 中的状况
咱们能够看到多个线程能够同时拜访公共资源 count，当某个线程在执行 count++ 的时候，可能其余的线程正好同时也执行 count++。但因为多个线程变量 count 的不可见性，会导致另外的线程拿到旧的 count 值 +1，这样就呈现了 realCount 预计是 20，然而实际上是 18 的数据问题。
再看看示例 2 中的状况：
如图所示，往大的方向上说，ThreadLocal 会给每一个线程都创立变量的正本，保障每个线程拜访都是本人的正本，互相隔离。
往小的方向上说，每个线程外部都有一个 threadLocalMap，每个 threadLocalMap 外面都蕴含了一个 entry 数组，而 entry 是由 threadLocal 和数据（这里指的是 count）组成的。这样一来，每个线程都领有本人专属的变量 count。示例 2 中线程 1 调用 calc 办法时，会先调用的 getCount 办法，因为第一次调用 threadLocal.get()返回是空的，所以 getCount 返回值是 0。这样 threadLocal.set(getCount() + 1); 就变成了 threadLocal.set(0 + 1); 它会给线程 1 中 threadLocal 的数据值设置成 1。线程 2 再调用 calc 办法，同样会先调用 getCount 办法，因为第一次调用 threadLocal.get()返回是空的，所以 getCount 返回值也是 0。这样 threadLocal.set(getCount() + 1); 会给线程 2 中 threadLocal 的数据值也设置成 1。。。。。。最初每个线程的 threadLocal 中的数据值都是 1。
还有，示例 2 中打印进去的 realCount 为什么是 0 呢？
因为 testThreadLocal.getCount()是在主线程中调用的，其余的线程扭转只会影响本人的正本，不会影响原始变量，count 初始值是 0，所以最初还是 0。
**3.ThreadLocal 源码解析
**
在介绍 ThreadLocal 之前，让咱们一起先看看 Thread 类
ThreadLocal.ThreadLocalMap threadLocals = null;能够看到 Thread 类中定义了一个叫 threadLocals 的成员变量，它的类型是 ThreadLocal.ThreadLocalMap。很显著 ThreadLocalMap 是 ThreadLocal 的外部类，验证了我在图中画的内容，每个线程都有一个 ThreadLocalMap 对象。
咱们再重点看看 ThreadLocalMap
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;
}
}
/**
* The initial capacity -- MUST be a power of two.
*/
private static final int INITIAL_CAPACITY = 16;
/**
* The table, resized as necessary.
* table.length MUST always be a power of two.
*/
private Entry[] table;
/**
* The number of entries in the table.
*/
private int size = 0;
/**
* The next size value at which to resize.
*/
private int threshold; // Default to 0
/**
* Set the resize threshold to maintain at worst a 2/3 load factor.
*/
private void setThreshold(int len) {threshold = len * 2 / 3;}
........ 省略
}因为该办法太长了，我在这里省略了局部内容。从以上代码能够看到 ThreadLocalMap 外面蕴含了一个叫 table 的数组，它的类型是 Entry，Entry 是 WeakReference（弱援用）的子类，Entry 又蕴含了 ThreadLocal 变量 和 Object 的 value，其中 ThreadLocal 变量做为 WeakReference 的 referent。
接下来，咱们再回到 ThreadLocal 类，罕用的其实就上面四个办法：get()，initialValue()，set(T value) 和 remove()，接下来咱们会逐个介绍。
首先看看 get() 办法
public T get() {
// 获取以后线程
Thread t = Thread.currentThread();
// 获取以后线程中的 ThreadLocalMap 对象
ThreadLocalMap map = getMap(t);
// 如果能够查问到数据
if (map != null) {
// 从 ThreadLocalMap 中获取 entry 对象
ThreadLocalMap.Entry e = map.getEntry(this);
// 如果 entry 存在
if (e != null) {@SuppressWarnings("unchecked")
// 获取 entry 中的值
T result = (T)e.value;
// 返回获取到的值
return result;
}
}
// 调用初始化办法
return setInitialValue();}其中的 getMap 办法
ThreadLocalMap getMap(Thread t) {return t.threadLocals;}再简略不过了，间接返回的是以后线程的成员变量 threadLocals
再看看 getEntry 办法
private Entry getEntry(ThreadLocal<?> key) {
//threadLocalHashCode 是 key 的 hash 值
//key.threadLocalHashCode & (table.length - 1)，// 相当于 threadLocalHashCode 对 table.length - 1 的取余操作，// 这样能够保障数组的下表在 0 到 table.length - 1 之间。int i = key.threadLocalHashCode & (table.length - 1);
// 获取下标对应的 entry
Entry e = table[i];
// 如果 entry 不为空，并且从弱援用中获取到的值(threadLocal) 和 key 雷同
if (e != null && e.get() == key)
// 返回获取到的 entry
return e;
else
// 如果没有获取到 entry 或者 e.get()获取不到数据，则清理空数据
return getEntryAfterMiss(key, i, e);
}我之前说过 entry 是 WeakReference 的子类，那么 e.get()办法会调用：
public T get() {return this.referent;}返回的是一个援用，这个援用就是结构器传入的 threadLocal 对象。
getEntryAfterMiss 外面有阐明逻辑呢？
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;
}该办法外面会调用 expungeStaleEntry 办法，前面咱们会重点介绍的。
再看看 setInitialValue 办法
protected T initialValue() {
return null; }
private T setInitialValue() {
// 调用用户自定义的 initialValue 办法，默认值是 null
T value = initialValue();
// 获取以后线程
Thread t = Thread.currentThread();
// 获取以后线程中的 ThreadLocalMap，跟之前一样
ThreadLocalMap map = getMap(t);
// 如果 ThreadLocalMap 不为空，if (map != null)
// 则笼罩 key 为以后 threadLocal 的值
map.set(this, value);
else
// 否则创立新的 ThreadLocalMap
createMap(t, value);
// 返回用户自定义的值
return value;
}当中的 initialValue()办法，就是咱们要介绍的第二个办法
protected T initialValue() {return null;}咱们能够看到该办法只有一个空实现，等着用户的子类重写之后从新实现。
接下来重点看看 threadLocalMap 的 set 办法
private void set(ThreadLocal<?> key, Object value) {
// 将 table 数组赋值给新数组 tab
Entry[] tab = table;
// 获取数组长度
int len = tab.length;
// 跟之前一样计算数组中的下表
int i = key.threadLocalHashCode & (len-1);
// 循环变量 tab 获取 entry
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
// 获取 entry 中的 threadLocal 对象
ThreadLocal<?> k = e.get();
// 如果 threadLocal 对象不为空，并且等于 key
if (k == key) {
// 笼罩已有数据
e.value = value;
// 返回
return;
}
// 如果 threadLocal 对象为空
if (k == null) {
// 创立一个新的 entry 赋值给已有 key
replaceStaleEntry(key, value, i);
return;
}
}
// 如果 key 不在已有数据中，则创立一个新的 entry
tab[i] = new Entry(key, value);
// 长度 +1
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();}replaceStaleEntry 办法也会调用 expungeStaleEntry 办法。
再看看 setInitialValue 办法中的 createMap 办法
void createMap(Thread t, T firstValue) {t.threadLocals = new ThreadLocalMap(this, firstValue);
}代码很简略，就是 new 了一个 ThreadLocalMap 对象。
好了，到这来 get() 和 initialValue() 办法介绍完了。
上面介绍 set(T value) 办法
public void set(T value) {
// 获取以后线程，都是一样的套路
Thread t = Thread.currentThread();
// 依据以后线程获取当中的 ThreadLocalMap
ThreadLocalMap map = getMap(t);
//ThreadLocalMap 不为空，则调用之前介绍过的 ThreadLocalMap 的 set 办法
if (map != null)
map.set(this, value);
else
// 如果 ThreadLocalMap 为空，则创立一个对象，之前也介绍过
createMap(t, value);
}so easy
最初，看看 remove()办法
public void remove() {
// 还是那个套路，不过简化了一下
// 先获取以后线程，再获取线程中的 ThreadLocalMap 对象
ThreadLocalMap m = getMap(Thread.currentThread());
// 如果 ThreadLocalMap 不为空
if (m != null)
// 删除数据
m.remove(this);
}这个办法的要害就在于 ThreadLocalMap 类的 remove 办法
private void remove(ThreadLocal<?> key) {
// 将 table 数组赋值给新数组 tab
Entry[] tab = table;
// 获取数组长度
int len = tab.length;
// 跟之前一样计算数组中的下表
int i = key.threadLocalHashCode & (len-1);
// 循环变量从下表 i 之后不为空的 entry
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
// 如果能够获取到 threadLocal 并且值等于 key
if (e.get() == key) {
// 清空援用
e.clear();
// 解决 threadLocal 为空然而 value 不为空的 entry
expungeStaleEntry(i);
return;
}
}
}其中的 clear 办法，也很简略，只是把援用设置为 null，即清空援用
public void clear() {this.referent = null;}咱们能够看到 get()、set(T value) 和 remove()办法，都会调用 expungeStaleEntry 办法，咱们接下来重点看一下 expungeStaleEntry 办法
private int expungeStaleEntry(int staleSlot) {Entry[] tab = table;
int len = tab.length;
// 将地位 staleSlot 对应的 entry 中的 value 设置为 null，有助于垃圾回收
tab[staleSlot].value = null;
// 将地位 staleSlot 对应的 entry 设置为 null，有助于垃圾回收
tab[staleSlot] = null;
// 数组大小 -1
size--;
Entry e;
int i;
// 变量 staleSlot 之后 entry 不为空的数据
for (i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
// 获取以后地位的 entry 中对应的 threadLocal
ThreadLocal<?> k = e.get();
//threadLocal 为空，阐明是脏数据
if (k == null) {
//value 设置为 null，有助于垃圾回收
e.value = null;
// 以后地位的 entry 设置为 null
tab[i] = null;
// 数组大小 -1
size--;
} else {
// 从新计算地位
int h = k.threadLocalHashCode & (len - 1);
// 如果 h 和 i 不相等，阐明存在 hash 抵触
// 当初它后面的脏 Entry 被清理
// 该 Entry 须要向前挪动，避免下次 get()或 set()的时候
// 再次因散列抵触而查找到 null 值
if (h != i) {tab[i] = null;
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}该办法首先革除以后地位的脏 Entry，而后向后遍历直到 table[i]==null。在遍历的过程中如果再次遇到脏 Entry 就会清理。如果没有遇到就会从新变量以后遇到的 Entry，如果从新散列失去的下标 h 与以后下标 i 不统一，阐明该 Entry 被放入 Entry 数组的时候产生了散列抵触（其地位通过再散列被向后偏移了），当初其后面的脏 Entry 曾经被革除，所以以后 Entry 应该向前挪动，补上空地位。否则下次调用 set()或 get()办法查找该 Entry 的时候会查找到位于其之前的 null 值。
为什么要做这样的革除？
咱们晓得 entry 对象外面蕴含了 threadLocal 和 value，threadLocal 是 WeakReference（弱援用）的 referent。每次垃圾回收期触发 GC 的时候，都会回收 WeakReference 的 referent，会将 referent 设置为 null。那么 table 数组中就会存在很多 threadLocal = null 然而 value 不为空的 entry，这种 entry 的存在是没有任何理论价值的。这种数据通过 getEntry 是获取不到值，因为它外面有 if (e != null && e.get() == key)这句判断。
为什么要应用 WeakReference（弱援用）？
如果应用强援用，ThreadLocal 在用户过程不再被援用，然而只有线程不完结，在 ThreadLocalMap 中就还存在援用，无奈被 GC 回收，会导致内存透露。如果用户线程耗时十分长，这个问题尤为显著。
另外在应用线程池技术的时候，因为线程不会被销毁，回收之后，下一次又会被反复利用，会导致 ThreadLocal 无奈被开释，最终也会导致内存泄露问题。
4.ThreadLocal 有哪些坑
内存泄露问题：
ThreadLocal 即便应用了 WeakReference（弱援用）也可能会存在内存泄露问题，因为 entry 对象中只把 key(即 threadLocal 对象)设置成了弱援用，然而 value 值没有。还是会存在上面的强依赖：
Thread -> ThreaLocalMap -> Entry -> value要解决这个问题就须要调用 get()、set(T value) 或 remove()办法。然而 get()和 set(T value) 办法是基于垃圾回收器把 key 回收之后的根底之上触发的数据清理。如果呈现垃圾回收器回收不及时的状况，也一样有问题。
所以，最保险的做法是在应用完 threadLocal 之后，手动调用一下 remove 办法，从源码能够看到，该办法会把 entry 中的 key(即 threadLocal 对象)和 value 一起清空。
线程平安问题：
可能有些敌人认为应用了 threadLocal 就不会呈现线程平安问题了，其实是不对的。如果咱们定义了一个 static 的变量 count，多线程的状况下，threadLocal 中的 value 须要批改并设置 count 的值，它一样有问题。因为 static 的变量是多个线程共享的，不会再独自保留正本。
5. 总结
1. 每个线程都有一个 threadLocalMap 对象，每个 threadLocalMap 外面都蕴含了一个 entry 数组，而 entry 是由 key（即 threadLocal）和 value（数据）组成。
2.entry 的 key 是弱援用，能够被垃圾回收器回收。
3.threadLocal 最罕用的这四个办法：get()，initialValue()，set(T value) 和 remove()，除了 initialValue 办法，其余的办法都会调用 expungeStaleEntry 办法做 key==null 的数据清理工作。
4.threadLocal 可能存在内存泄露和线程平安问题，应用完之后，要手动调用 remove 办法。
敌人们如果喜爱这篇文章的话，请关注一下我的公众账号：苏三说技术，前面会有很多干货分享，谢谢大家。
