当使用 ThreadLocal 维护变量的时候 为每一个使用该变量的线程提供一个独立的变量副本,即每个线程内部都会有一个该变量,这样同时多个线程访问该变量并不会彼此相互影响,因此他们使用的都是自己从内存中拷贝过来的变量的副本, 这样就不存在线程安全问题,也不会影响程序的执行性能。但是要注意,虽然 ThreadLocal 能够解决上面说的问题,但是由于在每个线程中都创建了副本,所以要考虑它对资源的消耗,比如内存的占用会比不使用 ThreadLocal 要大。
@Test
public void testSimpleThreadLocal() throws InterruptedException {
ThreadLocal threadLocal = new ThreadLocal();
threadLocal.set("simple thread local in main thread!");
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("inner thread:" + threadLocal.get());
threadLocal.set("simple ThreadLocal in thread!");
System.out.println("inner thread:" + threadLocal.get());
}
});
thread.start();
thread.join();
System.out.println(threadLocal.get());
}
输出结果为:
inner thread:null
inner thread:simple ThreadLocal in thread!
simple thread local in main thread!
这里我们从源码角度来聊一聊 ThreadLocal 的原理。先来看一看它的属性和方法:
我们先来走一遍流程,然后再回过头来看一看每个方法的作用。
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
先看下 getMap 方法:
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
要了解这个,我们需要先看一看 Thread 类中的两个属性:
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
/*
* InheritableThreadLocal values pertaining to this thread. This map is
* maintained by the InheritableThreadLocal class.
*/
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
这两个参数在 new Thread 时会进行初始化:
public Thread() {
init(null, null, "Thread-" + nextThreadNum(), 0);
}
private void init(ThreadGroup g, Runnable target, String name,
long stackSize, AccessControlContext acc) {
.............
if (parent.inheritableThreadLocals != null)
this.inheritableThreadLocals =
ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
............
}
需要关注的是在初始化时会将父线程的 inheritableThreadLocals 赋给子线程(这点在后面讲到 inheritableThreadLocals 时特别有用)。
我们再回过来看 set 方法,在 getMap 时第一次获取到的值为 null,继而会执行 createMap 方法:
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
会给当前线程的 threadLocals 变量赋一个新创建的 ThreadLocalMap 对象。传入的是 threadLocal 变量和要 set 的值,我们看一下 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);
}
关于这个构造我们来聊以下几点:
这里是不是想到了 hashmap 中的用法——用 key 的 hashcode 对容量减一取&操作的结果应该是该值在 map 中的索引位置。前提是容量是 2 的指数倍。
而当第二次调用 ThreadLocal 的 set(value)方法时,会直接进入下面这个方法:
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);
//相当于i < len - 1的一个遍历
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
//e的值是tab[i]位置上的那个Entry
ThreadLocal<?> k = e.get();
//条件一:如果这个ThreadLocal的引用已经存在时,则直接更改Entry的value值。
if (k == key) {
e.value = value;
return;
}
//条件二:e!=null成立,证明这个Entry之前存在,但是现在这个Entry中的key为空时
if (k == null) {
//如果key为null,用新key、value覆盖,同时清理历史key=null的陈旧数据
//在replaceStaleEntry中会从i位置开始向前和向后清理table上的key为null的Entry,减小空间占用
replaceStaleEntry(key, value, i);
return;
}
}
//如果不符合上述两个条件时,直接放入位置i
tab[i] = new Entry(key, value);
int sz = ++size;
//1. 清理一些slot
//2. 是否需要扩容,如果需要扩容则需要将老的数据进行rehash重新放入容器中
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}
这里需要注意一点是,当两个 hash 冲突时会有覆盖发生。
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 Entry getEntry(ThreadLocal<?> key) {
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
if (e != null && e.get() == key)
return e;
else
return getEntryAfterMiss(key, i, e);
}
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;
}
对于 get 方法我们做以下几点讲解:
关于 ThreadLocal 的部分就聊到这里,通过上面的流程我们可以看出,ThreadLocal 是用来隔离每个线程的变量使用的,对于父子线程的变量传递却并不适合,那么怎么拿到父线程的共享变量值呢,下节的 inheritableThreadLocals 会告诉你答案。