ThreadLocal 是如何实现的？它是用 Java 实现的（使用一些从 ThreadID 到对象的并发映射），还是使用一些 JVM 挂钩来更有效地完成它？
问问题
15237 次
5 回答
123
这里的所有答案都是正确的，但有点令人失望，因为它们在某种程度上掩盖了ThreadLocal的实现有多聪明。我只是在查看源代码，ThreadLocal并对其实现方式印象深刻。
天真的实现
如果我要求你根据 javadoc 中描述的 API 实现一个ThreadLocal<T>类，你会怎么做？最初的实现可能是ConcurrentHashMap<Thread,T>使用Thread.currentThread()作为它的关键。这将工作得相当好，但确实有一些缺点。
- 线程争用 -
ConcurrentHashMap是一个非常聪明的类，但它最终仍然必须处理防止多个线程以任何方式与它发生冲突，并且如果不同的线程定期命中它，将会出现减速。 - 永久保留指向 Thread 和对象的指针，即使在 Thread 完成并可能被 GC 之后也是如此。
GC 友好的实现
好的再试一次，让我们通过使用弱引用来处理垃圾收集问题。处理 WeakReferences 可能会令人困惑，但使用这样构建的地图就足够了：
Collections.synchronizedMap(new WeakHashMap<Thread, T>())
或者如果我们使用番石榴（我们应该这样做！）：
new MapMaker().weakKeys().makeMap()
这意味着一旦没有其他人持有线程（暗示它已经完成），键/值可以被垃圾收集，这是一种改进，但仍然没有解决线程争用问题，这意味着到目前为止我们ThreadLocal还不是全部很棒的一堂课。此外，如果有人在完成后决定保留Thread对象，它们将永远不会被 GC，因此我们的对象也不会被 GC，即使它们现在在技术上无法访问。
巧妙的实现
我们一直在考虑ThreadLocal将线程映射到值，但也许这实际上并不是正确的思考方式。与其将其视为从 Threads 到每个 ThreadLocal 对象中的值的映射，不如将其视为 ThreadLocal 对象到每个 Thread中的值的映射呢？如果每个线程都存储映射，而 ThreadLocal 只是为该映射提供了一个很好的接口，我们可以避免之前实现的所有问题。
一个实现看起来像这样：
// called for each thread, and updated by the ThreadLocal instance
new WeakHashMap<ThreadLocal,T>()
这里无需担心并发性，因为只有一个线程会访问此映射。
Java 开发人员在这里比我们有一个主要优势——他们可以直接开发 Thread 类并向其添加字段和操作，而这正是他们所做的。
里面有java.lang.Thread以下几行：
/* ThreadLocal values pertaining to this thread. This map is maintained * by the ThreadLocal class. */ ThreadLocal.ThreadLocalMap threadLocals = null;
正如评论所暗示的那样，这确实是ThreadLocal对象跟踪的所有值的包私有映射 this Thread。的实现ThreadLocalMap不是 a WeakHashMap，但它遵循相同的基本契约，包括通过弱引用来持有它的密钥。
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; } } return setInitialValue(); }
ThreadLocal.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; }
本质上，在这个线程中使用一个映射来保存我们所有的ThreadLocal对象。这样，我们就不必担心其他线程中的值（ThreadLocal实际上只能访问当前线程中的值），因此不会出现并发问题。此外，一旦Thread完成，它的映射将自动被 GC'ed 并且所有本地对象都将被清理。即使Thread被持有，ThreadLocal对象也被弱引用持有，并且一旦ThreadLocal对象超出范围就可以被清理。
不用说，这个实现给我留下了深刻的印象，它非常优雅地解决了很多并发问题（诚然，通过利用作为核心 Java 的一部分，但这是可以原谅的，因为它是一个非常聪明的类）并且允许快速和对一次只需要由一个线程访问的对象的线程安全访问。
tl;dr ThreadLocal的实现非常酷，而且比您乍看之下想象的要快/智能得多。
如果您喜欢这个答案，您可能还会欣赏我对ThreadLocalRandom.
Thread/ThreadLocal取自Oracle/OpenJDK 的 Java 8 实现的代码片段。
于 2013-03-27T06:25:53.730 回答
33
你的意思是java.lang.ThreadLocal。这很简单，真的，它只是存储在每个Thread对象中的名称-值对的映射（参见Thread.threadLocals字段）。API 隐藏了实现细节，但这或多或少是它的全部。
于 2009-07-29T19:20:58.277 回答
8
Java 中的 ThreadLocal 变量通过访问 Thread.currentThread() 实例持有的 HashMap 来工作。
于 2009-07-29T19:20:58.027 回答
4
假设您要实现ThreadLocal，如何使其特定于线程？当然最简单的方法是在 Thread 类中创建一个非静态字段，我们称之为threadLocals. 因为每个线程都由一个线程实例表示，所以threadLocals在每个线程中也会有所不同。这也是 Java 所做的：
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
这是什么ThreadLocal.ThreadLocalMap？因为您只有threadLocals一个线程，所以如果您只是将threadLocals其作为您的ThreadLocal（例如，将 threadLocals 定义为Integer），那么您将只有一个ThreadLocal用于特定线程。如果你想要ThreadLocal一个线程有多个变量怎么办？最简单的方法是制作threadLocals一个HashMap，key每个条目的 是ThreadLocal变量的名称，value每个条目的 是ThreadLocal变量的值。有点混乱？假设我们有两个线程，t1并且t2. 它们采用相同的Runnable实例作为Thread构造函数的参数，并且它们都有两个ThreadLocal名为tlA和的变量tlb。这就是它的样子。
t1.tlA
+-----+-------+
| Key | Value |
+-----+-------+
| tlA | 0 |
| tlB | 1 |
+-----+-------+
t2.tlB
+-----+-------+
| Key | Value |
+-----+-------+
| tlA | 2 |
| tlB | 3 |
+-----+-------+
请注意，这些值是由我组成的。
现在看起来很完美。但什么是ThreadLocal.ThreadLocalMap？为什么不直接使用HashMap？为了解决这个问题，让我们看看当我们通过类的set(T value)方法设置一个值时会发生什么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(t)简单地返回t.threadLocals。因为t.threadLocals被初始化为null，所以我们先进入createMap(t, value)：
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
ThreadLocalMap它使用当前ThreadLocal实例和要设置的值创建一个新实例。让我们看看是什么ThreadLocalMap样的，它实际上是ThreadLocal类的一部分
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;
}
}
...
/**
* Construct a new map initially containing (firstKey, firstValue).
* ThreadLocalMaps are constructed lazily, so we only create
* one when we have at least one entry to put in it.
*/
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是Entry class扩展了WeakReference. 它确保如果当前线程退出，它将自动被垃圾收集。这就是为什么它使用ThreadLocalMap而不是简单的HashMap. 它将当前ThreadLocal及其值作为Entry类的参数传递，所以当我们想要获取值时，我们可以从类table的实例中获取它Entry：
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();
}
整个画面是这样的：
于 2015-11-12T16:23:39.617 回答
-2
从概念上讲，您可以将 aThreadLocal<T>视为Map<Thread,T>存储线程特定值的 a，尽管这不是它的实际实现方式。
线程特定的值存储在 Thread 对象本身中；当线程终止时，线程特定的值可以被垃圾收集。
参考：JCIP
于 2017-11-29T21:41:48.353 回答