2. 并发编程之ThreadLocal详解

西红柿幼儿园园长
289 阅读4分钟

ThreadLocal原理概述

ThreadLocal是Java中提供的一种线程局部变量。其核心思想是在每个线程中创建一个单独的变量副本，使得每个线程都可以独立地改变自己的副本，而不会影响其他线程。ThreadLocal的实现基于内部类ThreadLocalMap，这是一个定制化的哈希映射，键为ThreadLocal实例本身，值为线程局部变量的值。

关键方法解析

  1. get() :

    • 功能: 返回当前线程对应的ThreadLocal变量的值。如果当前线程没有此ThreadLocal变量的值，则会调用initialValue()方法进行初始化。

      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();
}

  2. set(T value) :

    • 功能: 将当前线程的ThreadLocal变量设置为指定的值。

      Java
public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

  3. remove() :

    • 功能: 移除当前线程的ThreadLocal变量。这有助于避免内存泄漏。

      Java
public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        m.remove(this);
}

  4. initialValue() :

    • 功能: 返回当前线程的ThreadLocal变量的初始值。默认实现返回null，子类可以覆盖此方法以提供特定的初始值。

      Java
protected T initialValue() {
    return null;
}

实现细节

  • ThreadLocalMap: 每个线程的Thread类实例中有一个ThreadLocalMap字段，用于存储线程局部变量。键为ThreadLocal实例，值为线程局部变量的值。

  • 内存泄漏风险: 如果ThreadLocal实例不再被任何线程引用，但线程的ThreadLocalMap中仍然保持对该ThreadLocal的引用，就可能导致内存泄漏。因此，使用完ThreadLocal后应调用remove()方法清理。

  • 弱引用问题: ThreadLocalMap中的键（即ThreadLocal实例）最初使用弱引用实现，但在Java 8中改为了直接引用，以减少由于GC导致的不必要的清除操作。不过，这进一步加大了开发者需要手动管理ThreadLocal生命周期以防止内存泄漏的责任。

    public class ThreadLocalExample {
    // 创建一个ThreadLocal实例
    private static final ThreadLocal<String> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {
        // 在主线程中设置ThreadLocal变量
        threadLocal.set("Main Thread Value");

        // 新建一个子线程
        Thread thread = new Thread(() -> {
            // 子线程尝试获取ThreadLocal变量
            System.out.println("ThreadLocal in child thread before setting: " + threadLocal.get());

            // 设置子线程的ThreadLocal变量
            threadLocal.set("Child Thread Value");
            System.out.println("ThreadLocal in child thread after setting: " + threadLocal.get());
        });

        // 输出主线程中的ThreadLocal变量
        System.out.println("ThreadLocal in main thread: " + threadLocal.get());

        // 启动子线程
        thread.start();

        // 主线程再次获取ThreadLocal变量，显示未受子线程影响
        System.out.println("ThreadLocal in main thread again: " + threadLocal.get());
    }
}

Java8与Java8之前的引用方式

  • 在Java 8之前的版本中，ThreadLocalMap中的键（即ThreadLocal实例）是作为弱引用（WeakReference）存储的。这意味着，一旦ThreadLocal实例外部没有任何强引用指向它，垃圾回收器（GC）就有机会回收这个ThreadLocal实例，进而使得ThreadLocalMap中的对应条目变为无效（key为null）。为了清理这些无效条目，ThreadLocalMap维护了一个引用队列（ReferenceQueue），并与这些弱引用关联。当GC回收ThreadLocal实例时，会将弱引用放入这个引用队列，然后在某些操作时检查这个队列并清理无效的条目。

  • 在Java 8中，这一策略发生了变化，主要是出于性能考虑。为了避免频繁的清理操作以及减少因GC引起的延迟，ThreadLocalMap中的键从弱引用改为了直接引用。这意味着，即使外部不再有对ThreadLocal实例的引用，只要线程活着且ThreadLocalMap中还存有对该实例的引用，ThreadLocal实例就不会被垃圾回收，这可能增加内存泄漏的风险。

  • 这一改动要求开发者更加注意ThreadLocal的生命周期管理，主动调用ThreadLocal#remove()方法来显式地移除不再使用的ThreadLocal变量，以避免潜在的内存泄漏问题。这是因为直接引用使得ThreadLocal实例的生命周期与线程或ThreadLocalMap的生命周期绑定得更紧密了。

Java 8之前（伪代码表示）：

    ```
    Java
    class ThreadLocalMap {
        Entry[] table;

        static class Entry extends WeakReference<ThreadLocal<?>> {
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k, queue); // 使用弱引用，并关联到引用队列
                value = v;
            }
        }

        // 定期检查引用队列，清理无效条目
        void maintain() {
            // 检查引用队列，清理key为null的条目
        }
    }
    ```

Java 8及之后（伪代码表示）：

Java
class ThreadLocalMap {
    Entry[] table;
    
    static class Entry {
        ThreadLocal<?> k;
        Object value;
        
        Entry(ThreadLocal<?> k, Object v) {
            this.k = k; // 直接引用
            value = v;
        }
    }
    
    // 不再需要定期检查引用队列，因为没有弱引用
}

存在的问题

  • 内存泄漏: 不恰当的使用可能导致内存泄漏，特别是当线程长时间存活且ThreadLocal不再使用但未被清理时。
  • 使用复杂度: 虽然提供了线程安全，但如果使用不当，如忘记清理ThreadLocal实例，可能会引入难以追踪的错误。

总结

ThreadLocal通过为每个线程提供独立的变量副本，简化了多线程程序中对某些变量的管理。然而，其使用需要谨慎，以避免潜在的内存泄漏问题，尤其是在长时间运行的服务中。开发者应当养成在不再需要ThreadLocal变量时主动调用remove()方法的习惯。

avatar
文章
阅读
粉丝