简介
当访问共享数据可变数据时，通常需要进行加锁同步，同步是需要消耗性能的。
一种避免使用同步的方式就是不共享数据：如果数据在每个线程中都拥有一个副本，那就不需要同步了，这种通过将数据封闭在线程中而避免使用同步的技术称为线程封闭。
线程封闭的实现方式由很多种，比如栈封闭（其实就是使用局部变量，只是换了一种高大上的名称而已）、使用ThreadLocal等等
接下来主要分析ThreadLocal，从以下几个方面
- 基本使用
- 原理解析（set、get、remove）
- ThreadLocal使用不当，会造成的Bug
基本使用
ThreadLocal的使用非常简单，下面直接上代码
ThreadLocal<String> threadLocal = new ThreadLocal<String>(){
protected String initialValue() {
return "initialValue";
};
};
System.out.println(threadLocal.get());
threadLocal.set("setValue");
System.out.println(threadLocal.get());
控制台输出的内容:
一般使用会建议把ThreadLocal定位为成员变量 并且被static final修饰，防止被gc回收
原理解析
许多人会误解ThreadLocal的存储结构就是Map<Thread, T>，事实上不是的。简单来说就是：每个Thread里面有个ThreadLocalMap【这个Map类似于平时使用的HashMap，但是它们实现的方法不一样，ThreadLocalMap使用的开放地址法 HashMap使用的拉链法】，当调用ThreadLocal.set，实际上是从当前Thread里取出ThreadLocalMap，把本身ThreadLocal作为key，set的data作为value，放入ThreadLocalMap中。
成员变量
/**
* ThreadLocal类的hashcode，用于定位在ThreadLocalMap的下标。new ThreadLocal<T>()时，调用nextHashCode()方法进行hashcode初始化。
*/
private final int threadLocalHashCode = nextHashCode();
private static AtomicInteger nextHashCode = new AtomicInteger();
/*
* hashcode递增数。每new一个ThreadLocal，那么threadLocalHashCode的生成会以这个数字进行递增
*/
private static final int HASH_INCREMENT = 0x61c88647;
/*
* 生成hashcode的方法：
* 举个例子：
* ThreadLocal threadLocal1 = new ThreadLocal();
* ThreadLocal threadLocal2 = new ThreadLocal();
* 那么
* threadLocal1 的threadLocalHashCode = 0x61c88647
* threadLocal2 的threadLocalHashCode = 0x61c88647 + 0x61c88647
*
*/
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
set方法
public void set(T value) {
// 获取当前线程
Thread t = Thread.currentThread();
// 调用getMap(t)，获取当前Thread里的ThreadLocalMap
ThreadLocalMap map = getMap(t);
// 如果map不为空，直接set；
if (map != null)
map.set(this, value);
// 如果map为空，那么先createMap，在继续set
else
createMap(t, value);
}
这个方法非常简单，上面都有注释进行说明。下面我们依次进入每个方法进行分析
- getMap()方法
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
这个方法也很简单，只是获取Thread里的threadLocals变量，也就是ThreadLocalMap，第一次调用set方法，那么从这里获取的ThreadLocalMap肯定为null。所以我们接下来看一下createMap方法
- createMap()方法
void createMap(Thread t, T firstValue) {
// 这里直接实例化了ThreadLocalMap对象，并且把ThreadLocal本身，和value穿进去
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
-
ThreadLocalMap类
- 成员变量
// 初始化容量
private static final int INITIAL_CAPACITY = 16;
// 存储数据的table
private Entry[] table;
// 当前的容量
private int size = 0;
// 负载因子
private int threshold; // Default to 0
/*
* Entry它是一个弱引用。
* 为什么使用弱引用?
* 可能这个类的作者，怕开发者使用ThreadLocal并且配合线程池一起使用的时候，使用完以后，没有及时remove，造成内存泄露。
* 所以把Entry定义为弱引用，一旦ThreadLocal被gc回收，那么这个Entry的key即为null。
*/
static class Entry extends WeakReference<ThreadLocal<?>> {
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
- 构造方法
// createMap方法调用的是这个构造方法，那么就拿这个来讲解
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
// 创建了一个INITIAL_CAPACITY容量的Entry数组
table = new Entry[INITIAL_CAPACITY];
// 根据threadLocalHashCode【我们前面说的】去计算该ThreadLocal在Entry数组的下标。
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
// 把ThreadLocal作为key，存入Entry数组
table[i] = new Entry(firstKey, firstValue);
// 标记size为1
size = 1;
// 设置负载因子【长度的三分之二】
setThreshold(INITIAL_CAPACITY);
}
private void setThreshold(int len) {
threshold = len * 2 / 3;
}
我们在回到ThreadLocal的set方法，如果ThreadLocalMap存在，那么会调用ThreadLocalMap的set方法，那么我们接下来看下ThreadLocalMap的set方法
- ThreadLocalMap.set()
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
// 计算该ThreadLocal在table的下标【类似于key.threadLocalHashCode % (len - 1)】
int i = key.threadLocalHashCode & (len-1);
/*
* 循环，目的是解决hash冲突。【一般不会进入该循环，hash冲突的几率非常小，因为ThreadLocal的threadLocalHashCode的生成方法非常科学，有兴趣可以自己去测试】
* ThreadLocalMap采用的是开放地址法，它解决hash冲突的方法是
* 1、如果该下标没值，那么直接存储
* 2、如果该下标有值，但不是自己，那么继续往后找，一直找到自己或者没值为止
*/
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
// 从Entry中获取key，也就是ThreadLocal
ThreadLocal<?> k = e.get();
// 如果找到是自己，那么直接替换值，返回
if (k == key) {
e.value = value;
return;
}
// 如果k为null，那么说明k对应的ThreadLocal被gc回收了，调用replaceStaleEntry清理被回收的key。
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
// 生成新的Entry
tab[i] = new Entry(key, value);
// 容量加1
int sz = ++size;
// 调用cleanSomeSlots清理一些无效的值，并且判断是否需要扩容
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
接下来我们看一下ThreadLocalMap是如何清理一些无效的值【也就是被gc回收的ThreadLocal，但是还留在ThreadLocalMap里的】，注意这里是清理“一些”，而不是所有。
- cleanSomeSlots()
private boolean cleanSomeSlots(int i, int n) {
boolean removed = false;
Entry[] tab = table;
int len = tab.length;
// 循环log2N次，这也是为什么清理一些，而不是所有的。
do {
// 找到下一个索引值。这里其实就是i++。如果i>len，那么重新从0开始
i = nextIndex(i, len);
Entry e = tab[i];
if (e != null && e.get() == null) {
n = len;
removed = true;
// expungeStaleEntry这个才是真正的清理过程
i = expungeStaleEntry(i);
}
} while ( (n >>>= 1) != 0);
return removed;
}
- expungeStaleEntry()
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// 将需要清除的下标的值置为null help gc
tab[staleSlot].value = null;
tab[staleSlot] = null;
// 将容量减一
size--;
Entry e;
int i;
// 从staleSlot的位置往后遍历，直到null停止，并且返回i
for (i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
if (k == null) {
e.value = null;
tab[i] = null;
size--;
} else {
int h = k.threadLocalHashCode & (len - 1);
if (h != i) {
tab[i] = null;
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}
- rehash()。清除所有无效的Entry，并且判断是否需要扩容
private void rehash() {
// 清理所有无效的Entry
expungeStaleEntries();
// 判断是否需要扩容
if (size >= threshold - threshold / 4)
resize();
}
- resize()进入扩容
private void resize() {
Entry[] oldTab = table;
int oldLen = oldTab.length;
int newLen = oldLen * 2;
Entry[] newTab = new Entry[newLen];
int count = 0;
for (int j = 0; j < oldLen; ++j) {
Entry e = oldTab[j];
if (e != null) {
ThreadLocal<?> k = e.get();
if (k == null) {
e.value = null; // Help the GC
} else {
int h = k.threadLocalHashCode & (newLen - 1);
while (newTab[h] != null)
h = nextIndex(h, newLen);
newTab[h] = e;
count++;
}
}
}
// 重新设置负载因子
setThreshold(newLen);
size = count;
table = newTab;
}
扩容逻辑很简单：将容量扩容2倍，将老table的Entry全部迁移到新table【迁移的时候，判断这些Entry是否为有效的，有效的重新rehash存储，无效的直接置为null丢弃】。
get方法
public T get() {
// 获取当前线程
Thread t = Thread.currentThread();
// 获取当前线程的ThreadLocalMap
ThreadLocalMap map = getMap(t);
// 如果map不为null，那么从ThreadLocalMap 里面进行查找
if (map != null) {
// 这里实际上是调用ThreadLocalMap.getEntry方法
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
/*
*如果map为null，那么调用setInitialValue()
*setInitialValue核心：
* 1、调用initialValue()获取初始化值
* 2、如果有设置初始化值，那么则将初始化值放到ThreadLocalMap中，返回初始化值
* 3、如果没有设置，那么调用createMap进行创建ThreadLocalMap，并且返回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;
}
- getEntry()
private Entry getEntry(ThreadLocal<?> key) {
// 根据hashcode计算下标
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
// 如果该Entry的key，是当前ThreadLocal，那么直接返回Entry
if (e != null && e.get() == key)
return e;
else
// 如果该Entry的key，不是当前ThreadLocal，那么需要调用getEntryAfterMiss()
return getEntryAfterMiss(key, i, e);
}
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
// 从i坐标往后继续找，找到直接返回，找不到返回null
while (e != null) {
ThreadLocal<?> k = e.get();
if (k == key)
return e;
if (k == null)
expungeStaleEntry(i);
else
i = nextIndex(i, len);
e = tab[i];
}
return null;
remove方法
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
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;
}
}
}
通过开放地址法找到 key 对应的 entry，调用 clear 方法，将 ThreadLocal 设置为null，调用 expungeStaleEntry 方法，该方法顺便会清理一些 key 为 null 的 entry。
Thread 线程退出时清理 ThreadLocal
Thread 的exit 方法：
private void exit() {
if (group != null) {
group.threadTerminated(this);
group = null;
}
target = null;
threadLocals = null;
inheritableThreadLocals = null;
inheritedAccessControlContext = null;
blocker = null;
uncaughtExceptionHandler = null;
}
可以看到，该方法会将线程相关的所有属性变量全部清除。包括 threadLocals【ThreadLocalMap】。
ThreadLocal使用不当，会造成的Bug
我们设想一种场景，当ThreadLocal和线程池一起使用的时候，我们使用ThreadLocal去存储Product这个对象，当使用完以后没有及时调用ThreadLocal.remove()从当前Thread的ThreadLocalMap里面清除Product，从而线程结束以后重新回到线程池，导致Product对象没有被回收，因为Product还被ThreadLocalMap引用。我们知道当调用ThreadLocal的set、get、remove都会去扫描线程ThreadLocalMap里一些无效的Entry，但是它并不是清除全部的无线Entry，而且如果一直不调用这三个方法，也会导致Product对象一直被ThreadLocalMap引用，从而导致Product对象无法被回收。这也是内存泄露的原因。
解决办法：
1、建议ThreadLocal被static final修饰，防止ThreadLocal被gc回收
2、使用完以后及时remove清除数据
扫一扫
1868
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
