概述
该类的作用是提供线程局部(thread-local)的变量, 这些变量与正常变量的不同之处在于(通过其get或set方法)访问一个线程的每个线程都有自己的独立初始化的变量副本。ThreadLocal实例通常是希望存储状态与线程(例如,用户ID或事务ID)关联的私有静态字段。
例如,下面的类生成每个线程本地的唯一标识符。第一次调用ThreadId.get方法时,分配一个线程的ID,在后续调用中保持不变。
import java.util.concurrent.atomic.AtomicInteger;
public class ThreadId {
// Atomic integer containing the next thread ID to be assigned
private static final AtomicInteger nextId = new AtomicInteger(0);
// Thread local variable containing each thread's ID
private static final ThreadLocal<Integer> threadId =
new ThreadLocal<Integer>() {
@Override
protected Integer initialValue() {
return nextId.getAndIncrement();
}
};
// Returns the current thread's unique ID, assigning it if necessary
public static int get() {
return threadId.get();
}
}
每个线程都保持对线程本地变量的副本的隐式引用,只要线程是活的并且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实例。 ThreadLocalMap是ThreadLocal的一个内部类,这个类的代码占据了ThreadLocal类的一半还多。可见其重要性。Threadlocal的方法都是基于这个类实现的。
从上面代码我们可以看到,如果map不为空就调用set方法
/**
* Set the value associated with key.
*
* @param key the thread local object
* @param value the value to be set
*/
private void set(ThreadLocal<?> key, Object value) {
// We don't use a fast path as with get() because it is at
// least as common to use set() to create new entries as
// it is to replace existing ones, in which case, a fast
// path would fail more often than not.
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)]) {
ThreadLocal<?> k = e.get();
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();
}
Key即为传入的参数this,即调用这个set方法的ThreadLocal实例,我们知道每个线程都会有自己对应的ThreadLocal实例,而这里把这个实例拿来作为了map的key,因此,这就可以解释清楚了为什么ThreadLocal是线程之间隔离的。
实现的逻辑比较简单:
根据传入的key,借助了Unsafe类去计算它的hashcode值,然后value不用做任何其他处理。最后是存储在了一个Entry类型的数组里面。
Entry则是ThreadLocalMap这个类的有一个内部类,定义如下:
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
可以看到,这个类里面有一个Object类型的成员变量value,这个成员变量就是我们拿来存储值的变量。
get方法
实现代码如下:
/**
* Returns the value in the current thread's copy of this
* thread-local variable. If the variable has no value for the
* current thread, it is first initialized to the value returned
* by an invocation of the {@link #initialValue} method.
*
* @return the current thread's value of this thread-local
*/
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();
}
有一个很有意思的问题,这个方法不是get方法吗?那它为什么没有参数,没有key呢?其实在分析set方法的时候我们已经回答了这个问题了,ThreadLocal的map的key是ThreadLocal实例本身。再看代码:首先仍旧是获取了当前线程,再去拿了它的ThreadLocalMap,这个时候,直接去调用了这个map的getEntry方法,然后传入的参数是this ,即这个ThreadLocal对象本身。非常巧妙的逻辑。
remove方法
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
调用了ThreadLocalMap的remove方法,参数是ThreadLocal实例,也就是map的key,即这里的this。实现如下
/**
* Remove the entry for key.
*/
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;
}
}
}
遍历table,找到这个key对于的Entry,然后把它的值设为null。
ThreadLocal Map定义
在ThreadLocal类中,对象是存储在一个内部类ThreadLocalMap的成员变量table里面的,定义如下:
static class ThreadLocalMap {
/**
* The entries in this hash map extend WeakReference, using
* its main ref field as the key (which is always a
* ThreadLocal object). Note that null keys (i.e. entry.get()
* == null) mean that the key is no longer referenced, so the
* entry can be expunged from table. Such entries are referred to
* as "stale entries" in the code that follows.
*/
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
/**
* The initial capacity -- MUST be a power of two.
*/
private static final int INITIAL_CAPACITY = 16;
/**
* The table, resized as necessary.
* table.length MUST always be a power of two.
*/
private Entry[] table;
...
}
可以看到table是一个Entry类型的数组,Entry也是一个类,这个类里面又有一个成员变量Object类型的value,这就是ThreadLocal这个类存储值得地方。
典型使用场景
比较出名的一个应用场景是 Web服务器端的Session的存储。
Web容器采用线程隔离的多线程模型,也就是每一个请求都会对应一条线程,线程之间相互隔离,没有共享数据。这样能够简化编程模型,程序员可以用单线程的思维开发这种多线程应用。
当收到一个请求时,可以将当前Session信息存储在ThreadLocal中,在请求处理过程中可以随时使用Session信息,每个请求之间的Session信息互不影响。当请求处理完成后通过remove方法将当前Session信息清除即可。