ThreadLocal 分析分为四篇
第一篇主要分析ThreadLocal使用原理
后三篇重点分析线程hash表结构的容器(前，中，后)
ThreadLocal的简介
在每个线程内存都存在一个hash表结构的容器，我们的应用程序可以通过ThreadLocal对象管理当前线程容器中的数据。
当我们把一个值添加到线程容器中，由于线程对象间接引用，其生命周期和线程一致，在线程生命周期内gc无法回收，也就是说这个变量变成一个线程局部变量
ThreadLocal类结构图
image
源码中定义
public class Thread implements Runnable {
/** 线程内管理的Hash结构容器 **/
ThreadLocal.ThreadLocalMap threadLocals = null;
public class ThreadLocal<T> {
/** 获取当前线程内Hash容器 **/
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
ThreadLocal 存储结构
我们现在定义两个 ThreadLocal 实例如下
static ThreadLocal<User> threadLocal_1 = new ThreadLocal<>();
static ThreadLocal<Client> threadLocal_2 = new ThreadLocal<>();
我们分别在三个线程中使用 ThreadLocal
// thread-1中
threadLocal_1.set(user_1);
threadLocal_2.set(client_1);
// thread-2中
threadLocal_1.set(user_2);
threadLocal_2.set(client_2);
// thread-3中
threadLocal_2 .set(client_3);
那么线程中的存储结构如下图
image
程序中每一个ThreadLocal都对象每个线程Hash容器中一个key,而设置到其中的值，就是容器对应value.
构建ThreadLocal
方式一
使用构建方法，并为ThreadLocal设置初始值
private static ThreadLocal<Test> threadLocal = new ThreadLocal<Test>() {
protected Test initialValue() {
return value;
}
};
方式二
使用静态方法返回，并为ThreadLocal设置初始值
private static ThreadLocal<Test> threadLocal2 = ThreadLocal.withInitial(()->new Test());
ThreadLocal 常用操作
get()
获取当前线程容器中当前TheadLocal对象（key）对应值(value)
/**
* 获取当前线程容器中以当前TheadLocal对象为（key）对应值(value)
*/
public T get() {
/** 获取当前线程 **/
Thread t = Thread.currentThread();
/** 取出线程内部的 ThreadLocalMap容器 (key-value结构)**/
ThreadLocalMap map = getMap(t);
/** 如果ThreadLocalMap存在，获取TheadLocal对象（key）对应值(value) **/
if (map != null) {
/** 以ThreadLocal为key 在ThreadLocalMap查找ThreadLocalMap.Entry(值) **/
ThreadLocalMap.Entry e = map.getEntry(this);
/**如果ThreadLocalMap.Entry不为空，返回内部存放的对象值 **/
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T) e.value;
return result;
}
}
/** 如果ThreadLocalMap不存在，实例化ThreadLocalMap，
* 并设置TheadLocal对象（key）对应初始值，并返回 **/
return setInitialValue();
}
/**
* 例化ThreadLocalMap，
* 并设置TheadLocal对象（key）对应初始值，并返回
*/
private T setInitialValue() {
/** 模板方法，设置当前TheadLocal（key）初始值 **/
T value = initialValue();
Thread t = Thread.currentThread();
/** 取出线程内部的 ThreadLocalMap容器 (key-value结构)**/
ThreadLocalMap map = getMap(t);
/** 判断ThreadLocalMap是否已初始化 **/
if (map != null)
/** 将当前TheadLocal（key）对应值(value).设置到ThreadLocalMap 容器中 **/
map.set(this, value);
else
/** 创建一个ThreadLocalMap
* 将当前TheadLocal（key）对应值(value).设置到ThreadLocalMap 容器中**/
createMap(t, value);
return value;
}
set()
设置当前线程容器中当前TheadLocal对象（key）对应(value)
/**
* 设置当前线程容器中当前TheadLocal对象（key）对应(value)
*/
public void set(T value) {
/** 获取当前线程 **/
Thread t = Thread.currentThread();
/** 取出线程内部的 ThreadLocalMap容器 (key-value结构)**/
ThreadLocalMap map = getMap(t);
if (map != null)
/** 将当前TheadLocal为（key），对应value.设置到ThreadLocalMap 容器中 **/
map.set(this, value);
else
/** 创建一个ThreadLocalMap
* 将当前TheadLocal（key）对应值(value).设置到ThreadLocalMap 容器中**/
createMap(t, value);
}
remove()
删除当前线程容器中当前TheadLocal对象（key）对应值(value)
/**
* 删除当前线程容器中当前TheadLocal对象（key）对应值(value)
*/
public void remove() {
/** 取出线程内部的 ThreadLocalMap容器 (key-value结构)**/
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
/** 从线程容器中删除 当前TheadLocal（key）对应值值(value) **/
m.remove(this);
}
TheadLocal 线程安全的争论
本质上来说TheadLocal仅仅只是对线程容器数据管理。并不能解决共享对象的多线程访问问题。其内部核心代码并没有对设置其中的数据做拷贝或者克隆。如果我们将一个引用类型的变量放置多个线程容器中并发操作一样会存在线程安全的问题。
package threadLocal;
import java.util.stream.IntStream;
/**
* ThreadLocal 内部并没有对添加值做克隆而是引用
* 因而无法解决共享对象的多线程访问问题
*/
public class ThreadLocalTest {
private static Test value = new Test();
private static ThreadLocal<Test> threadLocal = new ThreadLocal<Test>() {
protected Test initialValue() {
return value;
}
};
public static class ThreadLocalThread implements Runnable {
@Override
public void run() {
IntStream.range(0, 200).forEach(i -> {
Test vaue = (Test) threadLocal.get();
vaue.value++;
threadLocal.set(vaue);
});
System.out.println(threadLocal.get());
}
}
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(new ThreadLocalThread());
Thread thread2 = new Thread(new ThreadLocalThread());
thread.start();
thread2.start();
thread.join();
thread2.join();
System.out.println(value);
}
static class Test {
int value = 0;
@Override
public String toString() {
return "Test{value=" + value + "}";
}
}
}
//结果
Test{value=345}
Test{value=394}
Test{value=394}
虽然无法解决共享对象的多线程访问问题，但却提出了解决此类问题的一种新思路
针对存在线程安全对象，我们可以为每一个线程手动创建一个来保证线程安全，如SimpleDateFormat.parse方法会有线程安全的问题，我们可以尝试使用threadLocal包装SimpleDateFormat，将该实例不被多线程共享即可。
public class ThreadLocalDemo {
private static ThreadLocal<SimpleDateFormat> sdf = new ThreadLocal<>();
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(10);
for (int i = 0; i < 100; i++) {
executorService.submit(new DateUtil("2019-11-25 09:00:" + i % 60));
}
}
static class DateUtil implements Runnable {
private String date;
public DateUtil(String date) {
this.date = date;
}
@Override
public void run() {
if (sdf.get() == null) {
sdf.set(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
} else {
try {
Date date = sdf.get().parse(this.date);
System.out.println(date);
} catch (ParseException e) {
e.printStackTrace();
}
}
}
}
}
TheadLocal 使用场景
1 用来实现线程参数传递，如 Spring 的 RequestContextHolder
2 针对存在线程安全对象，我们可以为每一个线程手动创建一个来保证线程安全
TheadLocal 导致内存溢出
当我们把一个变量添加到线程容器中时，其生命周期和线程一致（被线程对象间接引用），在线程生命周期内gc无法回收，也就是说这个变量变成一个线程局部变量。如果线程一直存在并不销毁（如线程池）则可能引发内存泄漏问题。
