本文探讨了Java中的ThreadLocal如何通过线程本地存储实现数据隔离，讲解了ThreadLocalMap的工作原理，包括弱引用、数组扩容和hash运算，以及它在多线程中的应用和内存管理策略。
背景
在多线程中，我们需要对同一资源进行访问，为了保证线程安全，我们通常需要通过加锁等方式来保证线程安全。
在JAVA JDK中，它提供线程本地线程ThreadLocal变量，起到了线程隔离的作用。访问这个变量的每个线程都会有这个变量的一个副本，在实际多线程操作的时候，操作的是自己本地内存中的变量，从而规避了线程安全问题。
加锁用于线程间的数据共享，而ThreadLocal则用于线程间的数据隔离。
那么，我们本篇文章就来带大家一起研究下其工作原理。
使用
在开始之前，我们先来看一下ThreadLoacal是怎么使用的。
public class MyTest {
static final ThreadLocal<String> threadlocal = new ThreadLocal<String>();
public static void main(String[] args) {
threadlocal.set("test");
System.out.printf(threadlocal.get());
}
}
threadlocal而是一个线程内部的存储类，可以在指定线程内存储数据，数据存储以后，只有指定线程可以得到存储数据。
源码剖析
set方法
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
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;
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
我们可以看到，ThreadLocal内部其实是维护了一个ThreadLocalMap，每个线程持有一个ThreadLocalMap对象。每一个新的线程Thread都会实例化一个ThreadLocalMap并赋值给成员变量threadLocals，使用时若已经存在threadLocals则直接使用已经存在的对象。
ThreadLocalMap
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;
}
}
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);
}
}
在这里，我们将ThreadLocalMap的关键代码抽了出来，可以看到：
- ThreadLocalMap是ThreadLocal的静态内部类(静态内部类实例化后不共享哦，所以每个线程有自己的ThreadLocalMap实例)。
- ThreadLocalMap的Entry对象(即存储的本地变量)是一个弱引用。弱引用的作用在前面文章已经提过，在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存，能够很好的解决内存泄漏的问题。
- 化ThreadLocalMap时创建了一个Entry数组(初始长度为16)，通过hashCode与length位运算确定出一个索引值i，这个i就是被存储在table数组中的位置，所以说，其实ThreadLocal其实将变量存储在一个数组中，通过操纵这个数组来写入或获取本地变量。
ThreadLocalMap的set方法
通过看ThreadLocal的set方法，我们知道其真实调用的是ThreadLocalMap的set方法，所以直接上ThreadLocalMap的代码
//ThreadLocalMap中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);
//遍历tab如果已经存在则更新值
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;
//满足条件数组扩容x2
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
可以看到：
- 通过计算当前线程的hash值与entry数组的长度进行位运算得到数组下标index。
- 拿着数组小标去取entry[index]，如果entry[index]==null，则直接赋值，如果不为空，则index+1，知道找到可以为Null的entry对象，然后赋值。
这里你也许会有疑问，如果我都写满了怎么办？
调用ThreadLocalMap对象的set方法时，它会根据需求进行扩容的。代码送上，有兴趣的小伙伴可以看看。
private ThreadLocalMap(ThreadLocalMap parentMap) {
Entry[] parentTable = parentMap.table;
int len = parentTable.length;
setThreshold(len);
table = new Entry[len];
for (int j = 0; j < len; j++) {
Entry e = parentTable[j];
if (e != null) {
@SuppressWarnings("unchecked")
ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
if (key != null) {
Object value = key.childValue(e.value);
Entry c = new Entry(key, value);
int h = key.threadLocalHashCode & (len - 1);
while (table[h] != null)
h = nextIndex(h, len);
table[h] = c;
size++;
}
}
}
}
get方法
理解了set方法，那么get方法就so easy了，它其实就是你逆向操作，根据线程的Hash值，从ThreadLocalMap中将对应的值取出来即可。
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;
}
}
行到此处，threadLocals为null，调用该更改初始化当前线程的threadLocals变量
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;
}
protected T initialValue() {
return null;
}
在get方法的实现中，首先获取当前调用者线程，如果当前线程的threadLocals不为null，就直接调用ThreadLocalMap的getEntry获取本地变量值，如下代码。
否则，如果ThreadLocalMap还未初始化，则执行setInitialValue方法初始化threadLocals变量。在setInitialValue方法中，类似于set方法的实现，都是判断当前线程的threadLocals变量是否为null，是则添加本地变量（这个时候由于是初始化，所以添加的值为null），否则创建threadLocals变量，同样添加的值为null。
ThreadLocalMap的get方法
//ThreadLocalMap中getEntry方法
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);
}
这里无非就是根据线程的hash值与数组大小进行位运算，找到对应的数组下标index，然后取出entry[index]返回给当前线程。
总结
ThreadLocal实现主要涉及Thread，ThreadLocal，ThreadLocalMap这三个类。
除此之外，它涉及到几个重要的知识点：
- ThreadLocalMap的Entry对象(即存储的本地变量)是一个弱引用。通过弱引用，可以很好地解决内存泄漏的问题。
- 与sychronized不同，它为了保证线程安全，采取的策略是通过每个线程单独一份存储空间，牺牲空间来解决冲突。而sychronized是通过锁等待来实现，有更多是时间消耗
- 可以用于实现单例模式，这个在单例模式中有介绍到。
- ThreadLocalMap的hash运算其实是利用了斐波那契散列乘数，它的优点是可以将hash值分布的非常均匀，很好的避免hash冲突，有兴趣的小伙伴可以再深入研究一下。
扫一扫
827
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
