Java多线程中ThreadLocal解读
作者：姚舜禹_12140
一、ThreadLocal简介
1、介绍
多线程访问同一个共享变量的时候容易出现并发问题，因此为了保证线程安全性，我们都会采用加锁的方式。
而ThreadLocal是除加锁方式之外的另一种保证线程安全性的方法。
ThreadLocal通过每个线程保存一份资源的副本，且这个副本只能被当前线程访问。这样的话每个线程都拥有一份，那么自然而然也就不需要对资源竞争了。
在JDK8之前，每个ThreadLocal都创建一个ThreadLocalMap，用线程作为ThreadLocalMap的key，要存储的局部变量作为ThreadLocalMap的value，这样就实现了各个线程的局部变量的隔离作用。
而在JDK8之后，每个线程维护一个ThreadLocalMap，这个ThreadLocalMap的key是ThreadLocal实例本身，value才是真正要存储的变量副本。线程内部的Map由ThreadLocal维护，由ThreadLocal负责向map获取和设置线程的变量值。对于不同的线程，每次获取副本值时，别的线程并不能获取到当前线程的副本值，形成了副本的隔离，互不干扰。
好处：
- 减少ThreadLocalMap存储的Entry数量：因为之前的存储数量由Thread的数量决定，现在是由ThreadLocal的数量决定。在实际运用当中，往往ThreadLocal的数量要少于Thread的数量
- 当Thread销毁之后，对应的ThreadLocalMap也会随之销毁，能减少内存的使用（但是不能避免内存泄漏问题，解决内存泄漏问题应该在使用完后及时调用remove()对ThreadMap里的Entry对象进行移除，由于Entry继承了弱引用类，会在下次GC时被JVM回收）
2、常用方法
在ThreadLocal类中，有以下几个比较常用的方法：
- get：用于获取 ThreadLocal 在当前线程中保存的变量副本。
- set：用于设置当前线程中变量的副本。
- remove：用于删除当前线程中变量的副本。如果此线程局部变量随后被当前线程读取，则其值将通过调用其 initialValue 方法重新初始化，除非其值由中间线程中的当前线程设置。 这可能会导致当前线程中多次调用 initialValue 方法。
- initialValue：为 ThreadLocal 设置默认的 get 初始值，需要重写 initialValue 方法 。
3、案例
public class TestThreadLocal {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public static void main(String[] args) {
TestThreadLocal testThreadLocal = new TestThreadLocal();
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
testThreadLocal.setName(Thread.currentThread().getName() + "的信息");
System.out.println(Thread.currentThread().getName() + ": " + testThreadLocal.getName());
}
}).start();
}
}
}执行结果：
从结果可以看出多个线程在访问同一个变量的时候出现的异常，线程间的数据没有隔离。下面我们来看下采用 ThreadLocal 的方式来解决这个问题的例子。
public class TestThreadLocal {
private static ThreadLocal<String> t = new ThreadLocal<>();
private String name;
public String getName() {
return t.get();
}
public void setName(String name) {
t.set(name);
}
public static void main(String[] args) {
TestThreadLocal testThreadLocal = new TestThreadLocal();
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
testThreadLocal.setName(Thread.currentThread().getName() + "的信息");
System.out.println(Thread.currentThread().getName() + ": " + testThreadLocal.getName());
}
}).start();
}
}
}执行结果：
二、ThreadLocal原理分析
1、ThreadLocal的存储结构
在Thread类中维护着ThreadLocal.ThreadLocalMap类型的成员threadLocals，这个成员用来存储当前线程独占的变量副本。ThreadLocalMap是ThreadLocal的静态内部类，它维护者一个Entry数组，用来存储键值对。
public class Thread implements Runnable {
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
}
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;
}
}
}可以看到：Entry的key是ThreadLocal对象，value则是传递进行的对象，即变量副本，且Entry继承了WeakReference。
2、set(T value)方法源码
源码如下：
public void set(T value) {
//获取当前线程
Thread t = Thread.currentThread();
//获取threalLocals
ThreadLocalMap map = getMap(t);
//将ThreadLocal和值一起存入当前线程的ThreadLocalMap中
if (map != null)
//如果存在就调用map.set()，这里的this指的是调用此方法的ThreadLocal对象
map.set(this, value);
else
createMap(t, value);
}
//获取当前线程维护的ThreadLocalMap
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
//创建当前线程
void createMap(Thread t, T firstValue) {
//这里的this是调用此方法的threadLocal
t.threadLocals = new ThreadLocalMap(this, firstValue);
}在ThreadLocal的set方法中，首先获取当前线程，然后调用getMap(Thread t)获取当前线程中ThreaLocalMap类型的threadLocals字段。然后将ThreadLocal一块放入到当前线程的ThreadLocalMap中。如果获取到的Map不为空，则将参数设置到Map中，否则就创建Map，并设置初值。
3、get()方法
源码如下：
public T get() {
//获取当前线程
Thread t = Thread.currentThread();
//拿到threadLocals字段
ThreadLocalMap map = getMap(t);
//如果map存在
if (map != null) {
//获取对应的存储实体
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
//获取存储尸体对应的value值
T result = (T)e.value;
return result;
}
}
//执行当前代码的两种情况：1、map不存在，说明此线程没有ThreadLocalMap对象；2、map存在，但是没有与当前ThreadLocal关联的Entry
return setInitialValue();
}
private T setInitialValue() {
// 调用initialValue获取初始化的值
// 此方法可以被子类重写, 如果不重写默认返回null
T value = initialValue();
// 获取当前线程对象
Thread t = Thread.currentThread();
// 获取此线程对象中维护的ThreadLocalMap对象
ThreadLocalMap map = getMap(t);
// 判断map是否存在
if (map != null)
// 存在则调用map.set设置此实体entry
map.set(this, value);
else
// 1）当前线程Thread 不存在ThreadLocalMap对象
// 2）则调用createMap进行ThreadLocalMap对象的初始化
// 3）并将 t(当前线程)和value(t对应的值)作为第一个entry存放至ThreadLocalMap中
createMap(t, value);
// 返回设置的值value
return value;
}执行流程：先获取到当前线程，并根据当前线程获取一个Map。如果获取的map不为空，则在Map中以ThreadLocal的引用作为key在map中获取对应的Entry。如果entry不为空则返回e.value；如果e为空或者Map为空，则通过initialValue函数获取初始值value，然后用ThreadLocal的引用和value作为firstKey和firstValue创建一个新的Map。
4、remove()方法
源码如下：
public void remove() {
// 获取当前线程对象中维护的ThreadLocalMap对象
ThreadLocalMap m = getMap(Thread.currentThread());
// 如果此map存在
if (m != null)
// 存在则调用map.remove
// 以当前ThreadLocal为key删除对应的实体entry
m.remove(this);
}执行流程：首先获取当前线程，并根据当前线程获取一个Map。如果获取的map不为空，则移除当前ThreadLocal对象对应的Entry。
5、initialValue()方法
源码如下：
/**
* 返回当前线程对应的ThreadLocal的初始值
* 此方法的第一次调用发生在，当线程通过get方法访问此线程的ThreadLocal值时
* 除非线程先调用了set方法，在这种情况下，initialValue 才不会被这个线程调用。
* 通常情况下，每个线程最多调用一次这个方法。
*
* <p>这个方法仅仅简单的返回null {@code null};
* 如果想ThreadLocal线程局部变量有一个除null以外的初始值，
* 必须通过子类继承{@code ThreadLocal} 的方式去重写此方法
* 通常, 可以通过匿名内部类的方式实现
*
* @return 当前ThreadLocal的初始值
*/
protected T initialValue() {
return null;
}该方法作用是返回该线程局部变量的初始值。从上面的代码我们得知，在set方法还未调用而先调用了get方法时才执行，并且仅执行1次，这个方法缺省实现直接返回一个null。如果想要一个除null之外的初始值，可以重写此方法。（备注： 该方法是一个protected的方法，显然是为了让子类覆盖而设计的）
6、如何解决hash冲突问题
从前面可以看到ThreadLocalMap是类似于Map的数据结构，但是它并没有实现Map接口，那么它也就不支持Map接口中的next方法。因此可以推断出：ThreadLocalMap并不是通过拉链法来解决hash冲突问题的。实际上，ThreadLocalMap是使用线性探测的方式来解决hash冲突的，即：根据初始key的hashcode值来确定元素在table数组中的位置，如果这个位置已经被其他的key占据，那么就通过算法寻找下一个位置，直到找到能够存放的位置为止。
在前面查看set()方法源码的时候，当map为空时调用了cerateMap()方法，而该方法中调用了有参构造：ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue)
/*
* firstKey : 本ThreadLocal实例(this)
* firstValue ： 要保存的线程本地变量
*/
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
//初始化table
table = new ThreadLocal.ThreadLocalMap.Entry[INITIAL_CAPACITY];
//计算索引(重点代码）
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
//设置值
table[i] = new ThreadLocal.ThreadLocalMap.Entry(firstKey, firstValue);
size = 1;
//设置阈值
setThreshold(INITIAL_CAPACITY);
}构造函数首先创建一个长度为16的Entry数组，然后计算出firstKey对应的索引，然后存储到table中，并设置size和threshold。
重点看一下计算索引这一块：
private final int threadLocalHashCode = nextHashCode();
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
//AtomicInteger是一个提供原子操作的Integer类，通过线程安全的方式操作加减,适合高并发情况下的使用
private static AtomicInteger nextHashCode = new AtomicInteger();
//特殊的hash值
private static final int HASH_INCREMENT = 0x61c88647;这里定义了一个AtomicInteger类型，每次获取当前值并加上HASH_INCREMENT，HASH_INCREMENT = 0x61c88647,这个值跟斐波那契数列（黄金分割数）有关，其主要目的就是为了让哈希码能均匀的分布在2的n次方的数组里, 也就是Entry[] table中，这样做可以尽量避免hash冲突。
关于& (INITIAL_CAPACITY - 1)
计算hash的时候里面采用了hashCode & (size - 1)的算法，这相当于取模运算hashCode % size的一个更高效的实现。正是因为这种算法，我们要求size必须是2的整次幂，这也能保证在索引不越界的前提下，使得hash发生冲突的次数减小。
来看下ThreadLocalMap中的set方法：
private void set(ThreadLocal<?> key, Object value) {
ThreadLocal.ThreadLocalMap.Entry[] tab = table;
int len = tab.length;
//计算索引(重点代码，刚才分析过了）
int i = key.threadLocalHashCode & (len-1);
/**
* 使用线性探测法查找元素（重点代码）
*/
for (ThreadLocal.ThreadLocalMap.Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
//ThreadLocal 对应的 key 存在，直接覆盖之前的值
if (k == key) {
e.value = value;
return;
}
// key为 null，但是值不为 null，说明之前的 ThreadLocal 对象已经被回收了，
// 当前数组中的 Entry 是一个陈旧（stale）的元素
if (k == null) {
//用新元素替换陈旧的元素，这个方法进行了不少的垃圾清理动作，防止内存泄漏
replaceStaleEntry(key, value, i);
return;
}
}
//ThreadLocal对应的key不存在并且没有找到陈旧的元素，则在空元素的位置创建一个新的Entry。
tab[i] = new Entry(key, value);
int sz = ++size;
/**
* cleanSomeSlots用于清除那些e.get()==null的元素，
* 这种数据key关联的对象已经被回收，所以这个Entry(table[index])可以被置null。
* 如果没有清除任何entry,并且当前使用量达到了负载因子所定义(长度的2/3)，那么进行 * rehash（执行一次全表的扫描清理工作）
*/
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
/**
* 获取环形数组的下一个索引
*/
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}综上所述，代码执行流程如下：
- 首先根据key计算出索引 i，然后查找i位置上的Entry
- 若是Entry已经存在并且key等于传入的key，那么这时候直接给这个Entry赋新的value值
- 若是Entry存在，但是key为null，则调用replaceStaleEntry来更换这个key为空的Entry
- 不断循环检测，直到遇到为null的地方，这时候要是还没在循环过程中return，那么就在这个null的位置新建一个Entry，并且插入，同时size增加1
- 最后调用cleanSomeSlots，清理key为null的Entry，最后返回是否清理了Entry，接下来再判断sz 是否>= thresgold达到了rehash的条件，达到的话就会调用rehash函数执行一次全表的扫描清理
三、ThreadLocalMap的内存泄漏问题
在前面我们看到了，ThreadLocalMap的Entry继承了WeakReference，其中key是弱引用，而value是强引用。如果ThreadLocal对象没有外部强引用来引用它，那么ThreadLocal对象会在下次GC时候被回收。此时，如果Entry中的key已经被回收，但是value又是强引用，并不会被垃圾收集器回收。如果创建ThreadLocal的线程一直持续运行，那么value就会一直得不到回收，从而产生内存泄漏。
在Java中有四种引用类型，这里介绍一下强引用和弱引用：
- 强引用（“Strong” Reference），就是我们最常见的普通对象引用，只要还有强引用指向一个对象，就能表明对象还“活着”，垃圾回收器就不会回收这种对象。
- 弱引用（WeakReference），垃圾回收器一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。
1、如果key使用强引用
如下图：
假设在业务代码中使用完ThreadLocal ，threadLocal Ref被回收了。但是因为threadLocalMap的Entry强引用了threadLocal，造成threadLocal无法被回收。
在没有手动删除这个Entry以及CurrentThread依然运行的前提下，始终有强引用链 threadRef->currentThread->threadLocalMap->entry，Entry就不会被回收（Entry中包括了ThreadLocal实例和value），导致Entry内存泄漏。
也就是说，ThreadLocalMap中的key使用了强引用， 是无法完全避免内存泄漏的。
2、如果key使用了弱引用
如下图：
假设在业务代码中使用完ThreadLocal ，threadLocal Ref被回收了。由于ThreadLocalMap只持有ThreadLocal的弱引用，没有任何强引用指向threadlocal实例, 所以threadlocal就可以顺利被gc回收，此时Entry中的key=null。但是在没有手动删除这个Entry以及CurrentThread依然运行的前提下，也存在有强引用链 threadRef->currentThread->threadLocalMap->entry -> value ，value不会被回收， 而这块value永远不会被访问到了，导致value内存泄漏。也就是说，ThreadLocalMap中的key使用了弱引用， 也有可能内存泄漏。
既然弱引用和强引用都无法阻止内存泄漏的问题，那么为啥还要选择弱引用？
根据刚才的分析, 我们知道了： 无论ThreadLocalMap中的key使用哪种类型引用都无法完全避免内存泄漏，跟使用弱引用没有关系。
要避免内存泄漏有两种方式：
- 使用完ThreadLocal，调用其remove方法删除对应的Entry
- 使用完ThreadLocal，当前Thread也随之运行结束
相对第一种方式，第二种方式显然更不好控制，特别是使用线程池的时候，线程结束是不会销毁的。也就是说，只要记得在使用完ThreadLocal及时的调用remove，无论key是强引用还是弱引用都不会有问题。那么为什么key要用弱引用呢？
事实上，在ThreadLocalMap中的set/getEntry方法中，会对key为null（也即是ThreadLocal为null）进行判断，如果为null的话，那么是会对value置为null的。这就意味着使用完ThreadLocal，CurrentThread依然运行的前提下，就算忘记调用remove方法，弱引用比强引用可以多一层保障：弱引用的ThreadLocal会被回收，对应的value在下一次ThreadLocalMap调用set,get,remove中的任一方法的时候会被清除，从而避免内存泄漏。
解决办法：使用ThreadLocal的set方法，显式调用remove方法。
ThreadLocal<String> threadLocal = new ThreadLocal();
try {
threadLocal.set("xxx");
// ...
} finally {
threadLocal.remove();
}四、总结
- threadLocal操作的是每个线程自己的ThreadLocalMap，因此不会有线程的竞争。key是当前的threadlocal对象，value是当前线程放在这个threadlocal里面的值。
- ThreadLocalMap是基于开放定址法（线性探测再散列）实现的hash表，这里没有采用HashMap的数组加链表的实现方式是因为这里的场景决定了hash表中不会有太多的值，通过采用独特的斐波那契散列求hash值，可以极大的降低hash冲突概率，访问数据速度也比HashMap快。
- ThreadLocalMap的实现类似WeakHashMap实现，都通过WeakReference封装了key值，防止内存泄漏；
- ThreadLocalMap实现的挺复杂的，主要是为了避免内存泄露，加了好多处理过期数据的操作，这就在线程中添加了多余的操作。所以如果确定ThreadLocal没有用的话，可以调用ThreadLocal的remove()方法，这样就避免了在ThreadLocalMap中查找过期数据并处理的操作。
到此这篇关于Java多线程中ThreadLocal解读的文章就介绍到这了,更多相关ThreadLocal解读内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！