java - Java 的 ThreadLocal 是如何在底层实现的？

Question

ThreadLocal 是如何实现的？它是在 Java 中实现的(使用一些从 ThreadID 到对象的并发映射)，还是使用一些 JVM 钩子(Hook)来更有效地完成它？

Answer 1

这里的所有答案都是正确的，但有点令人失望，因为它们在某种程度上掩盖了 ThreadLocal 的实现是多么聪明。我只是看着 source code for ThreadLocal ，它的实现方式给我留下了深刻的印象。

天真的实现

如果我让你根据 javadoc 中描述的 API 实现一个 ThreadLocal<T> 类，你会怎么做？初始实现可能是使用 ConcurrentHashMap<Thread,T> 作为其键的 Thread.currentThread()。这将工作得相当好，但确实有一些缺点。

线程争用 - ConcurrentHashMap 是一个非常聪明的类，但它最终仍然需要处理防止多个线程以任何方式破坏它，如果不同的线程定期访问它，就会出现减速。

永久保持一个指向线程和对象的指针，即使在线程完成并且可以被 GC 处理之后。

GC 友好的实现

好的，再试一次，让我们使用 weak references 来处理垃圾收集问题。处理 WeakReferences 可能会令人困惑，但使用像这样构建的 map 应该就足够了:

 Collections.synchronizedMap(new WeakHashMap<Thread, T>())

或者，如果我们使用的是 Guava(我们应该是!):

new MapMaker().weakKeys().makeMap()

这意味着一旦没有其他人持有线程(暗示它已完成)，键/值可以被垃圾收集，这是一个改进，但仍然没有解决线程争用问题，这意味着到目前为止我们的 ThreadLocal 还不是全部这么棒的一个类。此外，如果有人决定在 Thread 对象完成后保留它们，它们将永远不会被 GC 处理，因此我们的对象也不会，即使它们现在在技术上无法访问。

聪明的实现

我们一直将 ThreadLocal 视为线程到值的映射，但也许这实际上并不是正确的思考方式。与其将其视为从 Threads 到每个 ThreadLocal 对象中的值的映射，不如将其视为 ThreadLocal 对象到每个 Thread 中的值的映射呢？如果每个线程都存储映射，而 ThreadLocal 只为该映射提供一个很好的接口(interface)，我们就可以避免之前实现的所有问题。

一个实现看起来像这样:

// 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 对象为此 Thread 跟踪的所有值的包私有(private)映射。 ThreadLocalMap 的实现不是 WeakHashMap ，但它遵循相同的基本契约，包括通过弱引用保持其 key 。
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 处理，所有本地对象将被清理。即使 Thread 被保留，ThreadLocal 对象也被弱引用保留，并且可以在 ThreadLocal 对象超出范围时立即清除。

不用说，这个实现给我留下了深刻的印象，它非常优雅地解决了许多并发问题(诚然，通过利用核心 Java 的一部分，但这是可以原谅的，因为它是一个如此聪明的类)并允许快速和对一次只需要由一个线程访问的对象的线程安全访问。

tl;dr ThreadLocal 的实现非常酷，而且比乍一看可能更快/更聪明。

如果您喜欢这个答案，您可能还会欣赏我的(不太详细的) discussion of ThreadLocalRandom 。
Thread/ThreadLocal 代码片段取自 Oracle/OpenJDK's implementation of Java 8 。