ThreadLocal介绍
概念:
- 官方描述:该类提供了线程局部(thread-local)变量。这些变量不同于它们的普通对应物,因为访问某个变量(通过其get或set方法)的每个线程都有自己的局部变量,它独立于变量的初始化副本。ThreadLocal实例通常是类中的private static字段,它们希望将状态与某一个线程(例如,用户ID或事务ID)相关联。
- 自己简单理解:ThreadLocal是每个线程自己维护的一个存储对象的数据结构,线程间互不影响实现线程封闭。一般我们通过ThreadLocal对象的get/set方法存取对象。
原理:
先看一下内部结构,以JDK1.8为例
过程:
- 每个 Thread 线程内部都有一个 ThreadLocalMap
ThreadLocalMap 中存储着以 ThreadLocal 对象为 key ,线程变量为 value
Thread 内部的 Map 是由 ThreadLocal 维护的,由 ThreadLocal 负责向 Map 设置和获取线程的变量值
对于不同的线程,每次获取副本值时,别的线程并不能获取到线程的副本值,这样就会形成副本的隔离,互不干扰
注: 每个线程都要有自己的一个 map,但是这个类就是一个普通的 Java 类,并没有实现 Map 接口,但是具有类似 Map 类似的功能
ThreadLocal.ThreadLocalMap threadLocals = null;
这种结构的好处:
- 每个 Map 存储的 Entry 数量就会变少,因为之前的存储数量由 Thread 的数量决定,现在是由 ThreadMap的数量决定,在实际开发中,ThreadLocal 的数量要更少于 Thread 的数量。
- 当 Thread 销毁之后,对应的 ThreadLocalMap 也会随之销毁,能减少内存的使用
源码分析
首先看下ThreadLocalMap中有哪些成员:
private static final int INITIAL_CAPACITY = 16;
private ThreadLocal.ThreadLocalMap.Entry[] table;
private int size;
private int threshold;
如果你看过 HashMap 的源码,肯定会觉得这几个特别熟悉,其中:
- INITIAL_CAPACITY:初始容量,必须是 2 的整次幂
- table:存放数据的table
- size:数组中 entries 的个数,用于判断 table 当前使用量是否超过阈值
- threshold:进行扩容的阈值,表使用量大于它的时候会进行扩容
ThreadLocals
Thread 类中有个类型为 ThreadLocal.ThreadLocalMap 类型的变量 ThreadLocals ,这个就是用来保存每个线程的私有数据。
ThreadLocal.ThreadLocalMap threadLocals = null;
ThreadLocalMap
ThreadLocalMap是ThreadLocal的内部类,每个数据用Entry保存,其中的Entry用一个键值对存储,键为ThreadLocal的引用。
我们可以看到 Entry 继承于WeakReference,这是因为如果是强引用,即使把 ThreadLocal 设置为 null,GC 也不会回收,因为 ThreadLocalMap 对它有强引用。
在没有手动删除这个Entry以及CurrentThread依然运行的前提下,始终有强引用链 threadRef -> currentThread -> threadLocalMap -> entry,Entry就不会被回收(Entry中包括了ThreadLocal实例和value),导致Entry内存泄漏。
那是不是就是说如果使用了弱引用,就不会造成内存泄露 呢,这也是不正确的。
因为如果我们没有手动删除 Entry 的情况下,此时 Entry 中的 key == null,这个时候没有任何强引用指向 threaLocal 实例,所以 threadLocal 就可以顺利被 gc 回收,但是 value 不会被回收,而这块的 value 永远不会被访问到,因此会导致内存泄露
下面我们看一下ThreadLocalMap的几个核心方法:
set 方法
首先我们看下源码:
public void set(T value) {
// 获取当前线程对象
Thread t = Thread.currentThread();
// 获取此线程对象中维护的ThreadLocalMap对象
ThreadLocalMap map = getMap(t);
// 判断map是否存在
if (map != null)
// 存在则调用map.set设置此实体entry
map.set(this, value);
else
// 如果当前线程不存在ThreadLocalMap对象则调用createMap进行ThreadLocalMap对象的初始化
// 并将 t(当前线程)和value(t对应的值)作为第一个entry存放至ThreadLocalMap中
createMap(t, value);
}
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
void createMap(Thread t, T firstValue) {
//这里的this是调用此方法的threadLocal
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
执行流程:
- 首先获取当前线程,并根据当前线程获取一个 map
- 如果获取的 map 不为空,则将参数设置到 map 中(当前 ThreadLocal 的引用作为 key )
- 如果 Map 为空,则给该线程创建 map ,并设置初始值
get 方法
源码如下:
public T get() {
// 获取当前线程对象
Thread t = Thread.currentThread();
// 获取此线程对象中维护的ThreadLocalMap对象
ThreadLocalMap map = getMap(t);
// 如果此map存在
if (map != null) {
// 以当前的ThreadLocal 为 key,调用getEntry获取对应的存储实体e
ThreadLocalMap.Entry e = map.getEntry(this);
// 对e进行判空
if (e != null) {
@SuppressWarnings("unchecked")
// 获取存储实体 e 对应的 value值
// 即为我们想要的当前线程对应此ThreadLocal的值
T result = (T)e.value;
return result;
}
}
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
// 如果当前线程不存在ThreadLocalMap对象则调用createMap进行ThreadLocalMap对象的初始化
// 并将 t(当前线程)和value(t对应的值)作为第一个entry存放至ThreadLocalMap中
createMap(t, value);
// 返回设置的值value
return value;
}
执行流程:
- 首先获取当前线程,根据当前线程获取一个 map
- 如果获取的 map 不为空,则在 map 中以 ThreadLocal 的引用作为 key 来在 map 中获取对应的 Entry entry ,否则跳转到第四步
- 如果 Entry entry 不为空 ,则返回 entry.value ,否则跳转到第四步
- map 为空或者 entry 为空,则通过 initialValue 函数获取初始值 value ,然后用 ThreadLocal的引用和 value 作为 firstKey 和 firstValue 创建一个新的 map
remove 方法
源码如下:
public void remove() {
// 获取当前线程对象中维护的ThreadLocalMap对象
ThreadLocalMap m = getMap(Thread.currentThread());
// 如果此map存在
if (m != null)
// 存在则调用map.remove
m.remove(this);
}
// 以当前ThreadLocal为key删除对应的实体entry
private void remove(ThreadLocal<?> key) {
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)]) {
if (e.get() == key) {
e.clear();
expungeStaleEntry(i);
return;
}
}
}
执行流程:
- 首先获取当前线程,并根据当前线程获取一个 map
- 如果获得的map 不为空,则移除当前 ThreadLocal 对象对应的 entry
initialValue 方法
源码如下:
protected T initialValue() {
return null;
}
在源码中我们可以看到这个方法仅仅简单的返回了 null ,这个方法是在线程第一次通过 get () 方法访问该线程的 ThreadLocal 时调用的,只有在线程先调用了 set () 方法才不会调用 initialValue () 方法,通常情况下,这个方法最多被调用一次。
如果们想要 ThreadLocal 线程局部变量有一个除 null 以外的初始值,那么就必须通过子类继承 ThreadLocal 来重写此方法,可以通过匿名内部类实现。
ThreadLocal的内存泄漏问题
前面在ThreadLocalMap中也提到了,这里再强调一遍,在ThreadLocalMap中,只有key是弱引用,value仍然是一个强引用。当某一条线程中的ThreadLocal使用完毕,没有强引用指向它的时候,这个key指向的对象就会被垃圾收集器回收,从而这个key就变成了null;然而,此时value和value指向的对象之间仍然是强引用关系,只要这种关系不解除,value指向的对象永远不会被垃圾收集器回收,从而导致内存泄漏!
不过不用担心,ThreadLocal提供了这个问题的解决方案。
每次操作set、get、remove操作时,ThreadLocal都会将key为null的Entry删除,从而避免内存泄漏。
那么问题又来了,如果一个线程运行周期较长,而且将一个大对象放入LocalThreadMap后便不再调用set、get、remove方法,此时该仍然可能会导致内存泄漏。
这个问题确实存在,没办法通过ThreadLocal解决,而是需要程序员在完成ThreadLocal的使用后要养成手动调用remove的习惯,从而避免内存泄漏。
ThreadLocal的使用场景
- 场景1:
ThreadLocal 用作保存每个线程独享的对象,为每个线程都创建一个副本,这样每个线程都可以修改自己所拥有的副本, 而不会影响其他线程的副本,确保了线程安全。
- 场景2:
ThreadLocal 用作每个线程内需要独立保存信息,以便供其他方法更方便地获取该信息的场景。每个线程获取到的信息可能都是不一样的,前面执行的方法保存了信息后,后续方法可以通过ThreadLocal 直接获取到,避免了传参,类似于全局变量的概念。
场景1典型实例
这种场景通常用于保存线程不安全的工具类,典型的需要使用的类就是 SimpleDateFormat。
在这种情况下,每个Thread内都有自己的实例副本,且该副本只能由当前Thread访问到并使用,相当于每个线程内部的本地变量,这也是ThreadLocal命名的含义。因为每个线程独享副本,而不是公用的,所以不存在多线程间共享的问题。
比如有10个线程都要用到SimpleDateFormat
public class ThreadLocalDemo01 {
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 10; i++) {
int finalI = i;
new Thread(() -> {
String data = new ThreadLocalDemo01().date(finalI);
System.out.println(data);
}).start();
Thread.sleep(100);
}
}
private String date(int seconds){
Date date = new Date(1000 * seconds);
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss");
return simpleDateFormat.format(date);
}
}
我们给每个线程都创建了SimpleDateFormat对象,他们之间互不影响,代码是可以正常执行的。输出结果:
00:00
00:01
00:02
00:03
00:04
00:05
00:06
00:07
00:08
00:09
我们用图来看一下当前的这种状态:
如果有1000个线程都用到SimpleDateFormat对象呢?
我们一般不会直接去创建这么多线程,而是通过线程池,比如:
public class ThreadLocalDemo011 {
public static ExecutorService threadPool = Executors.newFixedThreadPool(16);
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 1000; i++) {
int finalI = i;
threadPool.submit(() -> {
String data = new ThreadLocalDemo011().date(finalI);
System.out.println(data);
});
}
threadPool.shutdown();
}
private String date(int seconds){
Date date = new Date(1000 * seconds);
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss");
return simpleDateFormat.format(date);
}
}
可以看出,我们用了一个16线程的线程池,并且给这个线程池提交了1000次任务。每个任务中它做的事情和之前是一样的,还是去执行date方法,并且在这个方法中创建一个
simpleDateFormat 对象。结果:
00:00
00:07
00:04
00:02
...
16:29
16:28
16:27
16:26
16:39
我们刚才所做的就是每个任务都创建了一个 simpleDateFormat 对象,也就是说,1000 个任务对应 1000 个 simpleDateFormat 对象,但是如果任务数巨多怎么办?
这么多对象的创建是有开销的,并且在使用完之后的销毁同样是有开销的,同时存在在内存中也是一种内存的浪费。
我们可能会想到,要不所有的线程共用一个 simpleDateFormat 对象?但是simpleDateFormat 又不是线程安全的,我们必须做同步,比如使用synchronized加锁。到这里也许就是我们最终的一个解决方法。但是使用synchronized加锁会陷入一种排队的状态,多个线程不能同时工作,这样一来,整体的效率就被大大降低了。有没有更好的解决方案呢?
使用ThreadLocal
对这种场景,ThreadLocal再合适不过了,ThreadLocal给每个线程维护一个自己的simpleDateFormat对象,这个对象在线程之间是独立的,互相没有关系的。这也就避免了线程安全问题。与此同时,simpleDateFormat对象还不会创造过多,线程池一共只有 16 个线程,所以需要16个对象即可
public class ThreadLocalDemo04 {
public static ExecutorService threadPool = Executors.newFixedThreadPool(16);
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 1000; i++) {
int finalI = i;
threadPool.submit(() -> {
String data = new ThreadLocalDemo04().date(finalI);
System.out.println(data);
});
}
threadPool.shutdown();
}
private String date(int seconds){
Date date = new Date(1000 * seconds);
SimpleDateFormat dateFormat = ThreadSafeFormater.dateFormatThreadLocal.get();
return dateFormat.format(date);
}
}
class ThreadSafeFormater{
public static ThreadLocal<SimpleDateFormat> dateFormatThreadLocal = ThreadLocal.withInitial(() -> new SimpleDateFormat("mm:ss"));
}
复制代码
我们用图来看一下当前的这种状态:
场景二典型实例
每个线程内需要保存类似于全局变量的信息(例如在拦截器中获取的用户信息),可以让不同方法直接使用,避免参数传递的麻烦却不想被多线程共享(因为不同线程获取到的用户信息不一样)。
例如,用 ThreadLocal 保存一些业务内容(用户权限信息、从用户系统获取到的用户名、用户ID 等),这些信息在同一个线程内相同,但是不同的线程使用的业务内容是不相同的。
在线程生命周期内,都通过这个静态 ThreadLocal 实例的 get() 方法取得自己 set 过的那个对象,避免了将这个对象(如 user 对象)作为参数传递的麻烦。
比如说我们是一个用户系统,那么当一个请求进来的时候,一个线程会负责执行这个请求,然后这个请求就会依次调用service-1()、service-2()、service-3()、service-4(),这4个方法可能是分布在不同的类中的。
我们用图画的形式举一个实例:
代码:
package com.damokelisijian886.threadlocal;
public class ThreadLocalDemo05 {
public static void main(String[] args) {
User user = new User("tom");
new Service1().service1(user);
}
}
class Service1 {
public void service1(User user){
//给ThreadLocal赋值,后续的服务直接通过ThreadLocal获取就行了。
UserContextHolder.holder.set(user);
new Service2().service2();
}
}
class Service2 {
public void service2(){
User user = UserContextHolder.holder.get();
System.out.println("service2拿到的用户:"+user.name);
new Service3().service3();
}
}
class Service3 {
public void service3(){
User user = UserContextHolder.holder.get();
System.out.println("service3拿到的用户:"+user.name);
//在整个流程执行完毕后,一定要执行remove
UserContextHolder.holder.remove();
}
}
class UserContextHolder {
//创建ThreadLocal保存User对象
public static ThreadLocal<User> holder = new ThreadLocal<>();
}
class User {
String name;
public User(String name){
this.name = name;
}
}
执行的结果:
service2拿到的用户:tom
service3拿到的用户:tom