前言
刚看过EventBus和AndroidEventBus的源码, 发现里面都有用到ThreadLocal, 那ThreadLocal到底为何物呢, 相信从事Java并发编程的朋友们并不陌生, 请跳过本篇文章. 下面讲一下我自己的理解, 如有不对的地方, 欢迎指正.
对ThreadLocal的理解
看源码注释: ThreadLocal维护线程的本地变量, 这些变量不同于线程中的普通副本, 它可以通过get, set方法获取和操作线程中初始变量的独立副本. ThreadLocal实例一般作为类中的私有静态属性来关联一个线程的状态(例如用户id, 或事件id).
简单来说就是通过ThreadLocal维护一个变量, 然后不同的线程来访问这个变量的时候, ThreadLocal会为每一个线程提供一个独立的变量副本, 这样不同的线程就可以互不影响的操作这个变量. 所以ThreadLocal普遍应用于多线程开发.
看到这里还不了解ThreadLocal维护变量到底有什么用? 别急, 看一个简单的例子就知道了.
public class JavaTest {
private static ThreadLocal localString = new ThreadLocal() {
@Override
protected String initialValue() {
return "Hello World!";
}
};
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + ":" + localString.get());
localString.set("aaa");
System.out.println(Thread.currentThread().getName() + ":" + localString.get());
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + ":" + localString.get());
localString.set("bbb");
System.out.println(Thread.currentThread().getName() + ":" + localString.get());
}
}).start();
}
}
打印结果:
Thread-0:Hello World!
Thread-0:aaa
Thread-1:Hello World!
Thread-1:bbb
看到没, 线程0对ThreadLocal维护的变量修改之后, 线程1修改之前获取到的值还是初始值, 而不是被线程0修改之后的值. 如果是普通变量, 线程1获取到的肯定是被线程0修改之后的值.
ThreadLocal的基本使用
ThreadLocal支持泛型, 使用起来非常简单, 有以下几个操作:
- public void set(T value): 为当前线程的本地线程变量赋值.
- public T get(): 取出当前线程的本地线程变量.
- protected T initialValue(): 返回当前线程的本地线程变量的初始化值, 是protected 类型, 实例化时可以重写该方法为变量初始化, 默认为null.
- public void remove(): 删除当前线程的本地线程变量.
ThreadLocal源码解析
ThreadLocal到底是怎么为每一个线程提供独立的变量副本的呢, 看下Thread的代码, 你会发现有一个属性ThreadLocal.ThreadLocalMap threadLocals, 在整个Thread代码中threadLocals也没做什么操作.
class Thread implements Runnable {
...
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
//threadLocals 由ThreadLocal来维护
ThreadLocal.ThreadLocalMap threadLocals = null;
...
//线程结束之前通知系统来清理
private void exit() {
...
/* Speed the release of some of these resources */
threadLocals = null;
...
}
来看下ThreadLocal.ThreadLocalMap的庐山真面目:
public class ThreadLocal {
...
static class ThreadLocalMap {
static class Entry extends WeakReference {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal k, Object v) {
super(k);
value = v;
}
}
private Entry[] table;
...
}
}
ThreadLocalMap是ThreadLocal的一个静态内部类, 是用来维护线程本地变量的一个自定义HashMap, 而ThreadLocal操作数据也都是通过ThreadLocalMap来实现的, 下面再具体分析.
可以看到ThreadLocalMap内部又有一个静态类Entry, 是对ThreadLocal的弱引用, 保存了ThreadLocal对象和变量值, 可以理解为key是ThreadLocal对象,值是变量值.
Thread, ThreadLocal, ThreadLocalMap之间到底是怎么联系到一起的, 后面会揭晓.
来看ThreadLocal对数据的操作代码:
- set方法
public void set(T value) {
//获取当前线程
Thread t = Thread.currentThread();
//获取当前线程的ThreadLocalMap
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);//map不为空的话, 保存当前变量值
else
createMap(t, value);//map为空的话创建一个map
}
ThreadLocalMap getMap(Thread t) {
//返回对应线程的threadLocals属性
return t.threadLocals;
}
void createMap(Thread t, T firstValue) {
//创建ThreadLocalMap
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
看到没, set的时候会获取当前线程的ThreadLocalMap, 然后通过该map存数据, key是当前ThreadLocal对象, value是要设置的变量.
继续看ThreadLocalMap中创建及set方法:
ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
//创建一个长度为16的Entry数组
table = new Entry[INITIAL_CAPACITY];
//根据传进来firstKey的hashCode值获取一个下标
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
//创建一个Entry,保存firstKey和初始值, 存入table
table[i] = new Entry(firstKey, firstValue);
size = 1;
setThreshold(INITIAL_CAPACITY);
}
private void set(ThreadLocal key, Object value) {
Entry[] tab = table;
int len = tab.length;
//根据参数ThreadLocal 的hashCode获取下标
int i = key.threadLocalHashCode & (len-1);
for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {
//获取Entry中的key
ThreadLocal k = e.get();
//key是当前设置的ThreadLocal对象, 就把值保存进去
if (k == key) {
e.value = value;
return;
}
//如果Entry不为空,但其key为空
if (k == null) {
//从table数组中找出key是当前ThreadLocal对象的Entry, 存入变量, 放到当前位置, 如果没找到, 就new一个Entry放入当前位置
replaceStaleEntry(key, value, i);
return;
}
}
//如果通过下标找到的Entry都为空,就new一个Entry, 保存ThreadLocal和变量,存入数组
tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
总结一下set方法, 就是从当前线程的map中取出引用是当前ThreadLocal对象的Entry, 没有的话创建一个Entry, 保存当前变量. map为空的话就去创建一个map, 然后新建一个Entry, 键是当前ThreadLocal对象, 值是变量, 保存在Entry数组中.
- get方法
public T get() {
Thread t = Thread.currentThread();
//获取当前线程中的ThreadLocalMap
ThreadLocalMap map = getMap(t);
//如果map不为空, 获取map中的Entry对象, 获取value
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null)
return (T)e.value;
}
//如果map为空, 就从初始值来获取
return setInitialValue();
}
先来看下setInitialValue方法:
private T setInitialValue() {
//通过initialValue获取初始值, 不重写该方法的话, 默认为null
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}
setInitialValue是不是跟set方法很像呢, 先从initialValue获取初始值, 再set保存. 下面看下通过ThreadLocalMap.Entry获取变量值的方法:
private Entry getEntry(ThreadLocal key) {
//根据key的hashCode值获取下标
int i = key.threadLocalHashCode & (table.length - 1);
//根据下标找到数组中对应的Entry
Entry e = table[i];
//如果Entry的键与传进来的ThreadLocal 相等, 就找到了对应的Entry
if (e != null && e.get() == key)
return e;
else
return getEntryAfterMiss(key, i, e);//继续寻找
}
private Entry getEntryAfterMiss(ThreadLocal key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
while (e != null) {
获取Entry的引用
ThreadLocal k = e.get();
//是当前key, 找到, 返回
if (k == key)
return e;
//如果引用为空, 从数组table中删除该位置的Entry
if (k == null)
expungeStaleEntry(i);
else
i = nextIndex(i, len);//下标加一, 继续寻找
e = tab[i];
}
//如果整个数组中都没找到对应ThreadLocal 的Entry, 返回null
return null;
}
总结一下get方法就是从当前线程的map中找到引用是当前ThreadLocal对象的Entry, 获取保存在Entry中的变量值, 没有的话获取变量的初始值并保存在map中.
- remove方法
public void remove() {
//获取当前线程的ThreadLocalMap
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
private void remove(ThreadLocal key) {
Entry[] tab = table;
int len = tab.length;
//根据ThreadLocal的hashCode找到下标
int i = key.threadLocalHashCode & (len-1);
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
//循环查找数组中引用等于要移除的ThreadLocal的Entry
if (e.get() == key) {
e.clear();
//从数组中删除该位置的Entry
expungeStaleEntry(i);
return;
}
}
}
就是获取当前线程的map, 然后从数组中删除key是当前ThreadLocal的Entry.
到此, ThreadLocal的代码基本都已经看完了, Thread, ThreadLocal, ThreadLocalMap之间的联系你看明白了吗?其实通过ThreadLocal来操作数据, 本质是通过当前Thread中的ThreadLocalMap来操作数据. 而变量的源头是通过initialValue设置初始值, 所以不同线程都有一份变量的副本, 可以互不影响的操作这个变量.