ThreadLocal叫做线程变量,意思是ThreadLocal中填充的变量属于当前线程,该变量对其他线程而言是隔离的,也就是说该变量是当前线程独有的变量。
ThreadLocal为变量在每个线程中都创建了一个副本,那么每个线程可以访问自己内部的副本变量。
ThreadLoal 变量,线程局部变量,同一个 ThreadLocal 所包含的对象,在不同的 Thread 中有不同的副本。这里有几点需要注意:
- 因为每个 Thread 内有自己的实例副本,且该副本只能由当前 Thread 使用。这是也是 ThreadLocal 命名的由来。
- 既然每个 Thread 有自己的实例副本,且其它 Thread 不可访问,那就不存在多线程间共享的问题。
特点:
- ThreadLocal 提供了线程本地的实例。它与普通变量的区别在于,每个使用该变量的线程都会初始化一个完全独立的实例副本。
- ThreadLocal 变量通常被private static修饰。当一个线程结束时,它所使用的所有 ThreadLocal 对应的实例副本都可被回收。
总的来说,ThreadLocal 适用于每个线程需要自己独立的实例且该实例需要在单线程内被多个方法使用,换句话说,就是变量在多线程间隔离,而在各自的单线程内共享(类似于全局变量的概念) 的场景。
下图可以增强理解:
一句话理解ThreadLocal,向ThreadLocal里面存东西就是向它里面的ThreadLocalMap存东西的,然后ThreadLocal把这个ThreadLocalMap挂到当前的线程底下,这样ThreadLocalMap就只属于这个线程了。
ThreadLocal与Synchronized的区别ThreadLocal其实是与线程绑定的一个变量。ThreadLocal和Synchonized都用于解决多线程并发访问。
但是ThreadLocal与synchronized有本质的区别:
- Synchronized用于线程间的数据共享,而ThreadLocal则用于线程间的数据隔离。
- Synchronized是利用锁的机制,使变量或代码块在某一时该只能被一个线程访问。
- ThreadLocal为每一个线程都提供了变量的副本,使得每个线程在某一时间访问到的并不是同一个对象,这样就隔离了多个线程对数据的数据共享。而Synchronized却正好相反,它用于在多个线程间通信时能够获得数据共享。
public class ThreadLocaDemo {
public static ThreadLocal localVar1 = new ThreadLocal<>();
static void print(String str) {
//打印当前线程中本地内存中本地变量的值
System.out.println(str + " :" + localVar1.get());
//清除本地内存中的本地变量
localVar1.remove();
}
public static void main(String[] args) throws InterruptedException {
new Thread(new Runnable() {
public void run() {
localVar1.set("local_A");
print("A");
//打印本地变量
System.out.println("after remove : " + localVar1.get());
}
},"A").start();
Thread.sleep(1000);
new Thread(new Runnable() {
public void run() {
localVar1.set("local_B");
print("B");
//打印本地变量
System.out.println("after remove : " + localVar1.get());
}
},"B").start();
}
}
输出:
A :local_A
after remove : null
B :local_B
after remove : null
从这个示例中我们可以看到,两个线程分表获取了自己线程存放的变量,他们之间变量的获取并不会错乱。
注:每个线程内ThreadLocal变量只能对应一个值,因为ThreadLocal变量做为 key 存到单线程的ThreadLocalMap中,根据Map唯一特性,所以单线程内ThreadLocal变量对应的值是唯一。
线程A执行 localVar1.set(“local_A_2”);
new Thread(new Runnable() {
public void run() {
localVar1.set("local_A");
localVar1.set("local_A_2");
print("A");
//打印本地变量
System.out.println("after remove : " + localVar1.get());
}
},"A").start();
输出:
A :local_A_2 after remove : null B :local_B after remove : null
线程A的localVar1变量对应的值变成了 “local_A_2”。
定义一个ThreadLocal变量,自定义类类型需要重写 initialValue 方法
public static ThreadLocal定义多个ThreadLocal变量,并且声明不同类型。localVar1 = new ThreadLocal (){ @Override protected User initialValue() { return new User(); } };
增加 public static ThreadLocal
public class ThreadLocaDemo {
public static ThreadLocal localVar1 = new ThreadLocal<>();
public static ThreadLocal
两个线程分表获取了自己线程存放的变量,他们之间变量的获取并不会错乱。
ThreadLocal的原理public class ThreadLocal
- public void set(T value):为该ThreadLocal变量设置value值。
- public T get():获取该ThreadLocal变量对应value值。
- public void remove():从ThreadLocalMap删除该ThreadLocal变量。
- void createMap(Thread t, T firstValue):创建ThreadLocalMap。
- private T setInitialValue():初始化TheralLocalMap。
public void set(T value) {
//1、获取当前线程
Thread t = Thread.currentThread();
//2、获取线程中的属性 threadLocalMap ,如果threadLocalMap 不为空,
//则直接更新要保存的变量值,否则创建threadLocalMap,并赋值
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
// 初始化thradLocalMap 并赋值
createMap(t, value);
}
从上面的代码可以看出,ThreadLocal.set赋值的时候首先会获取当前线程thread,并获取thread线程中的ThreadLocalMap属性。如果map属性不为空,用ThreadLocal作为key,更新value值;如果map为空,则实例化threadLocalMap,并将value值初始化。
那么ThreadLocalMap又是什么呢,还有createMap又是怎么做的,我们继续往下看。
static class ThreadLocalMap {
static class Entry extends WeakReference> {
Object value;
Entry(ThreadLocal> k, Object v) {
super(k);
value = v;
}
}
}
可看出ThreadLocalMap是ThreadLocal的内部静态类,而它的构成主要是用Entry来保存数据 ,而且还是继承的弱引用。在Entry内部使用 ThreadLocal的弱引用 作为key, 使用我们设置的value作为value。使用弱引用,防止内存泄漏。
弱引用的特点:如果一个对象只存在弱引用,那么在下一次垃圾回收的时候必然会被清理掉。详见《Java四大引用》
//这个是threadlocal 的内部方法
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
//ThreadLocalMap 构造方法
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);
}
ThreadLocal的get方法
public T get() {
//1、获取当前线程
Thread t = Thread.currentThread();
//2、获取当前线程的ThreadLocalMap
ThreadLocalMap map = getMap(t);
//3、如果map数据为空,
if (map != null) {
//3.1、获取threalLocalMap中存储的值
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
//如果是数据为null,则初始化,初始化的结果,TheralLocalMap中存放key值为threadLocal,值为null
return setInitialValue();
}
private T setInitialValue() {
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}
ThreadLocal的remove方法
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
remove方法,直接将ThrealLocal 对应的值从当前线程Thread中的ThreadLocalMap中删除。防止内存泄漏。
ThreadLocal与Thread,ThreadLocalMap之间的关系这个图中我们可以非常直观的看出,ThreadLocalMap其实是Thread线程的一个属性值。ThreadLocalMap可以拥有多个ThreadLocal维护的自己线程独享的共享变量(这个共享变量只是针对自己线程里面共享)。
ThreadLocal应用场景基于ThreadLocal特点,适应场景
- 每个线程需要有自己单独的实例。
- 实例需要在单线程内多个方法中共享,但不希望被其他线程共享。
private static final ThreadLocal threadSession = new ThreadLocal();
public static Session getSession() throws InfrastructureException {
Session s = (Session) threadSession.get();
try {
if (s == null) {
s = getSessionFactory().openSession();
threadSession.set(s);
}
} catch (HibernateException ex) {
throw new InfrastructureException(ex);
}
return s;
}
数据库连接,处理数据库事务
保存线程不安全的工具类SimpleDateFormat
通常用于保存线程不安全的工具类,典型的需要使用的类就是 SimpleDateFormat。
public class ThreadLocalNormalUsage00 {
private static ExecutorService threadPool = Executors.newFixedThreadPool(10);
public static void main(String[] args) throws InterruptedException {
for (int j = 0; j < 1000; j++) {
int i = j;
threadPool.execute(() -> System.out.println(date(i)));
Thread.sleep(100L);
}
threadPool.shutdown();
}
public static String date(int seconds) {
return ThreadSafeFormatter
.dateFormatThreadLocal
.get()
.format(new Date(seconds * 1000L));
}
}
class ThreadSafeFormatter {
public static ThreadLocal dateFormatThreadLocal
= ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"));
}
ThreadLocal给每个线程维护一个自己的simpleDateFormat对象,这个对象在线程之间是独立的,互相没有关系的。这也就避免了线程安全问题。与此同时,simpleDateFormat对象还不会创造过多,线程池一共只有 10 个线程,所以需要10个对象即可。
数据跨层传递每个线程内需要保存类似于全局变量的信息,例如在拦截器中获取的用户信息,该信息需要被多个服务共享。
比如说我们是一个用户系统,那么当一个请求进来的时候,一个线程会负责执行这个请求,然后这个请求就会依次调用service-1()、service-2()、service-3()、service-4(),这4个方法可能是分布在不同的类中的。
public class ThreadLocalDemo05 {
public static void main(String[] args) {
User user = new User("jack");
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 holder = new ThreadLocal<>();
}
class User {
String name;
public User(String name){
this.name = name;
}
}
输出:
service2拿到的用户:jack
service3拿到的用户:jack
Spring使用ThreadLocal解决线程安全问题
Spring中,绝大部分Bean都可以声明为singleton作用域。就是因为Spring对一些Bean(如RequestContextHolder、TransactionSynchronizationManager、LocaleContextHolder等)中非线程安全的“状态性对象”采用ThreadLocal进行封装,让它们也成为线程安全的“状态性对象”,因此有状态的Bean就能够以singleton的方式在多线程中正常工作了。
一般的Web应用划分为展现层、服务层和持久层三个层次,在不同的层中编写对应的逻辑,下层通过接口向上层开放功能调用。在一般情况下,从接收请求到返回响应所经过的所有程序调用都同属于一个线程,如图9-2所示。
这样用户就可以根据需要,将一些非线程安全的变量以ThreadLocal存放,在同一次请求响应的调用线程中,所有对象所访问的同一ThreadLocal变量都是当前线程所绑定的。
线程不安全示例public class TopicDao {
//①一个非线程安全的变量
private Connection conn;
public void addTopic(){
//②引用非线程安全变量
Statement stat = conn.createStatement();
…
}
由于①处的conn是成员变量,因为addTopic()方法是非线程安全的,必须在使用时创建一个新TopicDao实例(非singleton)。
线程安全示例public class TopicDao {
//①使用ThreadLocal保存Connection变量
private static ThreadLocal connThreadLocal = new ThreadLocal();
public static Connection getConnection(){
//②如果connThreadLocal没有本线程对应的Connection创建一个新的Connection,
//并将其保存到线程本地变量中。
if (connThreadLocal.get() == null) {
Connection conn = ConnectionManager.getConnection();
connThreadLocal.set(conn);
return conn;
}else{
//③直接返回线程本地变量
return connThreadLocal.get();
}
}
public void addTopic() {
//④从ThreadLocal中获取线程对应的
Statement stat = getConnection().createStatement();
}
使用本地线程变量,保证了不同的线程使用线程相关的Connection,而不会使用其他线程的Connection。因此,这个TopicDao就可以做到singleton共享了。
面试题为什么不将ThreadLocalMap的key设置为强引用
如果key设计成强引用且没有手动remove(),那么key会和value一样伴随线程的整个生命周期,是无法完全避免内存泄漏的。
ThreadLocalMap的key设置为弱引用,是不是避免了内存泄漏
结论:无论ThreadLocalMap中的key使用什么引用方式,都无法完全避免泄漏。
假设在业务代码中使用完ThreadLocal,ThreadLocal ref被回收了。由于ThreadLocalMap只持有ThreadLocal的弱引用, 没有任何强引用指向ThreadLocal实例,因为弱引用特性,ThreadLocal 就可以顺利被gc回收。
但是!!此时Entry中的key = null,如果没有手动删除Entry以及CurrentThread依然运行的前提下,始终存在有强引用链 CurrentThread Ref → CurrentThread →Map(ThreadLocalMap)-> entry,而且因为key=null,这块value永远不会被访问到了,value就不会被回收了,导致value内存泄漏。
也就是说: ThreadLocalMap中的key使用了弱引用, 如果不手动remove(),也有可能内存泄漏。
为什么 key 要用弱引用?
事实上,在 ThreadLocalMap 中的set/getEntry 方法中,会对 key 为 null(也即是 ThreadLocal 为 null )进行判断,如果为 null 的话,那么会把 value 置为 null 的。
这就意味着如果没有手动删除Entry以及CurrentThread依然运行的前提下,就算忘记调用 remove 方法,弱引用比强引用可以多一层保障:弱引用的 ThreadLocal 会被回收,对应value在下一次 ThreadLocaIMap 调用 set/get/remove 中的任一方法的时候会被清除,从而避免内存泄漏。
如何正确的使用ThreadLocal
- 将ThreadLocal变量定义成private static的,这样的话ThreadLocal的生命周期就更长,由于一直存在ThreadLocal的强引用,所以ThreadLocal也就不会被回收,也就能保证任何时候都能根据ThreadLocal的弱引用访问到Entry的value值,然后remove它,防止内存泄露。
- 每次使用完ThreadLocal,都调用它的remove()方法,清除数据。
ThreadLocal的 value为什么不是弱引用?
因为不清楚这个Value除了map的引用还是否还存在其他引用,如果不存在其他引用,当GC的时候就会直接将这个Value干掉了,而此时我们的ThreadLocal还处于使用期间,就会造成Value为null的错误,所以将其设置为强引用。
参考文章:
史上最全ThreadLocal 详解(一)
史上最全ThreadLocal 详解(二)
ThreadLocal的应用场景



