当前位置:   article > 正文

实战指南:理解 ThreadLocal 原理并用于Java 多线程上下文管理_threadlocal 实现上下文

threadlocal 实现上下文

目录

一、ThreadLocal基本知识回顾分析

(一)ThreadLocal原理

(二)既然ThreadLocalMap的key是弱引用,GC之后key是否为null?

(三)ThreadLocal中的内存泄漏问题及JDK处理方法

(四)部分核心源码回顾

ThreadLocal.set()方法源码详解

ThreadLocalMap.get()方法详解

ThreadLocal.remove()方法源码详解

(五)简单的直观体会

二、基于Threadlocal实现的上下文管理组件ContextManager

(一)定义 ContextManager 类

(二)使用 ContextManager 进行上下文管理

(三)扩展 ContextManager 的使用方式

三、在线程池中传递ContextManager

(一)增加静态方法,用于在已有的上下文中执行任务

(二)自定义线程池实现

(三)测试自定义线程池

四、总结


干货分享,感谢您的阅读!

探讨如何基于 ThreadLocal 实现一个高效的上下文管理组件,以解决多线程环境下的数据共享和上下文管理这些问题。通过具体的代码示例和实战展示 ThreadLocal 如何为多线程编程提供一种简洁而高效的上下文管理方案。

一、ThreadLocal基本知识回顾分析

(一)ThreadLocal原理

ThreadLocal 是 Java 提供的一个用于线程级别数据存储的类。它为每个线程提供了独立的变量副本,使得每个线程都能独立地操作自己的变量,而不会与其他线程的变量冲突。这种机制特别适用于需要线程隔离的场景,通过 ThreadLocal,我们可以确保同一个变量在不同线程中拥有各自独立的值。

我们先来看下Thread、ThreadLocalMap、ThreadLocal结构关系:

  • 每个Thread都有一个ThreadLocalMap变量
  • ThreadLocalMap内部定义了Entry(ThreadLocal<?> k, Object v)节点类,这个节点继承了WeakReference类泛型为ThreacLocal

ThreadLocal主要作用就是实现线程间变量隔离,对于一个变量,每个线程维护一个自己的实例,防止多线程环境下的资源竞争,那ThreadLocal是如何实现这一特性的呢?基本原理实现如下:

  1. 每个Thread对象中都包含一个ThreadLocal.ThreadLocalMap类型的threadlocals成员变量;

  2. 该map对应的每个元素Entry对象中:key是ThreadLocal对象的弱引用,value是该threadlocal变量在当前线程中的对应的变量实体;

  3. 当某一线程执行获取该ThreadLocal对象对应的变量时,首先从当前线程对象中获取对应的threadlocals哈希表,再以该ThreadLocal对象为key查询哈希表中对应的value;

  4. 由于每个线程独占一个threadlocals哈希表,因此线程间ThreadLocal对象对应的变量实体也是独占的,不存在竞争问题,也就避免了多线程问题。

(二)既然ThreadLocalMapkey是弱引用,GC之后key是否为null

在搞清楚这个问题之前,我们需要先搞清楚Java的四种引用类型

  • 强引用:new出来的对象就是强引用,只要强引用存在,垃圾回收器就永远不会回收被引用的对象,哪怕内存不足的时候。
  • 软引用:使用SoftReference修饰的对象被称为软引用,在内存要溢出的时候软引用指向的对象会被回收。
  • 弱引用:使用WeakReference修饰的对象被称为弱引用,只要发生垃圾回收,被弱引用指向的对象就会被回收。
  • 虚引用:虚引用是最弱的引用,用PhantomReference进行定。唯一的作用就是用来队列接受对象即将死亡的通知。

这个问题的答案是不为null,从上图的图示就可以直接看出。

(三)ThreadLocal中的内存泄漏问题及JDK处理方法

由图可知,ThreadLocal.ThreadLocalMap 对应的Entry中,key为ThreadLocal对象的弱引用,方法执行对应栈帧中的ThreadLocal引用为强引用。当方法执行过程中,由于栈帧销毁或者主动释放等原因,释放了ThreadLocal对象的强引用,即表示该ThreadLocal对象可以被回收了。又因为Entry中key为ThreadLocal对象的弱引用,所以当jvm执行GC操作时是能够回收该ThreadLocal对象的。

Entry中value对应的是变量实体对象的强引用,因此释放一个ThreadLocal对象,是无法释放ThreadLocal.ThreadLocalMap中对应的value对象的,也就造成了内存泄漏。除非释放当前线程对象,这样整个threadlocals都被回收了。但是日常开发中会经常使用线程池等线程池化技术,释放线程对象的条件往往无法达到。

JDK处理的方法是,在ThreadLocalMap进行set()get()remove()的时候,都会进行清理:

  1. private Entry getEntry(ThreadLocal<?> key) {
  2. int i = key.threadLocalHashCode & (table.length - 1);
  3. Entry e = table[i];
  4. if (e != null && e.get() == key)
  5. return e;
  6. else
  7. return getEntryAfterMiss(key, i, e);
  8. }
  9. private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
  10. Entry[] tab = table;
  11. int len = tab.length;
  12. while (e != null) {
  13. ThreadLocal<?> k = e.get();
  14. if (k == key)
  15. return e;
  16. if (k == null)
  17. //如果key为null,对应的threadlocal对象已经被回收,清理该Entry
  18. expungeStaleEntry(i);
  19. else
  20. i = nextIndex(i, len);
  21. e = tab[i];
  22. }
  23. return null;
  24. }

(四)部分核心源码回顾

ThreadLocalAPI很少就包含了4个,分别是get()set()remove()withInitial(),源码如下:

  1. public T get() {}
  2. public void set(T value){}
  3. public void remove(){}
  4. public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
  5. }
  • get():从当前线程的 ThreadLocalMap 获取与当前 ThreadLocal 对象对应的值。如果 ThreadLocalMap 中不存在该值,则调用 setInitialValue() 方法进行初始化。
  • set(T value):将当前线程的 ThreadLocalMap 中的值设置为给定的 value。如果当前线程没有 ThreadLocalMap,则会创建一个新的 ThreadLocalMap 并将值设置进去。
  • remove():从当前线程的 ThreadLocalMap 中移除与当前 ThreadLocal 对象对应的值,帮助防止内存泄漏。
  • withInitial(Supplier<? extends T> supplier):返回一个新的 ThreadLocal 对象,其初始值由 Supplier 提供。这允许使用者在创建 ThreadLocal 时指定初始值。

针对这几个源码我们重点进行分析和体会。

ThreadLocal.set()方法源码详解

  1. pubic void set(T value) {
  2. // 获取当前线程
  3. Thread t = Threac.currentThread();
  4. // 获取当前线程的ThreadLocalMap
  5. ThreadLocalMap map = getMap(t);
  6. // 如果map不为null, 调用ThreadLocalMap.set()方法设置值
  7. if (map != null)
  8. map.set(this, value);
  9. else
  10. // map为null,调用createMap()方法初始化创建map
  11. createMap(t, value);
  12. }
  13. // 返回线程的ThreadLocalMap.threadLocals
  14. ThreadLocalMap getMap(Thread t) {
  15. return t.threadLocals;
  16. }
  17. // 调用ThreadLocalMap构造方法创建ThreadLocalMap
  18. void createMap(Thread t, T firstValue) {
  19. t.threadLocals = new ThreadLocalMap(this, firstValue);
  20. }
  21. // ThreadLocalMap构造方法,传入firstKey, firstValue
  22. ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
  23. // 初始化Entry表的容量 = 16
  24. table = new Entry[INITIAL_CAPACITY];
  25. // 获取ThreadLocal的hashCode值与运算得到数组下标
  26. int i = firsetKey.threadLocalHashCode & (INITAL_CAPACITY - 1);
  27. // 通过下标Entry表赋值
  28. table[i] = new Entry(firstKey, firstValue);
  29. // Entry表存储元素数量初始化为1
  30. size = 1;
  31. // 设置Entry表扩容阙值 默认为 len * 2 / 3
  32. setThreshold(INITIAL_CAPACITY);
  33. }
  34. private void setThreshold(int len) {
  35. threshold = len * 2 / 3
  36. }

ThreadLocal.set()方法还是很简单的,核心方法在ThreadLocalMap.set()方法

基本流程可总结如下:

ThreadLocalMap.get()方法详解

  1. public T get() {
  2. Thread t = Thread.currentThread();
  3. ThreadLocalMap map = getMap(t);
  4. if (map != null) {
  5. ThreadLocalMap.Entry e = map.getEntry(this);
  6. if (e != null) {
  7. @SuppressWarnings("unchecked")
  8. T result = (T)e.value;
  9. return result;
  10. }
  11. }
  12. // 未找到的话,则调用setInitialValue()方法设置null
  13. return setInitialValue();
  14. }
  15. private Entry getEntry(ThreadLocal<?> key) {
  16. int i = key.threadLocalHashCode & (table.length - 1);
  17. Entry e = table[i];
  18. // key相等直接返回
  19. if (e != null && e.get() == key)
  20. return e;
  21. else
  22. // key不相等调用getEntryAfterMiss()方法
  23. return getEntryAfterMiss(key, i, e);
  24. }
  25. private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
  26. Entry[] tab = table;
  27. int len = tab.length;
  28. // 迭代往后查找key相等的entry
  29. while (e != null) {
  30. ThreadLocal<?> k = e.get();
  31. if (k == key)
  32. return e;
  33. // 遇到key=null的entry,先进行探测式清理工作
  34. if (k == null)
  35. expungeStaleEntry(i);
  36. else
  37. i = nextIndex(i, len);
  38. e = tab[i];
  39. }
  40. return null;
  41. }

主要包含两种情况,一种是hash计算出下标,该下标对应的Entry.key和我们传入的key相等的情况,另外一种就是不相等的情况。

相等情况:相等情况处理很简单,直接返回value,如下图,比如get(ThreadLocal1)计算下标为4,且4存在Entry,且key相等,则直接返回value = 11

不相等情况:不相等情况,以get(ThreadLocal2)为例计算下标为4,且4存在Entry,但key相等,这个时候则为往后迭代寻找key相等的元素,如果寻找过程中发现了有key = null的元素则回进行探测式清理操作。如下图:

迭代到index=5的数据时,此时Entry.key=null,触发一次探测式数据回收操作,执行expungeStaleEntry()方法,执行完后,index 5、8的数据都会被回收,而index 6、7的数据都会前移,此时继续往后迭代,到index = 6的时候即找到了key值相等的Entry数据,如下图:

ThreadLocal.remove()方法源码详解

  1. public void remove() {
  2. // 获取当前线程的 ThreadLocalMap
  3. ThreadLocalMap m = getMap(Thread.currentThread());
  4. if (m != null)
  5. // 如果当前线程有 ThreadLocalMap,则在 map 中移除当前 ThreadLocal 的值
  6. m.remove(this);
  7. }
  8. static class ThreadLocalMap {
  9. // 内部 Entry 类,继承自 WeakReference<ThreadLocal<?>>
  10. static class Entry extends WeakReference<ThreadLocal<?>> {
  11. // ThreadLocal 对应的值
  12. Object value;
  13. Entry(ThreadLocal<?> k, Object v) {
  14. super(k);
  15. value = v;
  16. }
  17. }
  18. // 线程局部变量哈希表
  19. private Entry[] table;
  20. private void remove(ThreadLocal<?> key) {
  21. Entry[] tab = table;
  22. int len = tab.length;
  23. // 计算当前 ThreadLocal 的哈希值在数组中的索引位置
  24. int i = key.threadLocalHashCode & (len - 1);
  25. // 从hash获取的下标开始,寻找key相等的entry元素清除
  26. for (Entry e = tab[i];
  27. e != null;
  28. e = tab[i = nextIndex(i, len)]) {
  29. if (e.get() == key) {
  30. e.clear(); // 清除键的引用
  31. expungeStaleEntry(i); // 清除相应的值
  32. return;
  33. }
  34. }
  35. }
  36. // 用于计算下一个索引位置
  37. private int nextIndex(int i, int len) {
  38. return ((i + 1 < len) ? i + 1 : 0);
  39. }
  40. // 清除无效的 Entry
  41. private void expungeStaleEntry(int staleSlot) {
  42. Entry[] tab = table;
  43. int len = tab.length;
  44. // 清除给定槽位的 Entry
  45. tab[staleSlot].value = null;
  46. tab[staleSlot] = null;
  47. // Rehash until we encounter null
  48. Entry e;
  49. int i;
  50. for (i = nextIndex(staleSlot, len);
  51. (e = tab[i]) != null;
  52. i = nextIndex(i, len)) {
  53. ThreadLocal<?> k = e.get();
  54. if (k == null) {
  55. e.value = null;
  56. tab[i] = null;
  57. } else {
  58. int h = k.threadLocalHashCode & (len - 1);
  59. if (h != i) {
  60. tab[i] = null;
  61. while (tab[h] != null)
  62. h = nextIndex(h, len);
  63. tab[h] = e;
  64. }
  65. }
  66. }
  67. }
  68. }

ThreadLocal.remove()核心是调用ThreadLocalMap.remove()方法,流程如下:

  1. 通过hash计算下标。
  2. 从散列表该下标开始往后查key相等的元素,如果找到则做清除操作,引用置为nullGC的时候key就会置为null,然后执行探测式清理处理。

(五)简单的直观体会

以下是 ThreadLocal 的基本使用示例:

  1. package org.zyf.javabasic.thread.threadLocal;
  2. /**
  3. * @program: zyfboot-javabasic
  4. * @description: ThreadLocal 的基本使用示例
  5. * @author: zhangyanfeng
  6. * @create: 2024-06-02 13:22
  7. **/
  8. public class ThreadLocalExample {
  9. private static ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 1);
  10. public static void main(String[] args) {
  11. Runnable task = () -> {
  12. int value = threadLocal.get();
  13. System.out.println(Thread.currentThread().getName() + " initial value: " + value);
  14. threadLocal.set(value + 1);
  15. System.out.println(Thread.currentThread().getName() + " updated value: " + threadLocal.get());
  16. };
  17. Thread thread1 = new Thread(task, "Thread 1");
  18. Thread thread2 = new Thread(task, "Thread 2");
  19. thread1.start();
  20. thread2.start();
  21. }
  22. }

直接结果查看可感受到其ThreadLocal主要作用就是实现线程间变量隔离,对于一个变量,每个线程维护一个自己的实例,防止多线程环境下的资源竞争。

二、基于Threadlocal实现的上下文管理组件ContextManager

在实际开发中,我们经常需要维护一些上下文信息,这样可以避免在方法调用过程中传递过多的参数。例如,当 Web 服务器收到一个请求时,需要解析当前登录状态的用户,并在后续的业务处理中使用这个用户名。如果只需要维护一个上下文数据,如用户名,可以通过方法传参的方式,将用户名作为参数传递给每个业务方法。然而,如果需要维护的上下文信息较多,这种方式就显得笨拙且难以维护。

一个更加优雅的解决方案是使用 ThreadLocal 来实现请求线程的上下文管理。这样,同一线程中的所有方法都可以通过 ThreadLocal 对象直接读取和修改上下文信息,而无需在方法间传递参数。当需要维护多个上下文状态时,可以使用多个 ThreadLocal 实例来存储不同的信息。虽然这种方式在某些情况下也能接受,但在使用线程池时,问题就变得复杂了。因为线程池中的线程会被多个请求重复使用,如何将 ThreadLocal 中的上下文信息从主线程传递到线程池中的工作线程成为一个难题。

基于上述考虑,我们介绍一种基于 ThreadLocal 实现的上下文管理组件 ContextManager,它能够简化上下文信息的管理,并解决线程池环境中的上下文传递问题。

(一)定义 ContextManager

首先,定义一个 ContextManager 类用于管理上下文信息。

  1. package org.zyf.javabasic.thread.threadLocal;
  2. import java.util.concurrent.ConcurrentHashMap;
  3. import java.util.concurrent.ConcurrentMap;
  4. /**
  5. * @program: zyfboot-javabasic
  6. * @description: 用于管理上下文信息
  7. * @author: zhangyanfeng
  8. * @create: 2024-06-02 13:48
  9. **/
  10. public class ContextManager {
  11. // 静态变量,维护不同线程的上下文
  12. private static final ThreadLocal<ContextManager> CONTEXT_THREAD_LOCAL = new ThreadLocal<>();
  13. // 实例变量,维护每个上下文中所有的状态数据
  14. private final ConcurrentMap<String, Object> values = new ConcurrentHashMap<>();
  15. // 获取当前线程的上下文
  16. public static ContextManager getCurrentContext() {
  17. return CONTEXT_THREAD_LOCAL.get();
  18. }
  19. // 在当前上下文设置一个状态数据
  20. public void set(String key, Object value) {
  21. if (value != null) {
  22. values.put(key, value);
  23. } else {
  24. values.remove(key);
  25. }
  26. }
  27. // 在当前上下文读取一个状态数据
  28. public Object get(String key) {
  29. return values.get(key);
  30. }
  31. // 开启一个新的上下文
  32. public static ContextManager beginContext() {
  33. ContextManager context = CONTEXT_THREAD_LOCAL.get();
  34. if (context != null) {
  35. throw new IllegalStateException("A context is already started in the current thread.");
  36. }
  37. context = new ContextManager();
  38. CONTEXT_THREAD_LOCAL.set(context);
  39. return context;
  40. }
  41. // 关闭当前上下文
  42. public static void endContext() {
  43. CONTEXT_THREAD_LOCAL.remove();
  44. }
  45. }

(二)使用 ContextManager 进行上下文管理

假设我们有一个在线商城系统,用户在进行购物时需要进行身份认证,并且在用户进行购物操作时,需要记录用户的购物车信息。我们可以使用 ContextManager 类来管理用户的上下文信息。

  1. package org.zyf.javabasic.thread.threadLocal;
  2. import org.zyf.javabasic.skills.reflection.dto.Product;
  3. /**
  4. * @program: zyfboot-javabasic
  5. * @description: 用户在进行购物时需要进行身份认证,并且在用户进行购物操作时,需要记录用户的购物车信息。
  6. * @author: zhangyanfeng
  7. * @create: 2024-06-02 14:02
  8. **/
  9. public class ShoppingCartService {
  10. public void addToCart(Product product, int quantity) {
  11. // 开启一个新的上下文
  12. ContextManager.beginContext();
  13. try {
  14. // 将用户ID和商品信息设置到当前上下文中
  15. ContextManager.getCurrentContext().set("userId", getCurrentUserId());
  16. ContextManager.getCurrentContext().set("product", product);
  17. ContextManager.getCurrentContext().set("quantity", quantity);
  18. // 执行添加到购物车的逻辑
  19. // 这里可以调用其他方法,或者执行其他操作
  20. System.out.println("Adding product to cart...");
  21. checkout();
  22. } finally {
  23. // 关闭当前上下文
  24. ContextManager.endContext();
  25. }
  26. }
  27. public void checkout() {
  28. // 从当前上下文中读取用户ID和购物车信息
  29. String userId = (String) ContextManager.getCurrentContext().get("userId");
  30. Product product = (Product) ContextManager.getCurrentContext().get("product");
  31. int quantity = (int) ContextManager.getCurrentContext().get("quantity");
  32. // 执行结账逻辑
  33. // 这里可以根据购物车信息进行结账操作
  34. System.out.println("Checking out...");
  35. System.out.println("User ID: " + userId);
  36. System.out.println("Product: " + product.getName());
  37. System.out.println("Quantity: " + quantity);
  38. }
  39. private String getCurrentUserId() {
  40. // 模拟获取当前用户ID的方法
  41. return "user123";
  42. }
  43. public static void main(String[] args) {
  44. ShoppingCartService shoppingCartService = new ShoppingCartService();
  45. Product product = new Product();
  46. product.setName("iPhone");
  47. product.setId(1000);
  48. shoppingCartService.addToCart(product, 1);
  49. }
  50. }

在这个示例中,ShoppingCartService 类模拟了一个购物车服务。在 addToCart() 方法中,我们开启了一个新的上下文,并将当前用户ID、商品信息和购买数量设置到上下文中。在 checkout() 方法中,我们从当前上下文中读取了用户ID、商品信息和购买数量,并执行了结账操作。

通过使用 ContextManager 类,我们可以轻松地在购物车服务中管理用户的上下文信息,而无需手动传递参数。

(三)扩展 ContextManager 的使用方式

我们可以给 ContextManager 添加类似的静态方法,以简化代码的书写。当前请视业务情况进行应用和分析。

  1. package org.zyf.javabasic.thread.threadLocal;
  2. import java.util.concurrent.ConcurrentHashMap;
  3. import java.util.concurrent.ConcurrentMap;
  4. import java.util.function.Supplier;
  5. /**
  6. * @program: zyfboot-javabasic
  7. * @description: 用于管理上下文信息
  8. * @author: zhangyanfeng
  9. * @create: 2024-06-02 13:48
  10. **/
  11. public class ContextManager {
  12. // 其他省去
  13. // 执行带有新的上下文的任务
  14. public static <X extends Throwable> void runWithNewContext(Runnable task) throws X {
  15. beginContext();
  16. try {
  17. task.run();
  18. } finally {
  19. endContext();
  20. }
  21. }
  22. // 在新的上下文中执行任务,并返回结果
  23. public static <T, X extends Throwable> T supplyWithNewContext(Supplier<T> supplier) throws X {
  24. beginContext();
  25. try {
  26. return supplier.get();
  27. } finally {
  28. endContext();
  29. }
  30. }
  31. }

三、在线程池中传递ContextManager

我们通过 ThreadLocal 实现了一个自定义的上下文管理组件 ContextManager,并通过 ContextManager.set()ContextManager.get() 方法在同一个线程中读写上下文中的状态数据。

现在,我们需要扩展这个功能,使其在一个线程执行过程中开启了一个 ContextManager,随后使用线程池执行任务时,也能获取到当前 ContextManager 中的状态数据。这在如下场景中很常见:服务收到一个用户请求,通过 ContextManager 将登录态数据存储到当前线程的上下文中,随后使用线程池执行一些耗时操作,并希望线程池中的线程也能访问这些登录态数据。

由于线程池中的线程和请求线程不是同一个线程,按照目前的实现,线程池中的线程无法访问请求线程的上下文数据。

为了解决这个问题,我们可以在提交 Runnable 时,将当前的 ContextManager 引用存储在 Runnable 对象中。当线程池中的线程开始执行时,将 ContextManager 替换到执行线程的上下文中,执行完成后再恢复原来的上下文。

(一)增加静态方法,用于在已有的上下文中执行任务

首先,添加静态方法 runWithExistingContextsupplyWithExistingContext,用于在指定的上下文中执行任务:

  1. package org.zyf.javabasic.thread.threadLocal;
  2. import java.util.concurrent.ConcurrentHashMap;
  3. import java.util.concurrent.ConcurrentMap;
  4. import java.util.function.Supplier;
  5. /**
  6. * @program: zyfboot-javabasic
  7. * @description: 用于管理上下文信息
  8. * @author: zhangyanfeng
  9. * @create: 2024-06-02 13:48
  10. **/
  11. public class ContextManager {
  12. // 省略
  13. public static <X extends Throwable> void runWithExistingContext(ContextManager context, Runnable task) throws X {
  14. supplyWithExistingContext(context, () -> {
  15. task.run();
  16. return null;
  17. });
  18. }
  19. public static <T, X extends Throwable> T supplyWithExistingContext(ContextManager context, Supplier<T> supplier) throws X {
  20. ContextManager oldContext = CONTEXT_THREAD_LOCAL.get();
  21. CONTEXT_THREAD_LOCAL.set(context);
  22. try {
  23. return supplier.get();
  24. } finally {
  25. if (oldContext != null) {
  26. CONTEXT_THREAD_LOCAL.set(oldContext);
  27. } else {
  28. CONTEXT_THREAD_LOCAL.remove();
  29. }
  30. }
  31. }
  32. }

(二)自定义线程池实现

创建一个自定义线程池 ContextAwareThreadPoolExecutor,确保任务在执行时可以正确传递和恢复上下文信息:

  1. package org.zyf.javabasic.thread.threadLocal;
  2. import java.util.concurrent.BlockingQueue;
  3. import java.util.concurrent.LinkedBlockingQueue;
  4. import java.util.concurrent.ThreadPoolExecutor;
  5. import java.util.concurrent.TimeUnit;
  6. import static org.zyf.javabasic.thread.threadLocal.ContextManager.runWithExistingContext;
  7. /**
  8. * @program: zyfboot-javabasic
  9. * @description: 自定义线程池 ContextAwareThreadPoolExecutor
  10. * @author: zhangyanfeng
  11. * @create: 2024-06-02 20:23
  12. **/
  13. public class ContextAwareThreadPoolExecutor extends ThreadPoolExecutor {
  14. public ContextAwareThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
  15. super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
  16. }
  17. public static ContextAwareThreadPoolExecutor newFixedThreadPool(int nThreads) {
  18. return new ContextAwareThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>());
  19. }
  20. @Override
  21. public void execute(Runnable command) {
  22. ContextManager context = ContextManager.getCurrentContext();
  23. super.execute(() -> runWithExistingContext(context, command::run));
  24. }
  25. }

(三)测试自定义线程池

验证 ContextAwareThreadPoolExecutor 是否正确传递和恢复上下文:

  1. package org.zyf.javabasic.thread.threadLocal;
  2. import org.junit.Test;
  3. import java.util.concurrent.ExecutorService;
  4. /**
  5. * @program: zyfboot-javabasic
  6. * @description: 验证 ContextAwareThreadPoolExecutor 是否正确传递和恢复上下文
  7. * @author: zhangyanfeng
  8. * @create: 2024-06-02 20:25
  9. **/
  10. public class ContextManagerTest {
  11. @Test
  12. public void testContextAwareThreadPoolExecutor() {
  13. ContextManager.beginContext();
  14. try {
  15. ContextManager.getCurrentContext().set("key", "value out of thread pool");
  16. Runnable r = () -> {
  17. String value = (String) ContextManager.getCurrentContext().get("key");
  18. System.out.println("Value in thread pool: " + value);
  19. };
  20. ExecutorService executor = ContextAwareThreadPoolExecutor.newFixedThreadPool(10);
  21. executor.execute(r);
  22. executor.submit(r);
  23. } finally {
  24. ContextManager.endContext();
  25. }
  26. /** 执行结果
  27. * Value in thread pool: value out of thread pool
  28. * Value in thread pool: value out of thread pool
  29. */
  30. }
  31. @Test
  32. public void testContextAwareThreadPoolExecutorWithNewContext() {
  33. ContextManager.runWithNewContext(() -> {
  34. ContextManager.getCurrentContext().set("key", "value out of thread pool");
  35. Runnable r = () -> {
  36. String value = (String) ContextManager.getCurrentContext().get("key");
  37. System.out.println("Value in thread pool: " + value);
  38. };
  39. ExecutorService executor = ContextAwareThreadPoolExecutor.newFixedThreadPool(10);
  40. executor.execute(r);
  41. executor.submit(r);
  42. });
  43. /** 执行结果
  44. * Value in thread pool: value out of thread pool
  45. * Value in thread pool: value out of thread pool
  46. */
  47. }
  48. }

验证ContextAwareThreadPoolExecutor 是否能正确传递和恢复上下文信息。测试用例涵盖了两种情况:

  1. 在当前上下文中执行任务,并使用自定义线程池执行任务。
  2. 在新的上下文中执行任务,并使用自定义线程池执行任务。

这两种情况覆盖了在不同上下文环境中使用线程池的情况,确保了上下文信息能够正确传递和恢复。因此,验证内容是完备的,没有问题。

四、总结

探讨如何基于 ThreadLocal 实现一个高效的上下文管理组件,以解决多线程环境下的数据共享和上下文管理这些问题。通过具体的代码示例和实战展示 ThreadLocal 如何为多线程编程提供一种简洁而高效的上下文管理方案。

参考文章

https://www.cnblogs.com/wupeixuan/p/12638203.html

一张图看懂Java中的ThreadLocal原理_threadlocal原理图解-CSDN博客

ThreadLocal原理 · 进击的java菜鸟

一文搞懂ThreadLocal原理-51CTO.COM

滑动验证页面

基于 ThreadLocal 实现一个上下文管理组件(附源码)

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/知新_RL/article/detail/948938
推荐阅读
相关标签
  

闽ICP备14008679号