Java ThreadLocal 线程本地变量
ThreadLocal 作用
ThreadLocal
的功能在Java
多线程并发环境中非常实用,其作用是提供线程本地变量,例如用户ID
、会话ID
等与当前线程密切关联的信息。
这里提到的
线程本地变量
指的是:当前线程自身拥有的变量值。其他线程中可能存在相同性质的变量值,但是彼此存在线程隔离,互不共享,所以在多线程环境中,对变量值的操作不需要添加同步控制。
声明示例:
public class Test {
private static ThreadLocal<Long> threadId = new ThreadLocal<>();
//...
}
这里声明的方式较为简单,后续会提供ThreadLocal
类的使用函数说明。
ThreadLocal 产生背景
原始代码
以id
的查询和修改操作为例,若多线程环境中类成员的声明、使用为如下方式,则使用过程中可能存在访问结果不确定的情况:
public class Test {
private Long id = 1L;
public void updateId() {
this.id = Thread.currentThread().getId();
}
public Long getId() {
return this.id;
}
}
当一个线程访问getId
函数时,可能同时有另一个线程执行了updateId
修改函数,所以查询到的id
值存在不确定性。
这里对
id
的赋值使用的是Thread.currentThread().getId()
,也就是赋予了线程id
,此处只是为了表示该变量值与当前线程有关而已。
synchronized 修饰
为了保证当一个线程执行查询id
操作的同时,不会有其他线程执行修改操作,这里可以使用synchronized
关键字对查询和修改操作进行同步控制:
public class Test {
private Long id = 1L;
public synchronized void updateId() {
this.id = Thread.currentThread().getId();
}
public synchronized Long getId() {
return this.id;
}
}
在方法声明中增加synchronized
关键字修饰,则线程需要先获取对象锁,然后才能执行同步方法内容。虽然该方式可以达到同步访问的目的,但是串行访问的代价较大。
这里使用
Java
内置的synchronized
关键字来进行访问控制,只是为了举例说明同步的形式。由于该示例中的getId
和updateId
函数相当于读、写操作,所以也可以使用java.util.concurrent.locks
包中提供的Lock、ReadWriteLock
读写锁来实现读写控制。
ThreadLocal 线程本地变量
为了避免多线程场景下的串行访问现象,这里给每一个线程提供一个id
对象,由于每个线程都有一个自己的id
对象,所以查询、修改操作彼此不再相互影响:
public class Test {
private ThreadLocal<Long> idLocal = new ThreadLocal<Long>();
public void updateId() {
idLocal.set(Thread.currentThread().getId());
}
public Long getId() {
return idLocal.get();
}
}
在代码中声明了一个idLocal
成员,给每个线程分配一个自己单独id
对象的功能,就是由该成员实现的;每个线程对自己id
对象的查询和修改操作,也都是由该对象完成的。
从代码中可以发现一个很明显的现象,一直讲的
id
对象不见了,或者说它是被idLocal
成员隐藏掉了。这是因为idLocal
成员与id
对象构成一个键值对,键为idLocal
成员,值为id
对象,所以代码中只需要保留一个idLocal
键成员就可以了,对值的修改通过updateId
函数中的idLocal.set()
完成,对值的查询通过getId
函数中的idLocal.get()
完成。
因为idLocal
成员与id
对象构成了一个键值对,所以现在关注的重点不再是id
对象,而是idLocal
成员,因为得idLocal
,即可通过idLocal.get()
得id
对象。因为idLocal
是一个成员变量,用于指向一个ThreadLocal
类型对象,下面分析该成员变量是怎么保存于每个线程中的。
ThreadLocal 实现原理
要实现每个线程中都保存一个自己的id
对象,则需要实现每个线程中都保存一个<idLocal, id>
键值对。首先看一下ThreadLocal
的set
函数是怎么在每个线程上保存<idLocal, id>
键值对;然后看一下ThreadLocal
的get
函数是怎么从每个线程上获取<idLocal, id>
键值对,继而获取键值id
对象的。
后续引用的
Java
源码版本为jdk1.8.0_121
set 函数
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);
}
//...
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
由源码可知,set
函数中,首先获取当前线程对象t
,然后获取t
对象的threadLocals
属性,该属性的类型为ThreadLocalMap
,维持的是一个键值对序列。当t
对象的threadLocals
属性不为空时,执行map.set(this, value)
,键为this
,即idLocal
,键值为value
,即id
对象。
由ThreadLocal
类中的set
函数内容分析可知,每个线程对象通过自身的threadLocals
成员,维持一个键值对序列,前面提到的<idLocal, id>
键值对,则是保存在该threadLocals
成员中的一个键值对。由此可知,在每个线程上保存<idLocal, id>
键值对,是通过获取每个线程的threadLocals
成员属性来实现的。
ThreadLocalMap 类型
线程对象的成员属性threadLocals
,其声明方式为:
public class Thread implements Runnable {
ThreadLocal.ThreadLocalMap threadLocals = null;
//...
}
ThreadLocalMap
是ThreadLocal
类中的一个静态内部类,其键值对类型定义为:
public class ThreadLocal<T> {
//...
static class ThreadLocalMap {
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 Entry[] table;
//...
}
}
由ThreadLocalMap
定义可知,其内部维持的是一个Entry
数组,Entry
是一个键值对类型,键的类型为ThreadLocal
,键值的类型为Object
。
由定义可知,
Entry
对键类型ThreadLocal
保持的是弱引用,当测试类对象test
消除或者线程终止后,即除了Entry
之外,不存在其他对ThreadLocal
对象的引用,当执行垃圾回收时,会回收该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();
}
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;
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
protected T initialValue() {
return null;
}
要获得每个线程上保存的<idLocal, id>
键值对,get
方法内首先获得当前线程对象t
,继而获得线程对象的threadLocals
成员属性,即这里的ThreadLocalMap
类型变量map
,然后根据idLocal
获得map
上的<idLocal, id>
键值对,最后获取键值id
对象。
在get
方法中有两种情况下可能会调用setInitialValue()
方法设置初始值:
-
一是线程对象
t
的threadLocals
成员属性为空时,即当前线程对象上并没有保存任何键值对,此时会初始化threadLocals
成员属性,并赋予初始键值对<idLocal, null>
; -
另一种情况是线程对象
t
的threadLocals
成员属性不为空,但是并不存在idLocal
对应的键值对,此时会赋予默认键值对<idLocal, null>
。
由get
方法的分析可知,在查询idLocal
对应的键值之前,若没有执行set
函数进行设置,则默认会创建并返回null
值,所以推荐ThreadLocal
的使用方式为重写initialValue
函数,设定初始值:
public class Test {
private ThreadLocal<Long> idLocal_one = new ThreadLocal<Long>();
private ThreadLocal<Long> idLocal_two = new ThreadLocal<Long>() {
protected Long initialValue() {
return Thread.currentThread().getId();
}
};
public static void main(String[] args) {
Test test = new Test();
System.out.println("main thread idLocal_one get: " + test.idLocal_one.get());
System.out.println("main thread idLocal_two get: " + test.idLocal_two.get());
}
}
输出结果为:
main thread idLocal_one get: null
main thread idLocal_two get: 1
由示例可知,idLocal_one
没有设置初始值,所以直接查询其对应的键值为null
,idLocal_two
设置了初始值,所以直接查询其对应的键值不为null
。
ThreadLocal 使用注意
由前面的分析可知,要想在每个线程中保存仅供自身使用的对象id_1、id_2...
,可以声明使用ThreadLocal
类型对象idLocal_1、idLocal_2...
,构成<idLocal, id>
键值对,保存于每个线程对象的threadLocals
成员中,通过idLocal
对象的get
方法即可查询对应的id
对象。
对于如下的使用场景:
public class Test {
private ThreadLocal<Long> idLocal = new ThreadLocal<Long>() {
protected Long initialValue() {
return Thread.currentThread().getId();
}
};
public static void main(String[] args) throws InterruptedException {
Test test = new Test();
System.out.println("main thread idLocal: " + test.idLocal);
System.out.println("main thread idLocal get: " + test.idLocal.get());
new Thread() {
public void run() {
System.out.println("sub thread idLocal: " + test.idLocal);
System.out.println("sub thread idLocal get: " + test.idLocal.get());
}
}.start();
}
}
代码中存在两个线程,主线程和子线程,输出结果为:
main thread idLocal: Test$1@1540e19d
main thread idLocal get: 1
sub thread idLocal: Test$1@1540e19d
sub thread idLocal get: 11
由结果可知主线程和子线程引用的是同一个idLocal
对象,因为Test
类中声明的idLocal
变量是可更改的,所以这里存在一个潜在的问题:如果多个线程中使用的是同一个idLocal
变量,其中某一个线程更改了该变量的引用对象,则会导致其他所有线程查询不到之前设置的键值对。
情况一:
public class Test {
private ThreadLocal<Long> idLocal = new ThreadLocal<Long>() {
protected Long initialValue() {
return Thread.currentThread().getId();
}
};
public static void main(String[] args) throws InterruptedException {
Test test = new Test();
test.idLocal.set(123L);
System.out.println("main thread idLocal get: " + test.idLocal.get());
Thread subThread = new Thread() {
public void run() {
test.idLocal = new ThreadLocal<Long>() {
protected Long initialValue() {
return 456L;
}
};
}
};
subThread.start();
subThread.join();
System.out.println("main thread idLocal get: " + test.idLocal.get());
}
}
输出结果为:
main thread idLocal get: 123
main thread idLocal get: 456
主线程和子线程共用一个test
对象,在子线程中更新了idLocal
的引用对象,导致主线程丢失根据之前idLocal
设置的键值。
情况二:
public class Test {
private static ThreadLocal<Long> idLocal = new ThreadLocal<Long>() {
protected Long initialValue() {
return Thread.currentThread().getId();
}
};
public static void main(String[] args) throws InterruptedException {
Test one = new Test();
one.idLocal.set(123L);
System.out.println("main thread idLocal get: " + one.idLocal.get());
Thread subThread = new Thread() {
public void run() {
Test two = new Test();
two.idLocal = new ThreadLocal<Long>() {
protected Long initialValue() {
return 456L;
}
};
}
};
subThread.start();
subThread.join();
System.out.println("main thread idLocal get: " + one.idLocal.get());
}
}
输出结果为:
main thread idLocal get: 123
main thread idLocal get: 456
因为idLocal
声明为静态变量,所以多个Test
实例对象共享该变量,一个线程中的实例更改了该变量引用的对象,则其他线程会丢失根据该变量设置的键值。
所以推荐以final
修饰ThreadLocal
类型成员,使用方式为:
public class Test {
private final static ThreadLocal<Long> idLocal = new ThreadLocal<Long>() {
protected Long initialValue() {
return Thread.currentThread().getId();
}
};
public void set(Long value) {
idLocal.set(value);
}
public Long get() {
return idLocal.get();
}
//...
}
参考
When and how to use a ThreadLocal
How is ThreadLocal implemented?