目录
1、前言
2、什么是ThreadLocal
3、ThreadLocal作用
4、ThradLocal基本使用
4.1、创建和初始化
4.2、存储和获取线程变量
4.3、清理和释放线程变量
4.4、小结
4.5、示例代码
5、ThreadLocal原理
5.1、set()
5.2、get()
5.3、变量清理
5.4、ThreadLocalMap
6、InheritableThreadLocal
1、前言
一般提到多线程并发总是要说资源竞争，线程安全。而通常保证线程安全的其中一种方式便是控制资源的访问，也就是加锁。其实还有另一种方式，那么便是增加资源来保证所有对象不竞争少数资源。比如，有100个人需要填写信息表，如果只有一只笔，那么要么变成串行，一个一个填写，要么就是我写一半你写一半。那么如果准备100只笔，100个人每个人都有一只笔能够填写信息表，那么就不会出现竞争的情况，也就能顺利的保证信息表的填写。这支笔也就是我们今天要说的ThreadLocal。
2、什么是ThreadLocal
ThreadLocal类是Java中的一个线程局部变量。它的作用是使得每个线程都拥有一个独立的变量副本，每个线程可以对自己的变量副本进行修改，但不会影响到其他线程的变量副本。
也就是说，只有当前线程可以访问，既然只有当前线程可以访问，那就必然是线程安全的。
3、ThreadLocal作用
ThreadLocal的主要作用是在多线程环境下，为每个线程提供一个独立的变量副本，以实现线程间的数据隔离。它具有以下几个常见的用途：
- 线程封闭性：通过将变量存储在ThreadLocal中，可以将其限制在单个线程内部，避免了线程安全性问题。每个线程都可以独立地修改和访问自己的副本，而不会干扰其他线程。
- 线程上下文传递：在某些情况下，需要在线程之间传递上下文信息，例如在Web应用中传递请求信息、用户身份认证等。使用ThreadLocal可以在不修改方法签名的情况下，将上下文信息存储在ThreadLocal中，从而在同一个线程的不同方法中共享这些信息。
- 避免参数传递的开销：在某些场景下，多个方法需要共享相同的数据，如果每次都通过方法参数传递这些数据会增加代码的复杂性和开销。使用ThreadLocal可以避免显式参数传递，将数据存储在ThreadLocal中，使得多个方法可以方便地访问和修改这些数据。
4、ThradLocal基本使用
4.1、创建和初始化
通过ThreadLocal类的构造函数来创建ThreadLocal对象，例如：
ThreadLocal<String> threadLocal = new ThreadLocal<>();在创建ThreadLocal对象后，可以使用set()方法来初始化线程本地变量，例如：
threadLocal.set("Hello, ThreadLocal!");4.2、存储和获取线程变量
存储线程本地变量是通过ThreadLocal对象的set()方法实现的，每个线程都有自己的线程本地变量副本。例如，在一个线程中存储线程本地变量：
threadLocal.set("Value stored in ThreadLocal");可以使用get()方法来获取线程本地变量的值，例如：
String value = threadLocal.get();注意，每个线程都只能访问和修改自己的线程本地变量，而无法直接访问其他线程的副本。这种线程间的数据隔离确保了线程安全性。
4.3、清理和释放线程变量
在使用完线程本地变量后，需要及时清理和释放，以避免内存泄漏和潜在的问题。可以使用ThreadLocal的remove()方法来清理线程本地变量，例如：
threadLocal.remove();另外，为了防止内存泄漏，最好将ThreadLocal对象定义为静态变量，或者使用ThreadLocal的静态工厂方法initialValue()来初始化ThreadLocal对象。这样可以确保在使用完线程本地变量后，及时清理ThreadLocal对象的引用，从而避免对线程的引用导致的内存泄漏。
至于为什么会内存泄露，我们稍后讲到。
4.4、小结
基本使用步骤可以归结为：
- 创建ThreadLocal对象后，使用set()方法存储线程本地变量。
- 使用get()方法获取线程本地变量的值。
- 使用remove()方法清理线程本地变量，避免内存泄漏。
- 将ThreadLocal对象定义为静态变量或使用initialValue()方法来初始化ThreadLocal对象，以避免内存泄漏。
4.5、示例代码
先来看一段代码：
public class ThreadLocalTest {
private static final SimpleDateFormat SIMPLE_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(10);
for (int i = 1; i <= 10; i++) {
executorService.execute(() -> {
Date date = null;
try {
date = SIMPLE_DATE_FORMAT.parse("2023-06-03 10:00:00");
} catch (ParseException e) {
e.printStackTrace();
}
System.out.println(date);
});
}
}
}执行结果：
我们可以看到一些报错，这些报错可能不会复现。原因是SimpleDateFormat并不是线程安全的，因此在线程池中共享这个对象实例必然会有线程安全问题。
那么结合前面介绍的思路，是否可以使用ThreadLocal为每个线程创造一个SimpleDateFormat对象实例，从而解决线程安全问题。
代码：
public class ThreadLocalTest {
// private static final SimpleDateFormat SIMPLE_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 构建ThreadLocal对象
private static ThreadLocal<SimpleDateFormat> formatThreadLocal = new ThreadLocal<>();
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(10);
for (int i = 1; i <= 10; i++) {
executorService.execute(() -> {
Date date = null;
try {
// 如果当前实例不存在，则初始化
if(formatThreadLocal.get() == null){
formatThreadLocal.set(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
}
// 从线程副本中获取SimpleDateFormat对象
date = formatThreadLocal.get().parse("2023-06-03 10:00:00");
} catch (ParseException e) {
e.printStackTrace();
} finally {
// 用完记得销毁
formatThreadLocal.remove();
}
System.out.println(date);
});
}
}
}执行结果：
需要注意的是：上述代码中可以看到，为每一个线程分配一个对象的工作并不是由ThreadLocal完成，而是需要在应用层保证。如果在应用上为每一个线程分配了相同的对象实例，那么ThreadLocal也未必能保证线程安全
5、ThreadLocal原理
要了解ThreadLocal的实现原理，我们主要关注的是set()和get()方法。
5.1、set()
/**
* Sets the current thread's copy of this thread-local variable
* to the specified value. Most subclasses will have no need to
* override this method, relying solely on the {@link #initialValue}
* method to set the values of thread-locals.
*
* @param value the value to be stored in the current thread's copy of
* this thread-local.
*/
public void set(T value) {
// 获取到当前线程
Thread t = Thread.currentThread();
// 从当前线程中获取ThreadLocalMap
ThreadLocalMap map = getMap(t);
if (map != null) {
map.set(this, value);
} else {
createMap(t, value);
}
}
/**
* Get the map associated with a ThreadLocal. Overridden in
* InheritableThreadLocal.
*
* @param t the current thread
* @return the map
*/
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}从源码中可以看到，当进行set时，首先获取的是当前线程对象，然后通过getMap()方法拿到线程中的ThreadLocalMap，并将值存入 ThreadLocalMap 中。而 ThreadLocalMap 可以理解为一个 Map （可以把它简单地理解成 HashMap），但是它是定在 Thread 内部的成员。可以看Thread的源码有这样的一个成员变量定义：
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;而当set操作时，也正是写入了 threadLocals 的这个 Map。其中，key为ThreadLocal当前对象，value 就是我们需要的值（如上面示例代码中的SimpleDateFormat对象实例）。而 threadLocals 本身就保存了当前自己所在线程的所有“局部变量”，也就是一个 ThreadLocal 变量的集合。
5.2、get()
/**
* Returns the value in the current thread's copy of this
* thread-local variable. If the variable has no value for the
* current thread, it is first initialized to the value returned
* by an invocation of the {@link #initialValue} method.
*
* @return the current thread's value of this thread-local
*/
public T get() {
// 获取当前线程
Thread t = Thread.currentThread();
// 当前线程中获取map
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();
}相应的，get()操作便是从这个Map中获取数据。当get()操作时，先获取当前线程的ThreadLocalMap对象，然后通过自己作为key取得内部的实际数据。
5.3、变量清理
前面我们说到，ThreadLocal这些变量是维护在Thread内部的，这也意味着只要线程不退出，这些对象的引用将一直存在。
当线程退出时，Thread类会进行清理工作，其中就包含了ThreadLocalMap的清理：
/**
* This method is called by the system to give a Thread
* a chance to clean up before it actually exits.
*/
private void exit() {
if (threadLocals != null && TerminatingThreadLocal.REGISTRY.isPresent()) {
TerminatingThreadLocal.threadTerminated();
}
if (group != null) {
group.threadTerminated(this);
group = null;
}
/* Aggressively null out all reference fields: see bug 4006245 */
target = null;
/* Speed the release of some of these resources */
// 这里清理了threadlocalMap
threadLocals = null;
inheritableThreadLocals = null;
inheritedAccessControlContext = null;
blocker = null;
uncaughtExceptionHandler = null;
}当使用线程池的时候，就意味着线程未必会退出（如固定大小线程池，线程总是存在）。如果这样，将一些大的对象设置到ThreadLocal中（因为实际保存在线程持有的ThreadLocalMap中），可能会导致内存泄露。
因此，在使用ThreadLocal时，最好使用ThreadLocal.remove()将其变量移除。
5.4、ThreadLocalMap
前面我们说过，ThreadLocal其实就是将变量存在了ThreadLocalMap中，而ThreadLocalMap是一个类似HashMap的集合，更准确的说，其实是类似WeakHashMap类。
ThreadLocalMap的实现使用了弱引用。JVM虚拟机在GC时，如果发现有弱引用，会立即回收。ThreadLocalMap内部由一系列Entry构成，每个Entry都是WeakReference。
这里的参数k就是Map的key，v就是Map的value。其中k也是ThreadLocal实例，作为弱引用使用。因此这里虽然使用了ThreadLocal作为Map的key，但实际上他并不真的持有ThreadLocal引用。而当ThreadLocal的外部强引用被回收时，ThreadLocalMap中的key就会变成null。当系统对ThreadLocalMap清理时，就会将这些垃圾数据进行回收。
而正因为是弱引用，就导致了 ThreadLocal在没有外部强引用时，发生GC时会被回收，如果创建ThreadLocal的线程一直持续运行，那么这个Entry对象中的value就有可能一直得不到回收，发生内存泄露。
解决内存泄露的方法就是：在使用完之后即使的调用remove()清理掉他。
6、InheritableThreadLocal
ThreadLocal是让每个线程的读取ThreadLocal的变量都是独立的。那既然是这样的话，自然的线程间通信就成了问题。比如子线程需要读取父线程的变量：
public static void main(String[] args) {
ThreadLocal<String> threadLocal = new ThreadLocal<>();
threadLocal.set("Hello, InheritableThreadLocal!");
Thread thread = new Thread(() -> {
String value = threadLocal.get();
System.out.println("Value in child thread: " + value);
});
thread.start();
}执行结果：
显然子线程获取到的是null。
使用InheritableThreadLocal：
public static void main(String[] args) {
InheritableThreadLocal<String> inheritableThreadLocal = new InheritableThreadLocal<>();
inheritableThreadLocal.set("Hello, InheritableThreadLocal!");
Thread thread = new Thread(() -> {
String value = inheritableThreadLocal.get();
System.out.println("Value in child thread: " + value);
});
thread.start();
}执行结果：
我们可以看到子线程已经正常获取到父线程的变量。
InheritableThreadLocal通过在子线程创建时，将父线程的线程本地变量副本复制到子线程中，实现了父线程与子线程之间线程本地变量的传递。这种特性对于一些场景非常有用，例如在父线程中设置一些上下文信息，然后在子线程中继续使用这些上下文信息。
使用InheritableThreadLocal的步骤与ThreadLocal类似。可以通过InheritableThreadLocal类的构造函数创建InheritableThreadLocal对象，然后使用set()方法设置线程本地变量，使用get()方法获取线程本地变量。子线程可以继承父线程的InheritableThreadLocal变量副本，而无需显式传递。
需要注意的是，虽然InheritableThreadLocal可以实现父子线程之间的线程本地变量传递，但它也有一些潜在的问题，比如可能增加线程间的耦合性和复杂性，以及对于线程池中的线程可能导致意外的结果。因此，在使用InheritableThreadLocal时，需要谨慎考虑使用场景和潜在的影响。
