构建无锁的线程安全架构：掌握Java中ThreadLocal的原理灵活应用

柔情只为你懂 2023-10-12 20:39 28阅读 0赞

ThreadLocal 是 Java 提供的一个线程级别的变量存储工具，它允许每个线程都有自己独立的变量副本，每个线程可以独立地操作自己的变量副本，互不干扰。本文将详细介绍 ThreadLocal 的原理和使用场景，并通过代码示例进行讲解。

# 一、ThreadLocal 的原理 #

# 1.1 概述 #

ThreadLocal 提供了一种简单的方式来实现线程封闭（Thread confinement），即将数据与线程关联起来，确保每个线程都拥有自己独立的数据副本，从而避免线程安全问题。在多线程环境下，使用 ThreadLocal 可以方便地实现线程间的数据隔离，保证每个线程都能够访问到自己的数据。

# 1.2 数据结构 #

ThreadLocal 内部通过一个特殊的数据结构来存储每个线程的变量副本，这个数据结构被称为 ThreadLocalMap。每个 ThreadLocal 对象作为 key，对应一个 value，表示该线程的变量副本。ThreadLocalMap 是 ThreadLocal 类的一个内部静态类，用于存储线程的局部变量。

**ThreadLocal 是线程共享变量。ThreadLoacl 有一个静态内部类 ThreadLocalMap，其 Key 是 ThreadLocal 对象，值是 Entry 对象，ThreadLocalMap是每个线程私有的。**

*  set 给ThreadLocalMap设置值。
 *  get 获取ThreadLocalMap。
 *  remove 删除ThreadLocalMap类型的对象。

# 1.3 实现原理 #

ThreadLocal 的实现原理可以简单概括为以下几个步骤：

1.  在每个线程内部创建一个 ThreadLocalMap 对象，用于存储线程的变量副本。
2.  在需要使用线程局部变量的地方，通过 get() 方法获取当前线程对应的 ThreadLocalMap 对象。
3.  在 ThreadLocalMap 中以当前 ThreadLocal 对象作为 key，获取或设置变量副本。

具体流程如下图所示：

![format_png][]

简单描述也就是这样：

css复制代码main Thread:          Thread1:                        Thread2:
    ┌─────────┐          ┌─────────┐       ┌─────────┐    ┌─────────┐
    │ Thread  │          │ Thread  │       │ Thread  │    │ Thread  │
    ├─────────┤          ├─────────┤       ├─────────┤    ├─────────┤
    │         ├──┐       │         ├──┐    │         ├───>│         │
    └─────────┘  │       └─────────┘  │    └─────────┘    └─────────┘
                 │                    │
         get()   │     set("Data1")   │
       ┌──────────┼──────────────────┼───────────────────┐
       │          │                  │                   │
    ┌───────────┐  │    ┌───────────┐ │    ┌───────────┐  │
    │ ThreadMap │  │    │ ThreadMap │ │    │ ThreadMap │  │
    ├───────────┤  │    ├───────────┤ │    ├───────────┤  │
    │ ThreadMap ├──┼───>│ ThreadMap ├──┼───>│ ThreadMap │  │
    └───────────┘  │    └───────────┘ │    └───────────┘  │
                   │                  │                   │
               ┌───────────┐      ┌───────────┐       ┌───────────┐
               │ ThreadLocal1 │      │ ThreadLocal1 │       │ ThreadLocal1 │
               ├───────────┤      ├───────────┤       ├───────────┤
               │     Data1     │      │     Data2     │       │     Data3  │
               └───────────┘      └───────────┘       └───────────┘

# 二、ThreadLocal 的使用场景 #

# 2.1 线程安全问题 #

在多线程环境中，多个线程访问共享数据时可能出现线程安全问题，例如数据被意外修改、并发写入等。此时，可以使用 ThreadLocal 将数据与线程关联起来，确保每个线程都操作自己的数据副本，从而避免线程安全问题。

# 2.2 传递上下文信息 #

在一些需要跨层传递上下文信息的场景下，使用 ThreadLocal 可以简化代码实现。例如，在 Web 应用中，用户的登录信息通常需要在多个组件间传递，可以使用 ThreadLocal 来存储用户登录信息，每个组件获取登录信息时直接从 ThreadLocal 中获取，避免了繁琐的参数传递过程。

# 2.3 数据库连接管理 #

在使用数据库连接池时，每个线程从连接池中获取连接执行数据库操作，并在处理完毕后将连接释放到连接池中。此时，可以使用 ThreadLocal 来管理数据库连接，确保每个线程都使用自己独立的连接，避免多线程并发访问同一个连接引发的问题。

# 2.4 其他应用场景 #

除了上述场景，ThreadLocal 还可以用于实现定制化的线程封闭策略，例如在线程池中复用线程时，通过使用 ThreadLocal 可以隔离线程之间的数据。

总的概括就是：

（1）每个线程需要有自己单独的实例

（2）实例需要在多个方法中共享，但不希望被多线程共享

# 三、ThreadLocal 的使用方式 #

下面举几个具体的例子来演示 ThreadLocal 的使用方式。

# 3.1 示例一：传递用户信息 #

假设有一个 Web 应用，需要在不同层级的组件中传递用户的登录信息。首先，我们定义一个包含用户信息的类 User：

java复制代码public class User {
        private String username;
        // ...
        
        // 构造方法和getter/setter 省略
    }

接下来，在一个拦截用户请求的过滤器中，将用户信息存储到 ThreadLocal 中：

java复制代码public class UserFilter implements Filter {
 private static final ThreadLocal<User> userThreadLocal = new ThreadLocal<>();
 
 @Override
 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
 throws IOException, ServletException {
 // 从请求中获取用户信息
 User user = extractUserFromRequest(request);
 
 // 将用户信息存储到 ThreadLocal 中
 userThreadLocal.set(user);
 
 try {
 chain.doFilter(request, response);
 } finally {
 // 请求处理完毕后清除 ThreadLocal 中的数据
 userThreadLocal.remove();
 }
 }
 
 private User extractUserFromRequest(ServletRequest request) {
 // 从请求中提取用户信息
 // ...
 return new User("Alice");
 }
 }

在其他组件中，可以通过 ThreadLocal 获取当前线程对应的用户信息：

java复制代码public class SomeComponent {
        public void doSomething() {
            User user = UserFilter.userThreadLocal.get();
            // 使用用户信息进行操作
            // ...
        }
    }

在上述示例中，通过 ThreadLocal 将用户信息存储在不同的线程中，避免了在不同组件间传递参数的麻烦，实现了上下文信息的传递。

# 3.2 示例二：数据库连接管理 #

在一个多线程的数据库访问场景中，使用 ThreadLocal 可以实现每个线程使用自己的数据库连接，封装数据库连接的获取和释放过程。

首先，定义一个数据库连接管理类：

java复制代码public class ConnectionManager {
 private static final ThreadLocal<Connection> connectionThreadLocal = new ThreadLocal<>();
 
 public static Connection getConnection() {
 Connection connection = connectionThreadLocal.get();
 if (connection == null) {
 // 创建新的数据库连接
 connection = createConnection();
 connectionThreadLocal.set(connection);
 }
 return connection;
 }
 
 public static void releaseConnection() {
 Connection connection = connectionThreadLocal.get();
 if (connection != null) {
 // 关闭数据库连接
 closeConnection(connection);
 connectionThreadLocal.remove();
 }
 }
 
 private static Connection createConnection() {
 // 创建数据库连接
 // ...
 return new Connection();
 }
 
 private static void closeConnection(Connection connection) {
 // 关闭数据库连接
 // ...
 }
 }

然后，在数据库访问的代码中，通过 ConnectionManager 来获取和释放数据库连接：

java复制代码public class UserDao {
        public void save(User user) {
            Connection connection = ConnectionManager.getConnection();
            try {
                // 使用数据库连接进行数据保存操作
                // ...
            } finally {
                ConnectionManager.releaseConnection();
            }
        }
    }

在上述示例中，每个线程都会通过 ThreadLocal 存储自己的数据库连接，避免了多线程并发访问同一个连接引发的问题。

# 四、存在的问题 #

ThreadLocal 存在的问题以及解决方法：

# 4.1 内存泄漏问题 #

ThreadLocal 的内部实现是通过 ThreadLocalMap 来维护每个线程的局部变量，并且 ThreadLocalMap 中的 Entry 对象使用弱引用来引用 ThreadLocal 对象。这就意味着，在没有其他强引用指向 ThreadLocal 对象时，ThreadLocal 对象可能被垃圾回收器回收，而相应的线程局部变量的值仍然保留在 ThreadLocalMap 中，从而导致内存泄漏问题。

**解决方法：** 为了避免内存泄漏，需要在使用完 ThreadLocal 后手动调用 remove() 方法清理对应的线程局部变量。通常可以通过在 finally 块中进行清理操作，以确保即使发生异常，也能正确清理 ThreadLocal。下面是一个示例代码：

java复制代码class MyThreadLocalExample {
 private static ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
 
 public static void main(String[] args) {
 try {
 // 设置线程局部变量的值
 threadLocal.set(123);
 
 // 执行业务逻辑...
 } finally {
 // 清理线程局部变量
 threadLocal.remove();
 }
 }
 }

# 4.2 线程复用时的数据共享问题 #

在线程池等多线程复用的场景中，通过 ThreadLocal 存储的线程局部变量可能会被 “复用” 给其他线程使用，从而导致数据共享问题。也就是说，在某些情况下，多个线程共享同一个 ThreadLocal 的值，这不符合我们使用 ThreadLocal 的初衷。

**解决方法：** 对于线程池等多线程复用的场景，可以考虑使用 InheritableThreadLocal 来解决数据共享问题。InheritableThreadLocal 是 ThreadLocal 的一个子类，它允许子线程从父线程中继承线程局部变量的值。下面是一个简单的示例代码：

java复制代码class MyInheritableThreadLocalExample {
 private static ThreadLocal<Integer> threadLocal = new InheritableThreadLocal<>();
 
 public static void main(String[] args) {
 // 设置线程局部变量的值
 threadLocal.set(123);
 
 // 创建子线程并执行任务
 Thread childThread = new Thread(() -> {
 // 子线程可以继承父线程的线程局部变量的值
 int value = threadLocal.get();
 System.out.println("子线程获取到的值：" + value);
 });
 childThread.start();
 }
 }

# 4.3 使用 ThreadLocal 的弱引用 #

在一些场景下，我们不希望 ThreadLocal 对象长期持有对线程局部变量的引用，以避免潜在的内存泄漏问题。可以使用 WeakReference 或者自定义的 WeakThreadLocal 来实现 ThreadLocal 的弱引用版本。这样，在没有其他强引用指向 ThreadLocal 对象时，ThreadLocal 对象就可以被垃圾回收。

**解决方法：** 下面是一个解决方法的demo代码，展示如何使用 WeakReference 来实现 ThreadLocal 的弱引用版本：

java复制代码class MyWeakThreadLocalExample {
 private static ThreadLocal<WeakReference<Integer>> threadLocal = new ThreadLocal<>();
 
 public static void main(String[] args) {
 // 设置线程局部变量的值
 threadLocal.set(new WeakReference<>(123));
 
 // 业务逻辑...
 
 // 获取线程局部变量的值
 WeakReference<Integer> reference = threadLocal.get();
 Integer value = reference.get();
 System.out.println("线程局部变量的值：" + value);
 }
 }

通过及时清理 ThreadLocal、使用 InheritableThreadLocal 或者使用 ThreadLocal 的弱引用，可以解决 ThreadLocal 存在的问题，并保证线程安全和正确性。应根据具体场景选择合适的解决方法。

# 五、ThreadLocal和Synchronized的区别 #

很多同学分不清：ThreadLocal和Synchronized这两种Java多线程编程中用于实现线程安全的两种机制。也不太明白如何去用它们。下面我简单归纳一下吧，它们在实现方式、适用场景和效果上确实是有一些区别的。

（1）实现方式：

*  ThreadLocal：ThreadLocal是一种基于线程的局部变量实现机制。每个线程都有自己独立的ThreadLocal实例，并且每个线程可以访问各自的ThreadLocal实例，线程之间的变量互不干扰。ThreadLocal内部使用一个Map结构，在每个线程内部维护一个变量副本。
 *  Synchronized：Synchronized是通过互斥锁（也称为监视器锁）来实现线程安全的。当一个线程获取到锁时，其他线程需要等待，直到持有锁的线程释放锁才能执行相应的代码块。

（2）适用场景：

*  ThreadLocal：ThreadLocal适用于需要在线程之间隔离数据的场景，每个线程可以独立地操作自己的变量副本。常见的使用场景包括Web应用程序的请求处理、数据库事务管理等。
 *  Synchronized：Synchronized适用于多个线程共享同一个资源的场景，需要确保在同一时间只有一个线程访问共享资源，从而避免数据竞争和不一致性。常见的使用场景包括共享数据的读写、临界区的保护等。

（3）效果：

*  ThreadLocal：通过ThreadLocal可以实现线程间的数据隔离，每个线程都有自己独立的变量副本，并且修改不会影响其他线程。这样可以避免使用锁带来的开销，提高并发性能。但需要注意合理管理ThreadLocal实例，避免内存泄漏。
 *  Synchronized：使用Synchronized可以保证线程安全，确保共享资源在同一时间只能被一个线程访问，从而避免数据竞争和不一致性。Synchronized通过获取锁来控制对共享资源的访问，保证了线程安全。但是，使用锁会引入额外的开销，并且当多个线程竞争同一个锁时，可能会导致线程阻塞和性能下降。

以下是ThreadLocal和Synchronized的对比情况：

<table> 
 <tbody> 
 <tr> 
 <td> 比较类型 </td> 
 <td> ThreadLocal </td> 
 <td> Synchronized </td> 
 </tr> 
 <tr> 
 <td> 实现方式 </td> 
 <td> 基于线程的局部变量 </td> 
 <td> 通过互斥锁（监视器锁）实现 </td> 
 </tr> 
 <tr> 
 <td> 适用场景 </td> 
 <td> 需要在线程之间隔离数据的场景 </td> 
 <td> 多个线程共享同一个资源的场景 </td> 
 </tr> 
 <tr> 
 <td> 效果 </td> 
 <td> 线程间数据隔离，避免锁的开销，提高并发性能 </td> 
 <td> 线程安全，保证共享资源在同一时间只能被一个线程访问 </td> 
 </tr> 
 <tr> 
 <td> 锁的粒度 </td> 
 <td> 线程级别 </td> 
 <td> 对象级别 </td> 
 </tr> 
 <tr> 
 <td> 并发性能 </td> 
 <td> 可以提高并发性能 </td> 
 <td> 引入额外的开销，可能导致线程阻塞 </td> 
 </tr> 
 <tr> 
 <td> 内存管理 </td> 
 <td> 需要注意合理管理ThreadLocal实例，避免泄漏 </td> 
 <td> 无需额外的内存管理 </td> 
 </tr> 
 <tr> 
 <td> 使用复杂度 </td> 
 <td> 相对较低，简单易用 </td> 
 <td> 相对较高，需要手动控制加锁和释放锁 </td> 
 </tr> 
 <tr> 
 <td> 编程范式 </td> 
 <td> 面向变量副本 </td> 
 <td> 面向共享资源 </td> 
 </tr> 
 </tbody> 
</table>

ThreadLocal适用于需要在线程间隔离数据的场景，可以提高并发性能，但需要注意管理ThreadLocal实例。Synchronized适用于多个线程共享同一个资源的场景，保证线程安全，但可能引入额外的开销和线程阻塞。 ThreadLocal 可以实现线程级别的变量存储，确保每个线程都拥有自己独立的变量副本，避免线程安全问题。ThreadLocal 的使用场景包括线程安全问题、传递上下文信息、数据库连接管理等。通过合理地运用 ThreadLocal，可以简化多线程编程，提高代码的可读性和可维护性。

[format_png]: https://img-blog.csdnimg.cn/img_convert/2fb2521f3f44e4e7c22538e0c9d6d5a8.webp?x-oss-process=image/format,png