【多线程】ThreadLocal 详解，举例说明

ThreadLocal 是 Java 中的一个线程级别的变量，用于在多线程环境下保持变量的独立性。每个线程都可以独立地设置和获取 ThreadLocal 的值，而不会影响其他线程。通常情况下，ThreadLocal 被用来在方法或类之间传递变量。

1、原理：

ThreadLocal 的实现原理是通过维护一个 Map，其中键为线程 ID，值为变量的值。每个线程都有一个唯一的 ID，通过这个 ID 将变量与线程关联起来。当调用 ThreadLocal 的 get 方法时，会根据当前线程的 ID 获取对应的值。当调用 set 方法时，会根据当前线程的 ID 设置对应的值。

2、为什么使用 ThreadLocal：

• 线程隔离： ThreadLocal 提供了一种线程隔离的机制，使得每个线程都可以拥有自己的变量，互不干扰。
• 避免参数传递： 在多线程环境下，为了传递变量，常常需要在方法之间传递参数。使用 ThreadLocal 可以避免参数传递的繁琐工作，提高代码的简洁性。
• 线程上下文共享： 在某些情况下，需要在多个方法之间共享某个值，但又不希望使用全局变量。ThreadLocal 提供了一种线程级别的共享机制。

3、使用方法：

public class Example {
    private static ThreadLocal<String> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {
        // 在线程中设置值
        threadLocal.set("Hello, ThreadLocal!");

        // 在不同的方法中获取值
        method1();
        method2();
    }

    public static void method1() {
        // 从当前线程获取值
        String value = threadLocal.get();
        System.out.println("Method 1: " + value);
    }

    public static void method2() {
        // 从当前线程获取值
        String value = threadLocal.get();
        System.out.println("Method 2: " + value);
    }
}

需要注意的是，在使用完 ThreadLocal 后，尤其是在线程池等场景，应该及时调用 remove 方法，以避免内存泄漏。可以使用 ThreadLocal.remove() 或者使用 try-with-resources 语句块。

public class Example {
    private static ThreadLocal<String> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {
        try {
            threadLocal.set("Hello, ThreadLocal!");

            // 在不同的方法中获取值
            method1();
            method2();
        } finally {
            // 及时清理 ThreadLocal，避免内存泄漏
            threadLocal.remove();
        }
    }

    // ...
}

在 Java 8 之后， ThreadLocal 还引入了 withInitial 方法，可以在创建 ThreadLocal 实例的同时初始化其值，进一步简化了使用。

3、实例

import java.util.concurrent.atomic.AtomicInteger;

public class ThreadLocalExample {

    private static final ThreadLocal<Integer> threadLocal1 = new ThreadLocal<>();
    private static final ThreadLocal<String> threadLocal2 = new ThreadLocal<>();
    private static final AtomicInteger counter = new AtomicInteger(0);

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            int value = counter.incrementAndGet();
            threadLocal1.set(value);
            threadLocal2.set("Thread " + value);
            printValues("Thread 1");
        });

        Thread thread2 = new Thread(() -> {
            int value = counter.incrementAndGet();
            threadLocal1.set(value);
            threadLocal2.set("Thread " + value);
            printValues("Thread 2");
        });

        thread1.start();
        thread2.start();
    }

    private static void printValues(String threadName) {
        System.out.println(threadName + " - threadLocal1: " + threadLocal1.get());
        System.out.println(threadName + " - threadLocal2: " + threadLocal2.get());
        System.out.println("---");
    }
}

在这个例子中，两个线程分别递增 counter 并将其值设置到两个不同的 ThreadLocal 变量中。通过 printValues 方法打印每个线程的 ThreadLocal 变量值。由于每个线程有自己的 ThreadLocal 副本，它们之间不会互相干扰。
输出：

解释： 在这个代码中，有两个线程：thread1 和 thread2。它们共享一个 counter 变量，并使用 threadLocal1 和 threadLocal2 来存储线程本地的值。
.
thread1 启动，counter 的值为0，counter.incrementAndGet() 将 counter 的值增加为1，然后将1设置到 threadLocal1 和 threadLocal2 中。输出线程1的本地值。
.
thread2 启动，counter 的值为1，counter.incrementAndGet() 将 counter 的值增加为2，然后将2设置到 threadLocal1 和 threadLocal2 中。输出线程2的本地值。
.
因为 ThreadLocal 提供了线程本地的变量副本，所以每个线程都可以独立维护自己的值，互不干扰。这就是为什么输出结果中会有 Thread 1 - threadLocal1: 1 和 Thread 2 - threadLocal1: 2 的原因。
.
输出的顺序可能会有差异，因为线程调度的执行顺序不确定。但是每个线程内部的输出是一致的。