Java ThreadLocal原理解析以及应用场景分析案例详解

Java ThreadLocal原理解析以及应用场景分析案例详解

目录ThreadLocal的定义ThreadLocal的应用场景ThreadLocal的demoTheadLocal的源码解析ThreadLocal的set方法ThreadLocal的cOdqrkMJZAget方法ThreadLocalMap的结构ThreadLocalMap的set方法ThreadLocalMap的getEntry方法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 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保存的。

2. 如果获取得到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）并返回

2. 如果可以获取到ThreadLocalMap 则获取其Entry对象，如果不为空则直接返回value

说完了ThreadLocal的set方法和get方法。我就来具体看看前面提到的ThreadLocalMap。

ThreadLocalMap的结构

public class ThreadLocal {

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> {

/** 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所持有，cOdqrkMJZA每个线程内部通过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;

}

根据当前ThreadLocal的hashCode mod table.length，计算直接索引的位置i，如果e不为null并且key相同则返回e。

如果e为null，返回null

如果e不为空且key不相同，则查找下一个位置，继续查找比较，直到e为null退出

在查找的过程中如果发现e不为空，且e的k为空的话，删除当前槽和下一个null槽之间的所有过期entry对象。

总结ThreadLocalMap：

ThreadLocalMap的散列表采用开放地址，线性探测的方法处理hash冲突，在hash冲突较大的时候效率低下，因为ThreadLoaclMap是一个Thread的一个属性，所以即使在自己的代码中控制设置的元素个数，但还是不能控制其他代码的行为。

ThreadLocalMap的set、get、remove操作中都带有删除过期元素的操作，类似缓存的lazy淘汰。

ThreadLocal的内存泄露

ThreadLocal可能导致内存泄露，为什么？先看看Entry的实现：

static class Entry extends WeakReference> {

/** 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对象（弱引用）中，即ThreadLocalMap弱引用ThreadLocal。

Key的引用链是

ThreadLocalRef---->ThreadLocal，

这就导致了一个问题，当一个ThreadLocal没有强引用时，threadLocal会被GC清理，会形成一个key为null的Map的引用。

但是value是强引用的，只有当当前线程结束了value的强引用才会结束，但线程迟迟未结束时，就会出现

ThreadRef---->Thread---->ThreadLocalMap—>Entry—>value这条强引用链条。

废弃threadLocal占用的内存会在三种情况下清理：

thread结束，那么与之相关的threadlocal value会被清理

GC后，thread.threadLocal(map) 的threadhold超过最大值时，会清理

GC后，thread.threadlocals(maps)添加新的Entry时，hash算法没有命中既有Entry时，会清理

那么何时会“内存泄漏”？当Thread长时间不结束，存在大量废弃的ThreadLocal，而又不再添加新的ThreadLocal时。

如何避免内存泄露呢

在调用ThreadLocal的get()、set()可能会清除ThreadLocalMap中key为null的Entry对象，这样对应的value就没有GC Roots可达了，下次GC的时候就可以被回收，当然如果调用remove方法，肯定会删除对应的Entry对象。

ThreadLocal threadLocal = new ThreadLocal<>();

try {

threadLocal.set("张三");

} catch (Exception e) {

threadLocal.remove();

}

应用实例

public class DateUtil {

private final static Map> sdfMap = new HashMap<>();

public final static String Y2M2D2HMS_ = "yyyy/MM/dd HH:mm:ss";

private static SimpleDateFormat getsdf(final String pattern) {

ThreadLocal sdfThread = sdfMap.get(pattern);

if (sdfThread == null) {

//双重检验,防止sdfMap被多次put进去值,和双重锁单例原因是一样的

synchronized (DateUtil.class) {

// 只有Map中还没有这个pattern的sdf才会生成新的sdf并放入map

// 这里是关键,使用ThreadLocal替代原来直接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中。

实际应用二

private static ThreadLocal DECIMAL_FORMAT_THREAD_LOCAL = ThreadLocal.withInitial(() -> new DecimalFormat(DECIMAL_FORMAT));

/**

* 获取金额格式化的类

* @return

*/

public static DecimalFormat getDecimalFormat() {

return DECIMAL_FORMAT_THREAD_LOCAL.get();

}

我们可以将金额格式化的类DecimalFormat保存到ThreadLocal中。

总结

本文简单的介绍了ThreadLocal的应用场景，其主要用在需要每个线程独占的元素上，例如SimpleDateFormat。然后，就是介绍了ThreadLocal的实现原理，详细介绍了set()和get()方法，介绍了ThreadeLocalMap的数据结构，最后就是说到了ThreadLocal的内存泄露以及避免的方式。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。