ThreadLocal的原理解析以及应用场景分析
ThreadLocal的定义
JDK对ThreadLocal的定义如下：TheadLocal提供了线程内部的局部变量：每个线程都有自己的独立的副本；ThreadLocal实例通常是类中的private static字段，该类一般与线程状态相关（或线程上下文）中使用。只要线程处于活动状态且ThreadLocal实例时可访问的状态下，每个线程都持有对其线程局部变量的副本的隐式引用，在线程消亡后，ThreadLocal实例的所有副本都将进行垃圾回收。
ThreadLocal的应用场景
ThreadLocal 不是用来解决多线程访问共享变量的问题，所以不能替换掉同步方法。一般而言，ThreadLocal的最佳应用场景是：按照线程多实例（每个线程对应一个实例）的对象的访问。例如：在事务中，connection绑定到当前线程来保证这个线程中的数据库操作用的是同一个connection。
ThreadLocal的demo
public class ThreadLocalTest {
public static void main(String[] args) {
ThreadLocal<String> threadLocal = new ThreadLocal<>();
threadLocal.set("张三");
new Thread(()->{
threadLocal.set("李四");
System.out.println("*******"+Thread.currentThread().getName()+"获取到的数据"+threadLocal.get());
},"线程1").start();
new Thread(()->{
threadLocal.set("王二");
System.out.println("*******"+Thread.currentThread().getName()+"获取到的数据"+threadLocal.get());
},"线程2").start();
new Thread(()->{
System.out.println("*******"+Thread.currentThread().getName()+"获取到的数据"+threadLocal.get());
},"线程3").start();
System.out.println("线程=" + Thread.currentThread().getName() + "获取到的数据=" + threadLocal.get());
}
}运行结果：
从运行结果，我们可以看出线程1和线程2在ThreadLocal中设置的值相互独立，每个线程只能取到自己设置的那个值。
TheadLocal的源码解析
ThreadLocal存储数据的逻辑是：每个线程持有个一个自己的ThreadLocalMap,key为ThreadLocal对象的实例，value 是我们需要设值的值。
ThreadLocal的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);
}getMap的方法如下：
public class Thread implements Runnable {
//每个线程自己的ThreadLocalMap对象通过ThreadLocal保存下来
ThreadLocal.ThreadLocalMap threadLocals = null;
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
}首先获取当前线程的ThreadLocalMap对象，该对象是通过实例变量threadLocals保存的。
1.如果获取得到ThreadLocalMap，则直接设值，key为当前ThreadLocal类的this实例，如果获取不到调用createMap方法创建ThreadLoalMap实例，并将值设置到这个ThreadLocalMap中，后面我们会重点介绍ThreadLocal的createMap方法。接下来我们就来看看ThreadLocal的get方法。
ThreadLocal的get方法
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}1.首先获取当前线程的ThreadLocalMap对象，没有的话，设置初始值（null）并返回
1.如果可以获取到ThreadLocalMap 则获取其Entry对象，如果不为空则直接返回value 说完了ThreadLocal的set方法和get方法。我就来具体看看前面提到的ThreadLocalMap。
ThreadLocalMap的结构
public class ThreadLocal<T> {
private static AtomicInteger nextHashCode =new AtomicInteger();
//初始的Hash值是0x61c88647
private static final int HASH_INCREMENT = 0x61c88647;
//每次调用就原子性的将hash值增加HASH_INCREMENT
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
static class ThreadLocalMap {
//Entry继承WeakReference
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 void setThreshold(int len) {
threshold = len * 2 / 3;
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
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);
}
}
}如上，ThreadLocalMap作为ThreadLocal的静态内部类，由ThreadLocal所持有，每个线程内部通过ThreadLocal来获取自己的ThreadLocalMap实例。结构如下图所示：
从上述代码我们可以看出ThreadLocalMap实际上没有继承Map接口，其只是一个可扩展的散列表结构。初始大小是16。大于等于数据的1/2 的时候会扩容为2倍的原数组的rehash。初始的hashCode值为0x61c88647。每创建一个Entry对象，hash值就会增加一个固定大小0x61c88647。同时，我们注意到，ThreadLocalMap的Entry是继承WeakReference,和HashMap很大的区别是，Entry中没有next字段，所以不存在链表的情况。那么没有链表结构，发生hash冲突了怎么办呢？要解答这个问题就需要看看ThreadLocalMap的set方法了。
ThreadLocalMap的set方法
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
//1.根据ThreadLocal对象的hash值，定位到table中的位置i
int i = key.threadLocalHashCode & (len-1);
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
//判断Entry.key等于当前的ThreadLoacl对象key，则覆盖旧值，退出。
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();
}前面我们提到了每个ThreadLocal对象都有一个hash值threadLocalHashCode，每创建一个Entry对象，hash值就增加一个固定的大小0x61c88647。1.根据ThreadLocal对象的hash值，定位到table中的位置i 2.如果table[i]的Entry不为null 2.1. 判断Entry.key等于当前的ThreadLoacl对象key，则覆盖旧值，退出。2.2. 如果Entry.key为null,将执行删除两个null 槽之间的所有过期的stale的entry， 并把当前的位置i上初始化一个Entry对象，退出 2.3 继续查找下一个位置i++ 3.如果找到了一个位置k,table[k]为null,初始化一个Entry对象。
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);
}
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;
}
1.
根据当前ThreadLocal的hashCode mod table.length，计算直接索引的位置i，如果e不为null并且key相同则返回e。
2.
如果e为null，返回null
3.
如果e不为空且key不相同，则查找下一个位置，继续查找比较，直到e为null退出
4.
在查找的过程中如果发现e不为空，且e的k为空的话，删除当前槽和下一个null槽之间的所有过期entry对象。总结ThreadLocalMap：
5.
ThreadLocalMap的散列表采用开放地址，线性探测的方法处理hash冲突，在hash冲突较大的时候效率低下，因为ThreadLoaclMap是一个Thread的一个属性，所以即使在自己的代码中控制设置的元素个数，但还是不能控制其他代码的行为。
6.
ThreadLocalMap的set、get、remove操作中都带有删除过期元素的操作，类似缓存的lazy淘汰。
ThreadLocal的内存泄露
ThreadLocal可能导致内存泄露，为什么？先看看Entry的实现：
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}通过之前的分析我们已经知道，当使用ThreadLocal保存一个value时，会在ThreadLoalMap中的数组插入一个Entry对象，按理来说key-value都可以以强引用保存在Entry对象中，但在ThreadLocalMap的实现中，key被保存到了WeakReference对象中。这就导致了一个问题，当一个ThreadLocal没有强引用时，threadLocal会被GC清理，会形成一个key为null的Map的引用。废弃threadLocal占用的内存会在三种情况下清理：
1.thread结束，那么与之相关的threadlocal value会被清理2.GC后，thread.threadLocal(map) 的threadhold超过最大值时，会清理3.GC后，thread.threadlocals(maps)添加新的Entry时，hash算法没有命中既有Entry时，会清理
那么何时会“内存泄漏”？当Thread长时间不结束，存在大量废弃的ThreadLocal，而又不再添加新的ThreadLocal时。
如何避免内存泄露呢
在调用ThreadLocal的get()、set()可能会清除ThreadLocalMap中key为null的Entry对象，这样对应的value就没有GC Roots可达了，下次GC的时候就可以被回收，当然如果调用remove方法，肯定会删除对应的Entry对象。
ThreadLocal<String> threadLocal = new ThreadLocal<>();
try {
threadLocal.set("张三");
} catch (Exception e) {
threadLocal.remove();
}应用实例
public class DateUtil {
private final static Map<String, ThreadLocal<SimpleDateFormat>> sdfMap = new HashMap<>();
public final static String Y2M2D2HMS_ = "yyyy/MM/dd HH:mm:ss";
private static SimpleDateFormat getsdf(final String pattern) {
ThreadLocal<SimpleDateFormat> sdfThread = sdfMap.get(pattern);
if (sdfThread == null) {
//双重检验,防止sdfMap被多次put进去值,和双重锁单例原因是一样的
synchronized (DateUtil.class) {
// 只有Map中还没有这个pattern的sdf才会生成新的sdf并放入map
// 这里是关键,使用ThreadLocal<SimpleDateFormat>替代原来直接new SimpleDateFormat
sdfThread = sdfMap.get(pattern);
if (sdfThread == null) {
sdfThread = ThreadLocal.withInitial(() -> new SimpleDateFormat(pattern));
sdfMap.put(pattern, sdfThread);
}
}
}
return sdfThread.get();
}
/**
* @param date 需要格式化的date
* @param pattern 给定转换格式
* @return java.lang.String 时间串
* @description 按照指定pattern的方式格式化时间
*/
public static String formatDate(Date date, String pattern) {
return DateUtil.getsdf(pattern).format(date);
}
}SimpleDateFormat是线程不安全的类，同时创建一个SimpleDateFormat类又比较耗时，所以，我们可以将SimpleDateFormat类放在ThreadLocal包装起来。然后，根据日期格式化的类型作为key放入一个静态的map中。
总结
本文简单的介绍了ThreadLocal的应用场景，其主要用在需要每个线程独占的元素上，例如SimpleDateFormat。然后，就是介绍了ThreadLocal的实现原理，详细介绍了set()和get()方法，介绍了ThreadeLocalMap的数据结构，最后就是说到了ThreadLocal的内存泄露以及避免的方式。
参考
https://segmentfault.com/a/1190000014738647 什么是ThreadLocal ？
腾讯云开发者
