Java高并发专题之24、ThreadLocal、InheritableThreadLocal

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量130 收藏
点赞数
文章标签： java 开发语言 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSDN_KONGlX/article/details/125484481
版权

本文内容

  1. 需要解决的问题
  2. 介绍ThreadLocal
  3. 介绍InheritableThreadLocal

需要解决的问题

我们还是以解决问题的方式来引出ThreadLocal、InheritableThreadLocal，这样印象会深刻一些。

目前java开发web系统一般有3层，controller、service、dao，请求到达controller，controller调用service，service调用dao，然后进行处理。

我们写一个简单的例子，有3个方法分别模拟controller、service、dao。代码如下：


     
     
  1. package com.itsoku.chat24;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.concurrent.LinkedBlockingDeque;
  6. import java.util.concurrent.ThreadPoolExecutor;
  7. import java.util.concurrent.TimeUnit;
  8. import java.util.concurrent.atomic.AtomicInteger;
  10. /**
  11.  * 跟着阿里p7学并发，微信公众号：javacode2018
  12.  */
  13. public class Demo1 {
  15.     static AtomicInteger threadIndex = new AtomicInteger(1);
  16.     //创建处理请求的线程池子
  17.     static ThreadPoolExecutor disposeRequestExecutor = new ThreadPoolExecutor(3,
  18.             3,
  19.             60,
  20.             TimeUnit.SECONDS,
  21.             new LinkedBlockingDeque<>(),
  22.             r -> {
  23.                 Thread thread = new Thread(r);
  24.                 thread.setName("disposeRequestThread-" + threadIndex.getAndIncrement());
  25.                 return thread;
  26.             });
  28.     //记录日志
  29.     public static void log(String msg) {
  30.         StackTraceElement stack[] = (new Throwable()).getStackTrace();
  31.         System.out.println("****" + System.currentTimeMillis() + ",[线程:" + Thread.currentThread().getName() + "]," + stack[1] + ":" + msg);
  32.     }
  34.     //模拟controller
  35.     public static void controller(List<String> dataList) {
  36.         log("接受请求");
  37.         service(dataList);
  38.     }
  40.     //模拟service
  41.     public static void service(List<String> dataList) {
  42.         log("执行业务");
  43.         dao(dataList);
  44.     }
  46.     //模拟dao
  47.     public static void dao(List<String> dataList) {
  48.         log("执行数据库操作");
  49.         //模拟插入数据
  50.         for (String s : dataList) {
  51.             log("插入数据" + s + "成功");
  52.         }
  53.     }
  55.     public static void main(String[] args) {
  56.         //需要插入的数据
  57.         List<String> dataList = new ArrayList<>();
  58.         for (int i = 0; i < 3; i++) {
  59.             dataList.add("数据" + i);
  60.         }
  62.         //模拟5个请求
  63.         int requestCount = 5;
  64.         for (int i = 0; i < requestCount; i++) {
  65.             disposeRequestExecutor.execute(() -> {
  66.                 controller(dataList);
  67.             });
  68.         }
  70.         disposeRequestExecutor.shutdown();
  71.     }
  72. }

运行结果：


     
     
  1. ****1565338891286,[线程:disposeRequestThread-2],com.itsoku.chat24.Demo1.controller(Demo1.java:36):接受请求
  2. ****1565338891286,[线程:disposeRequestThread-1],com.itsoku.chat24.Demo1.controller(Demo1.java:36):接受请求
  3. ****1565338891287,[线程:disposeRequestThread-2],com.itsoku.chat24.Demo1.service(Demo1.java:42):执行业务
  4. ****1565338891287,[线程:disposeRequestThread-1],com.itsoku.chat24.Demo1.service(Demo1.java:42):执行业务
  5. ****1565338891287,[线程:disposeRequestThread-3],com.itsoku.chat24.Demo1.controller(Demo1.java:36):接受请求
  6. ****1565338891287,[线程:disposeRequestThread-1],com.itsoku.chat24.Demo1.dao(Demo1.java:48):执行数据库操作
  7. ****1565338891287,[线程:disposeRequestThread-1],com.itsoku.chat24.Demo1.dao(Demo1.java:51):插入数据数据0成功
  8. ****1565338891287,[线程:disposeRequestThread-1],com.itsoku.chat24.Demo1.dao(Demo1.java:51):插入数据数据1成功
  9. ****1565338891287,[线程:disposeRequestThread-2],com.itsoku.chat24.Demo1.dao(Demo1.java:48):执行数据库操作
  10. ****1565338891287,[线程:disposeRequestThread-1],com.itsoku.chat24.Demo1.dao(Demo1.java:51):插入数据数据2成功
  11. ****1565338891287,[线程:disposeRequestThread-3],com.itsoku.chat24.Demo1.service(Demo1.java:42):执行业务
  12. ****1565338891288,[线程:disposeRequestThread-1],com.itsoku.chat24.Demo1.controller(Demo1.java:36):接受请求
  13. ****1565338891287,[线程:disposeRequestThread-2],com.itsoku.chat24.Demo1.dao(Demo1.java:51):插入数据数据0成功
  14. ****1565338891288,[线程:disposeRequestThread-1],com.itsoku.chat24.Demo1.service(Demo1.java:42):执行业务
  15. ****1565338891288,[线程:disposeRequestThread-3],com.itsoku.chat24.Demo1.dao(Demo1.java:48):执行数据库操作
  16. ****1565338891288,[线程:disposeRequestThread-1],com.itsoku.chat24.Demo1.dao(Demo1.java:48):执行数据库操作
  17. ****1565338891288,[线程:disposeRequestThread-2],com.itsoku.chat24.Demo1.dao(Demo1.java:51):插入数据数据1成功
  18. ****1565338891288,[线程:disposeRequestThread-1],com.itsoku.chat24.Demo1.dao(Demo1.java:51):插入数据数据0成功
  19. ****1565338891288,[线程:disposeRequestThread-3],com.itsoku.chat24.Demo1.dao(Demo1.java:51):插入数据数据0成功
  20. ****1565338891288,[线程:disposeRequestThread-1],com.itsoku.chat24.Demo1.dao(Demo1.java:51):插入数据数据1成功
  21. ****1565338891288,[线程:disposeRequestThread-2],com.itsoku.chat24.Demo1.dao(Demo1.java:51):插入数据数据2成功
  22. ****1565338891288,[线程:disposeRequestThread-1],com.itsoku.chat24.Demo1.dao(Demo1.java:51):插入数据数据2成功
  23. ****1565338891288,[线程:disposeRequestThread-3],com.itsoku.chat24.Demo1.dao(Demo1.java:51):插入数据数据1成功
  24. ****1565338891288,[线程:disposeRequestThread-2],com.itsoku.chat24.Demo1.controller(Demo1.java:36):接受请求
  25. ****1565338891288,[线程:disposeRequestThread-3],com.itsoku.chat24.Demo1.dao(Demo1.java:51):插入数据数据2成功
  26. ****1565338891288,[线程:disposeRequestThread-2],com.itsoku.chat24.Demo1.service(Demo1.java:42):执行业务
  27. ****1565338891289,[线程:disposeRequestThread-2],com.itsoku.chat24.Demo1.dao(Demo1.java:48):执行数据库操作
  28. ****1565338891289,[线程:disposeRequestThread-2],com.itsoku.chat24.Demo1.dao(Demo1.java:51):插入数据数据0成功
  29. ****1565338891289,[线程:disposeRequestThread-2],com.itsoku.chat24.Demo1.dao(Demo1.java:51):插入数据数据1成功
  30. ****1565338891289,[线程:disposeRequestThread-2],com.itsoku.chat24.Demo1.dao(Demo1.java:51):插入数据数据2成功

代码中调用controller、service、dao 3个方法时，来模拟处理一个请求。main方法中循环了5次模拟发起5次请求，然后交给线程池去处理请求，dao中模拟循环插入传入的dataList数据。

问题来了：开发者想看一下哪些地方耗时比较多，想通过日志来分析耗时情况，想追踪某个请求的完整日志，怎么搞？

上面的请求采用线程池的方式处理的，多个请求可能会被一个线程处理，通过日志很难看出那些日志是同一个请求，我们能不能给请求加一个唯一标志，日志中输出这个唯一标志，当然可以。

如果我们的代码就只有上面示例这么简单，我想还是很容易的，上面就3个方法，给每个方法加个traceId参数，log方法也加个traceId参数，就解决了，代码如下：


     
     
  1. package com.itsoku.chat24;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.concurrent.LinkedBlockingDeque;
  6. import java.util.concurrent.ThreadPoolExecutor;
  7. import java.util.concurrent.TimeUnit;
  8. import java.util.concurrent.atomic.AtomicInteger;
  10. /**
  11.  * 跟着阿里p7学并发，微信公众号：javacode2018
  12.  */
  13. public class Demo2 {
  15.     static AtomicInteger threadIndex = new AtomicInteger(1);
  16.     //创建处理请求的线程池子
  17.     static ThreadPoolExecutor disposeRequestExecutor = new ThreadPoolExecutor(3,
  18.             3,
  19.             60,
  20.             TimeUnit.SECONDS,
  21.             new LinkedBlockingDeque<>(),
  22.             r -> {
  23.                 Thread thread = new Thread(r);
  24.                 thread.setName("disposeRequestThread-" + threadIndex.getAndIncrement());
  25.                 return thread;
  26.             });
  28.     //记录日志
  29.     public static void log(String msg, String traceId) {
  30.         StackTraceElement stack[] = (new Throwable()).getStackTrace();
  31.         System.out.println("****" + System.currentTimeMillis() + "[traceId:" + traceId + "],[线程:" + Thread.currentThread().getName() + "]," + stack[1] + ":" + msg);
  32.     }
  34.     //模拟controller
  35.     public static void controller(List<String> dataList, String traceId) {
  36.         log("接受请求", traceId);
  37.         service(dataList, traceId);
  38.     }
  40.     //模拟service
  41.     public static void service(List<String> dataList, String traceId) {
  42.         log("执行业务", traceId);
  43.         dao(dataList, traceId);
  44.     }
  46.     //模拟dao
  47.     public static void dao(List<String> dataList, String traceId) {
  48.         log("执行数据库操作", traceId);
  49.         //模拟插入数据
  50.         for (String s : dataList) {
  51.             log("插入数据" + s + "成功", traceId);
  52.         }
  53.     }
  55.     public static void main(String[] args) {
  56.         //需要插入的数据
  57.         List<String> dataList = new ArrayList<>();
  58.         for (int i = 0; i < 3; i++) {
  59.             dataList.add("数据" + i);
  60.         }
  62.         //模拟5个请求
  63.         int requestCount = 5;
  64.         for (int i = 0; i < requestCount; i++) {
  65.             String traceId = String.valueOf(i);
  66.             disposeRequestExecutor.execute(() -> {
  67.                 controller(dataList, traceId);
  68.             });
  69.         }
  71.         disposeRequestExecutor.shutdown();
  72.     }
  73. }

输出：


     
     
  1. ****1565339559773[traceId:0],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo2.controller(Demo2.java:36):接受请求
  2. ****1565339559773[traceId:1],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo2.controller(Demo2.java:36):接受请求
  3. ****1565339559773[traceId:2],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo2.controller(Demo2.java:36):接受请求
  4. ****1565339559774[traceId:1],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo2.service(Demo2.java:42):执行业务
  5. ****1565339559774[traceId:0],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo2.service(Demo2.java:42):执行业务
  6. ****1565339559774[traceId:1],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo2.dao(Demo2.java:48):执行数据库操作
  7. ****1565339559774[traceId:2],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo2.service(Demo2.java:42):执行业务
  8. ****1565339559774[traceId:1],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo2.dao(Demo2.java:51):插入数据数据0成功
  9. ****1565339559774[traceId:0],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo2.dao(Demo2.java:48):执行数据库操作
  10. ****1565339559774[traceId:1],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo2.dao(Demo2.java:51):插入数据数据1成功
  11. ****1565339559774[traceId:2],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo2.dao(Demo2.java:48):执行数据库操作
  12. ****1565339559774[traceId:1],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo2.dao(Demo2.java:51):插入数据数据2成功
  13. ****1565339559774[traceId:0],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo2.dao(Demo2.java:51):插入数据数据0成功
  14. ****1565339559775[traceId:3],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo2.controller(Demo2.java:36):接受请求
  15. ****1565339559775[traceId:2],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo2.dao(Demo2.java:51):插入数据数据0成功
  16. ****1565339559775[traceId:3],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo2.service(Demo2.java:42):执行业务
  17. ****1565339559775[traceId:0],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo2.dao(Demo2.java:51):插入数据数据1成功
  18. ****1565339559775[traceId:3],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo2.dao(Demo2.java:48):执行数据库操作
  19. ****1565339559775[traceId:2],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo2.dao(Demo2.java:51):插入数据数据1成功
  20. ****1565339559775[traceId:3],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo2.dao(Demo2.java:51):插入数据数据0成功
  21. ****1565339559775[traceId:0],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo2.dao(Demo2.java:51):插入数据数据2成功
  22. ****1565339559775[traceId:3],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo2.dao(Demo2.java:51):插入数据数据1成功
  23. ****1565339559775[traceId:2],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo2.dao(Demo2.java:51):插入数据数据2成功
  24. ****1565339559775[traceId:3],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo2.dao(Demo2.java:51):插入数据数据2成功
  25. ****1565339559775[traceId:4],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo2.controller(Demo2.java:36):接受请求
  26. ****1565339559776[traceId:4],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo2.service(Demo2.java:42):执行业务
  27. ****1565339559776[traceId:4],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo2.dao(Demo2.java:48):执行数据库操作
  28. ****1565339559776[traceId:4],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo2.dao(Demo2.java:51):插入数据数据0成功
  29. ****1565339559776[traceId:4],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo2.dao(Demo2.java:51):插入数据数据1成功
  30. ****1565339559776[traceId:4],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo2.dao(Demo2.java:51):插入数据数据2成功

上面我们通过修改代码的方式，把问题解决了，但前提是你们的系统都像上面这么简单，功能很少，需要改的代码很少，可以这么去改。但事与愿违，我们的系统一般功能都是比较多的，如果我们都一个个去改，岂不是要疯掉，改代码还涉及到重新测试，风险也不可控。那有什么好办法么？

ThreadLocal

还是拿上面的问题，我们来分析一下，每个请求都是由一个线程处理的，线程就相当于一个人一样，每个请求相当于一个任务，任务来了，人来处理，处理完毕之后，再处理下一个请求任务。人身上是不是有很多口袋，人刚开始准备处理任务的时候，我们把任务的编号放在处理者的口袋中，然后处理中一路携带者，处理过程中如果需要用到这个编号，直接从口袋中获取就可以了。那么刚好java中线程设计的时候也考虑到了这些问题，Thread对象中就有很多口袋，用来放东西。Thread类中有这么一个变量：


     
     
  1. ThreadLocal.ThreadLocalMap threadLocals = null;

这个就是用来操作Thread中所有口袋的东西，ThreadLocalMap源码中有一个数组(有兴趣的可以去看一下源码)，对应处理者身上很多口袋一样，数组中的每个元素对应一个口袋。

如何来操作Thread中的这些口袋呢，java为我们提供了一个类ThreadLocal，ThreadLocal对象用来操作Thread中的某一个口袋，可以向这个口袋中放东西、获取里面的东西、清除里面的东西，这个口袋一次性只能放一个东西，重复放东西会将里面已经存在的东西覆盖掉。

常用的3个方法：


     
     
  1. //向Thread中某个口袋中放东西
  2. public void set(T value);
  3. //获取这个口袋中目前放的东西
  4. public T get();
  5. //清空这个口袋中放的东西
  6. public void remove()

我们使用ThreadLocal来改造一下上面的代码，如下：


     
     
  1. package com.itsoku.chat24;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.concurrent.LinkedBlockingDeque;
  6. import java.util.concurrent.ThreadPoolExecutor;
  7. import java.util.concurrent.TimeUnit;
  8. import java.util.concurrent.atomic.AtomicInteger;
  10. /**
  11.  * 跟着阿里p7学并发，微信公众号：javacode2018
  12.  */
  13. public class Demo3 {
  15.     //创建一个操作Thread中存放请求任务追踪id口袋的对象
  16.     static ThreadLocal<String> traceIdKD = new ThreadLocal<>();
  18.     static AtomicInteger threadIndex = new AtomicInteger(1);
  19.     //创建处理请求的线程池子
  20.     static ThreadPoolExecutor disposeRequestExecutor = new ThreadPoolExecutor(3,
  21.             3,
  22.             60,
  23.             TimeUnit.SECONDS,
  24.             new LinkedBlockingDeque<>(),
  25.             r -> {
  26.                 Thread thread = new Thread(r);
  27.                 thread.setName("disposeRequestThread-" + threadIndex.getAndIncrement());
  28.                 return thread;
  29.             });
  31.     //记录日志
  32.     public static void log(String msg) {
  33.         StackTraceElement stack[] = (new Throwable()).getStackTrace();
  34.         //获取当前线程存放tranceId口袋中的内容
  35.         String traceId = traceIdKD.get();
  36.         System.out.println("****" + System.currentTimeMillis() + "[traceId:" + traceId + "],[线程:" + Thread.currentThread().getName() + "]," + stack[1] + ":" + msg);
  37.     }
  39.     //模拟controller
  40.     public static void controller(List<String> dataList) {
  41.         log("接受请求");
  42.         service(dataList);
  43.     }
  45.     //模拟service
  46.     public static void service(List<String> dataList) {
  47.         log("执行业务");
  48.         dao(dataList);
  49.     }
  51.     //模拟dao
  52.     public static void dao(List<String> dataList) {
  53.         log("执行数据库操作");
  54.         //模拟插入数据
  55.         for (String s : dataList) {
  56.             log("插入数据" + s + "成功");
  57.         }
  58.     }
  60.     public static void main(String[] args) {
  61.         //需要插入的数据
  62.         List<String> dataList = new ArrayList<>();
  63.         for (int i = 0; i < 3; i++) {
  64.             dataList.add("数据" + i);
  65.         }
  67.         //模拟5个请求
  68.         int requestCount = 5;
  69.         for (int i = 0; i < requestCount; i++) {
  70.             String traceId = String.valueOf(i);
  71.             disposeRequestExecutor.execute(() -> {
  72.                 //把traceId放入口袋中
  73.                 traceIdKD.set(traceId);
  74.                 try {
  75.                     controller(dataList);
  76.                 } finally {
  77.                     //将tranceId从口袋中移除
  78.                     traceIdKD.remove();
  79.                 }
  80.             });
  81.         }
  83.         disposeRequestExecutor.shutdown();
  84.     }
  85. }

输出：


     
     
  1. ****1565339644214[traceId:1],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo3.controller(Demo3.java:41):接受请求
  2. ****1565339644214[traceId:2],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo3.controller(Demo3.java:41):接受请求
  3. ****1565339644214[traceId:0],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo3.controller(Demo3.java:41):接受请求
  4. ****1565339644214[traceId:2],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo3.service(Demo3.java:47):执行业务
  5. ****1565339644214[traceId:1],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo3.service(Demo3.java:47):执行业务
  6. ****1565339644214[traceId:2],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo3.dao(Demo3.java:53):执行数据库操作
  7. ****1565339644214[traceId:0],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo3.service(Demo3.java:47):执行业务
  8. ****1565339644214[traceId:2],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo3.dao(Demo3.java:56):插入数据数据0成功
  9. ****1565339644214[traceId:0],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo3.dao(Demo3.java:53):执行数据库操作
  10. ****1565339644214[traceId:1],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo3.dao(Demo3.java:53):执行数据库操作
  11. ****1565339644215[traceId:0],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo3.dao(Demo3.java:56):插入数据数据0成功
  12. ****1565339644215[traceId:2],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo3.dao(Demo3.java:56):插入数据数据1成功
  13. ****1565339644215[traceId:0],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo3.dao(Demo3.java:56):插入数据数据1成功
  14. ****1565339644215[traceId:1],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo3.dao(Demo3.java:56):插入数据数据0成功
  15. ****1565339644215[traceId:0],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo3.dao(Demo3.java:56):插入数据数据2成功
  16. ****1565339644215[traceId:2],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo3.dao(Demo3.java:56):插入数据数据2成功
  17. ****1565339644215[traceId:1],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo3.dao(Demo3.java:56):插入数据数据1成功
  18. ****1565339644215[traceId:4],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo3.controller(Demo3.java:41):接受请求
  19. ****1565339644215[traceId:3],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo3.controller(Demo3.java:41):接受请求
  20. ****1565339644215[traceId:4],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo3.service(Demo3.java:47):执行业务
  21. ****1565339644215[traceId:1],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo3.dao(Demo3.java:56):插入数据数据2成功
  22. ****1565339644215[traceId:4],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo3.dao(Demo3.java:53):执行数据库操作
  23. ****1565339644215[traceId:3],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo3.service(Demo3.java:47):执行业务
  24. ****1565339644215[traceId:4],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo3.dao(Demo3.java:56):插入数据数据0成功
  25. ****1565339644215[traceId:3],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo3.dao(Demo3.java:53):执行数据库操作
  26. ****1565339644215[traceId:4],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo3.dao(Demo3.java:56):插入数据数据1成功
  27. ****1565339644215[traceId:3],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo3.dao(Demo3.java:56):插入数据数据0成功
  28. ****1565339644215[traceId:4],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo3.dao(Demo3.java:56):插入数据数据2成功
  29. ****1565339644215[traceId:3],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo3.dao(Demo3.java:56):插入数据数据1成功
  30. ****1565339644215[traceId:3],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo3.dao(Demo3.java:56):插入数据数据2成功

可以看出输出和刚才使用traceId参数的方式结果一致，但是却简单了很多。不用去修改controller、service、dao代码了，风险也减少了很多。

代码中创建了一个ThreadLocal traceIdKD，这个对象用来操作Thread中一个口袋，用这个口袋来存放tranceId。在main方法中通过traceIdKD.set(traceId)方法将traceId放入口袋，log方法中通traceIdKD.get()获取口袋中的traceId，最后任务处理完之后，main中的finally中调用traceIdKD.remove();将口袋中的traceId清除。

ThreadLocal的官方API解释为：

“该类提供了线程局部 (thread-local) 变量。这些变量不同于它们的普通对应物，因为访问某个变量(通过其 get 或 set 方法)的每个线程都有自己的局部变量，它独立于变量的初始化副本。ThreadLocal 实例通常是类中的 private static 字段，它们希望将状态与某一个线程(例如，用户 ID 或事务 ID)相关联。”

InheritableThreadLocal

继续上面的实例，dao中循环处理dataList的内容，假如dataList处理比较耗时，我们想加快处理速度有什么办法么？大家已经想到了，用多线程并行处理dataList，那么我们把代码改一下，如下：


     
     
  1. package com.itsoku.chat24;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.concurrent.CountDownLatch;
  6. import java.util.concurrent.LinkedBlockingDeque;
  7. import java.util.concurrent.ThreadPoolExecutor;
  8. import java.util.concurrent.TimeUnit;
  9. import java.util.concurrent.atomic.AtomicInteger;
  11. /**
  12.  * 跟着阿里p7学并发，微信公众号：javacode2018
  13.  */
  14. public class Demo4 {
  16.     //创建一个操作Thread中存放请求任务追踪id口袋的对象
  17.     static ThreadLocal<String> traceIdKD = new ThreadLocal<>();
  19.     static AtomicInteger threadIndex = new AtomicInteger(1);
  20.     //创建处理请求的线程池子
  21.     static ThreadPoolExecutor disposeRequestExecutor = new ThreadPoolExecutor(3,
  22.             3,
  23.             60,
  24.             TimeUnit.SECONDS,
  25.             new LinkedBlockingDeque<>(),
  26.             r -> {
  27.                 Thread thread = new Thread(r);
  28.                 thread.setName("disposeRequestThread-" + threadIndex.getAndIncrement());
  29.                 return thread;
  30.             });
  32.     //记录日志
  33.     public static void log(String msg) {
  34.         StackTraceElement stack[] = (new Throwable()).getStackTrace();
  35.         //获取当前线程存放tranceId口袋中的内容
  36.         String traceId = traceIdKD.get();
  37.         System.out.println("****" + System.currentTimeMillis() + "[traceId:" + traceId + "],[线程:" + Thread.currentThread().getName() + "]," + stack[1] + ":" + msg);
  38.     }
  40.     //模拟controller
  41.     public static void controller(List<String> dataList) {
  42.         log("接受请求");
  43.         service(dataList);
  44.     }
  46.     //模拟service
  47.     public static void service(List<String> dataList) {
  48.         log("执行业务");
  49.         dao(dataList);
  50.     }
  52.     //模拟dao
  53.     public static void dao(List<String> dataList) {
  54.         CountDownLatch countDownLatch = new CountDownLatch(dataList.size());
  56.         log("执行数据库操作");
  57.         String threadName = Thread.currentThread().getName();
  58.         //模拟插入数据
  59.         for (String s : dataList) {
  60.             new Thread(() -> {
  61.                 try {
  62.                     //模拟数据库操作耗时100毫秒
  63.                     TimeUnit.MILLISECONDS.sleep(100);
  64.                     log("插入数据" + s + "成功,主线程：" + threadName);
  65.                 } catch (InterruptedException e) {
  66.                     e.printStackTrace();
  67.                 } finally {
  68.                     countDownLatch.countDown();
  69.                 }
  70.             }).start();
  71.         }
  72.         //等待上面的dataList处理完毕
  73.         try {
  74.             countDownLatch.await();
  75.         } catch (InterruptedException e) {
  76.             e.printStackTrace();
  77.         }
  78.     }
  80.     public static void main(String[] args) {
  81.         //需要插入的数据
  82.         List<String> dataList = new ArrayList<>();
  83.         for (int i = 0; i < 3; i++) {
  84.             dataList.add("数据" + i);
  85.         }
  87.         //模拟5个请求
  88.         int requestCount = 5;
  89.         for (int i = 0; i < requestCount; i++) {
  90.             String traceId = String.valueOf(i);
  91.             disposeRequestExecutor.execute(() -> {
  92.                 //把traceId放入口袋中
  93.                 traceIdKD.set(traceId);
  94.                 try {
  95.                     controller(dataList);
  96.                 } finally {
  97.                     //将tranceId从口袋中移除
  98.                     traceIdKD.remove();
  99.                 }
  100.             });
  101.         }
  103.         disposeRequestExecutor.shutdown();
  104.     }
  105. }

输出：


     
     
  1. ****1565339904279[traceId:0],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo4.controller(Demo4.java:42):接受请求
  2. ****1565339904279[traceId:0],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo4.service(Demo4.java:48):执行业务
  3. ****1565339904279[traceId:1],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo4.controller(Demo4.java:42):接受请求
  4. ****1565339904279[traceId:1],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo4.service(Demo4.java:48):执行业务
  5. ****1565339904279[traceId:2],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo4.controller(Demo4.java:42):接受请求
  6. ****1565339904279[traceId:2],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo4.service(Demo4.java:48):执行业务
  7. ****1565339904279[traceId:0],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo4.dao(Demo4.java:56):执行数据库操作
  8. ****1565339904279[traceId:1],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo4.dao(Demo4.java:56):执行数据库操作
  9. ****1565339904279[traceId:2],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo4.dao(Demo4.java:56):执行数据库操作
  10. ****1565339904281[traceId:null],[线程:Thread-3],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:62):插入数据数据0成功,主线程：disposeRequestThread-1
  11. ****1565339904281[traceId:null],[线程:Thread-5],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:62):插入数据数据0成功,主线程：disposeRequestThread-2
  12. ****1565339904281[traceId:null],[线程:Thread-4],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:62):插入数据数据0成功,主线程：disposeRequestThread-3
  13. ****1565339904281[traceId:null],[线程:Thread-6],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:62):插入数据数据1成功,主线程：disposeRequestThread-3
  14. ****1565339904281[traceId:null],[线程:Thread-9],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:62):插入数据数据2成功,主线程：disposeRequestThread-3
  15. ****1565339904282[traceId:null],[线程:Thread-8],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:62):插入数据数据1成功,主线程：disposeRequestThread-1
  16. ****1565339904282[traceId:null],[线程:Thread-10],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:62):插入数据数据2成功,主线程：disposeRequestThread-1
  17. ****1565339904282[traceId:3],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo4.controller(Demo4.java:42):接受请求
  18. ****1565339904282[traceId:null],[线程:Thread-7],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:62):插入数据数据1成功,主线程：disposeRequestThread-2
  19. ****1565339904282[traceId:null],[线程:Thread-11],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:62):插入数据数据2成功,主线程：disposeRequestThread-2
  20. ****1565339904282[traceId:3],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo4.service(Demo4.java:48):执行业务
  21. ****1565339904282[traceId:4],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo4.controller(Demo4.java:42):接受请求
  22. ****1565339904283[traceId:3],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo4.dao(Demo4.java:56):执行数据库操作
  23. ****1565339904283[traceId:4],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo4.service(Demo4.java:48):执行业务
  24. ****1565339904283[traceId:4],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo4.dao(Demo4.java:56):执行数据库操作
  25. ****1565339904283[traceId:null],[线程:Thread-12],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:62):插入数据数据0成功,主线程：disposeRequestThread-3
  26. ****1565339904283[traceId:null],[线程:Thread-13],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:62):插入数据数据1成功,主线程：disposeRequestThread-3
  27. ****1565339904283[traceId:null],[线程:Thread-14],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:62):插入数据数据0成功,主线程：disposeRequestThread-1
  28. ****1565339904284[traceId:null],[线程:Thread-15],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:62):插入数据数据2成功,主线程：disposeRequestThread-3
  29. ****1565339904284[traceId:null],[线程:Thread-17],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:62):插入数据数据2成功,主线程：disposeRequestThread-1
  30. ****1565339904284[traceId:null],[线程:Thread-16],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:62):插入数据数据1成功,主线程：disposeRequestThread-1

看一下上面的输出，有些traceId为null，这是为什么呢？这是因为dao中为了提升处理速度，创建了子线程来并行处理，子线程调用log的时候，去自己的存放traceId的口袋中拿去东西，肯定是空的了。

那有什么办法么？可不可以这样？

父线程相当于主管，子线程相当于干活的小弟，主管让小弟们干活的时候，将自己兜里面的东西复制一份给小弟们使用，主管兜里面可能有很多牛逼的工具，为了提升小弟们的工作效率，给小弟们都复制一个，丢到小弟们的兜里，然后小弟就可以从自己的兜里拿去这些东西使用了，也可以清空自己兜里面的东西。

Thread对象中有个inheritableThreadLocals变量，代码如下：


     
     
  1. ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

inheritableThreadLocals相当于线程中另外一种兜，这种兜有什么特征呢，当创建子线程的时候，子线程会将父线程这种类型兜的东西全部复制一份放到自己的inheritableThreadLocals兜中，使用InheritableThreadLocal对象可以操作线程中的inheritableThreadLocals兜。

InheritableThreadLocal常用的方法也有3个：


     
     
  1. //向Thread中某个口袋中放东西
  2. public void set(T value);
  3. //获取这个口袋中目前放的东西
  4. public T get();
  5. //清空这个口袋中放的东西
  6. public void remove()

使用InheritableThreadLocal解决上面子线程中无法输出traceId的问题，只需要将上一个示例代码中的ThreadLocal替换成InheritableThreadLocal即可，代码如下：


     
     
  1. package com.itsoku.chat24;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.concurrent.CountDownLatch;
  6. import java.util.concurrent.LinkedBlockingDeque;
  7. import java.util.concurrent.ThreadPoolExecutor;
  8. import java.util.concurrent.TimeUnit;
  9. import java.util.concurrent.atomic.AtomicInteger;
  11. /**
  12.  * 跟着阿里p7学并发，微信公众号：javacode2018
  13.  */
  14. public class Demo4 {
  16.     //创建一个操作Thread中存放请求任务追踪id口袋的对象,子线程可以继承父线程中内容
  17.     static InheritableThreadLocal<String> traceIdKD = new InheritableThreadLocal<>();
  19.     static AtomicInteger threadIndex = new AtomicInteger(1);
  20.     //创建处理请求的线程池子
  21.     static ThreadPoolExecutor disposeRequestExecutor = new ThreadPoolExecutor(3,
  22.             3,
  23.             60,
  24.             TimeUnit.SECONDS,
  25.             new LinkedBlockingDeque<>(),
  26.             r -> {
  27.                 Thread thread = new Thread(r);
  28.                 thread.setName("disposeRequestThread-" + threadIndex.getAndIncrement());
  29.                 return thread;
  30.             });
  32.     //记录日志
  33.     public static void log(String msg) {
  34.         StackTraceElement stack[] = (new Throwable()).getStackTrace();
  35.         //获取当前线程存放tranceId口袋中的内容
  36.         String traceId = traceIdKD.get();
  37.         System.out.println("****" + System.currentTimeMillis() + "[traceId:" + traceId + "],[线程:" + Thread.currentThread().getName() + "]," + stack[1] + ":" + msg);
  38.     }
  40.     //模拟controller
  41.     public static void controller(List<String> dataList) {
  42.         log("接受请求");
  43.         service(dataList);
  44.     }
  46.     //模拟service
  47.     public static void service(List<String> dataList) {
  48.         log("执行业务");
  49.         dao(dataList);
  50.     }
  52.     //模拟dao
  53.     public static void dao(List<String> dataList) {
  54.         CountDownLatch countDownLatch = new CountDownLatch(dataList.size());
  56.         log("执行数据库操作");
  57.         String threadName = Thread.currentThread().getName();
  58.         //模拟插入数据
  59.         for (String s : dataList) {
  60.             new Thread(() -> {
  61.                 try {
  62.                     //模拟数据库操作耗时100毫秒
  63.                     TimeUnit.MILLISECONDS.sleep(100);
  64.                     log("插入数据" + s + "成功,主线程：" + threadName);
  65.                 } catch (InterruptedException e) {
  66.                     e.printStackTrace();
  67.                 } finally {
  68.                     countDownLatch.countDown();
  69.                 }
  70.             }).start();
  71.         }
  72.         //等待上面的dataList处理完毕
  73.         try {
  74.             countDownLatch.await();
  75.         } catch (InterruptedException e) {
  76.             e.printStackTrace();
  77.         }
  78.     }
  80.     public static void main(String[] args) {
  81.         //需要插入的数据
  82.         List<String> dataList = new ArrayList<>();
  83.         for (int i = 0; i < 3; i++) {
  84.             dataList.add("数据" + i);
  85.         }
  87.         //模拟5个请求
  88.         int requestCount = 5;
  89.         for (int i = 0; i < requestCount; i++) {
  90.             String traceId = String.valueOf(i);
  91.             disposeRequestExecutor.execute(() -> {
  92.                 //把traceId放入口袋中
  93.                 traceIdKD.set(traceId);
  94.                 try {
  95.                     controller(dataList);
  96.                 } finally {
  97.                     //将tranceId从口袋中移除
  98.                     traceIdKD.remove();
  99.                 }
  100.             });
  101.         }
  103.         disposeRequestExecutor.shutdown();
  104.     }
  105. }

输出：


     
     
  1. ****1565341611454[traceId:1],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo4.controller(Demo4.java:42):接受请求
  2. ****1565341611454[traceId:2],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo4.controller(Demo4.java:42):接受请求
  3. ****1565341611454[traceId:0],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo4.controller(Demo4.java:42):接受请求
  4. ****1565341611454[traceId:2],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo4.service(Demo4.java:48):执行业务
  5. ****1565341611454[traceId:1],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo4.service(Demo4.java:48):执行业务
  6. ****1565341611454[traceId:0],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo4.service(Demo4.java:48):执行业务
  7. ****1565341611454[traceId:2],[线程:disposeRequestThread-3],com.itsoku.chat24.Demo4.dao(Demo4.java:56):执行数据库操作
  8. ****1565341611454[traceId:1],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo4.dao(Demo4.java:56):执行数据库操作
  9. ****1565341611454[traceId:0],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo4.dao(Demo4.java:56):执行数据库操作
  10. ****1565341611557[traceId:2],[线程:Thread-5],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:64):插入数据数据0成功,主线程：disposeRequestThread-3
  11. ****1565341611557[traceId:0],[线程:Thread-4],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:64):插入数据数据0成功,主线程：disposeRequestThread-1
  12. ****1565341611557[traceId:1],[线程:Thread-11],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:64):插入数据数据2成功,主线程：disposeRequestThread-2
  13. ****1565341611557[traceId:1],[线程:Thread-3],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:64):插入数据数据0成功,主线程：disposeRequestThread-2
  14. ****1565341611557[traceId:1],[线程:Thread-8],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:64):插入数据数据1成功,主线程：disposeRequestThread-2
  15. ****1565341611557[traceId:0],[线程:Thread-6],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:64):插入数据数据1成功,主线程：disposeRequestThread-1
  16. ****1565341611557[traceId:0],[线程:Thread-10],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:64):插入数据数据2成功,主线程：disposeRequestThread-1
  17. ****1565341611557[traceId:3],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo4.controller(Demo4.java:42):接受请求
  18. ****1565341611557[traceId:2],[线程:Thread-9],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:64):插入数据数据2成功,主线程：disposeRequestThread-3
  19. ****1565341611558[traceId:2],[线程:Thread-7],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:64):插入数据数据1成功,主线程：disposeRequestThread-3
  20. ****1565341611557[traceId:3],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo4.service(Demo4.java:48):执行业务
  21. ****1565341611557[traceId:4],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo4.controller(Demo4.java:42):接受请求
  22. ****1565341611558[traceId:3],[线程:disposeRequestThread-2],com.itsoku.chat24.Demo4.dao(Demo4.java:56):执行数据库操作
  23. ****1565341611558[traceId:4],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo4.service(Demo4.java:48):执行业务
  24. ****1565341611558[traceId:4],[线程:disposeRequestThread-1],com.itsoku.chat24.Demo4.dao(Demo4.java:56):执行数据库操作
  25. ****1565341611659[traceId:3],[线程:Thread-15],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:64):插入数据数据2成功,主线程：disposeRequestThread-2
  26. ****1565341611659[traceId:4],[线程:Thread-14],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:64):插入数据数据0成功,主线程：disposeRequestThread-1
  27. ****1565341611659[traceId:3],[线程:Thread-13],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:64):插入数据数据1成功,主线程：disposeRequestThread-2
  28. ****1565341611659[traceId:3],[线程:Thread-12],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:64):插入数据数据0成功,主线程：disposeRequestThread-2
  29. ****1565341611660[traceId:4],[线程:Thread-16],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:64):插入数据数据1成功,主线程：disposeRequestThread-1
  30. ****1565341611660[traceId:4],[线程:Thread-17],com.itsoku.chat24.Demo4.lambda$dao$1(Demo4.java:64):插入数据数据2成功,主线程：disposeRequestThread-1

输出中都有traceId了，和期望的结果一致。

希望通过这篇文章可以学会使用InheritableThreadLocal和InheritableThreadLocal。有问题可以加我微信itsoku交流，也可以留言，谢谢。

来源：http://itsoku.com/course/1/24
「已注销」
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java 并发编程之ThreadLocal详解及实例
08-31
ThreadLocal 是 Java 中一个强大的工具，它允许在多线程环境中为每个线程维护独立的、私有的变量副本。在并发编程中，ThreadLocal 提供了一种线程间数据隔离的解决方案，避免了传统共享变量带来的同步问题。下面将...
实例讲解Java并发编程之ThreadLocal类
09-03
Java并发编程中的ThreadLocal类是一个非常重要的工具，它允许我们在多线程环境下为每个线程维护独立的变量副本，从而避免了线程间的数据共享和同步问题。ThreadLocal并不是一个线程，而是一个线程局部变量的容器。...
Java多线程--InheritableThreadLocal的用法(有实例)
IT利刃出鞘的博客
09-25 2356
本文介绍InheritableThreadLocal的用法。 ThreadLocal可以将数据绑定当前线程，如果希望当前线程的ThreadLocal的数据被子线程使用，实现方式就会相当困难（需要用户自己在代码中传递）。 InheritableThreadLocal可以方便地让子线程自动获取父线程ThreadLocal的数据。......
Java 类InheritableThreadLocal的使用
抛弃幻想，准备斗争
03-23 722
一、类InheritableThreadLocal的使用。 使用类InheritableThreadLocal可以在子线程中取得父线程继承下来的值。 1.值继承: 值继承再修改： 如果在继承的同时还可以对值进行进一步的处理那就更好了。 往InheritableThreadLocalExt类中添加如下代码： 注意： 在使用InheritableThreadLocal类时，如果子线程在取...
java中ThreadLocal、InheritableThreadLocal详解
OceanSky的专栏
11-11 4352
一、ThreadLocal介绍 ​ 在多线程环境下访问同一个线程的时候会出现并发问题，特别是多个线程同时对一个变量进行写入操作时，为了保证线程的安全，通常会进行加锁来保证线程的安全，但是加锁又会造成效率的降低；ThreadLocal是jdk提供的除了加锁之外保证线程安全的方法，其实现原理是在Thread类中定义了两个ThreadLocalMap类型变量threadLocals、inheritableThreadLocals用来存储当前操作的ThreadLocal的引用及变量对象，这样就可以把当前线程的变
InheritableThreadLocal链路追踪在线程池下问题
阿拉斯加大闸蟹的博客
09-16 1574
摘自我球的docs文档，我没时间在CSDN上再写一份，见 问题描述： 在业务的service实现中，有两个接口的方法使用了同一个线程池，在一次log的error报警中，出现了A方法对应的traceId不是A的controller，而是B的controller。原因就是A和B公用了同一个线程池，spring注入的那个 后来写了下面的代码： import com.alibaba.ttl....
【JUC并发编程】8 InheritableThreadLocal（可继承的ThreadLocal）详解
健身变秃，coding变强
05-02 2604
InheritableThreadLocal（可继承的ThreadLocal）详解？ 为什么InheritableThreadLocal可以实现父子线程变量的共享？ InheritableThreadLocal和ThreadLocal的区别是什么？
Java并发编程学习之ThreadLocal源码详析
08-27
Java并发编程学习之ThreadLocal源码详析 ThreadLocal是Java并发编程中的一种机制，用于解决多线程访问共享变量的问题。它可以使每个线程对共享变量的访问都是线程安全的，使得多线程编程变得更加简单。 ...
Java并发编实践之ThreadLocal变量.doc
09-30
Java并发编程实践中，ThreadLocal变量是一个非常重要的工具，它在JDK1.2版本就已经引入。ThreadLocal不是代表一个线程实例，而是一种线程局部变量的机制，它为每个线程提供了一个独立的变量副本，各个线程可以独立地...
java高并发视频讲解
08-03
Java高并发编程是Java开发中的重要领域，尤其在大规模分布式系统和互联网应用中，对高并发处理能力的需求日益增加。本视频讲解旨在帮助开发者深入理解Java架构，并系统性地学习如何在Java环境中处理高并发问题。 ...
ThreadLocal分析五：InheritableThreadLocal
Chen_leilei的博客
12-15 3897
通过上面几篇文章的分析，大家已经了解了threadlocal的数据结构，以及源码分析。但是他有什么缺点呢？ 答案是threadlocal不能在父子线程中线程之间传递 public class ThreadLocalTest { private static ThreadLocal<Integer> threadLocal = new ThreadLocal<>(); public static void main(String[] args) {
InheritableThreadLocal——父线程传递本地变量到子线程的解决方式及分析
热门推荐
代码小司机
05-29 5万+
上一个博客提到ThreadLocal变量的基本使用方式，可以看出ThreadLocal是相对于每一个线程自己使用的本地变量，但是在实际的开发中，有这样的一种需求：父线程生成的变量需要传递到子线程中进行使用，那么在使用ThreadLocal似乎就解决不了这个问题，难道这个业务就没办法使用这个本地变量了吗？答案肯定是否定的，ThreadLocal有一个子类InheritableThreadLo...
解决InheritableThreadLocal线程池复用线程时，取值错误
疯狂撸代码的奋青博客
03-22 2649
解决InheritableThreadLocal线程池复用线程时，取值错误
多线程热知识（二）：异步线程变量传递必知必会---InheritableThreadLocal及底层原理分析
Laugh_xiaoao的博客
02-20 1146
在不依赖于线程池的场景下，ITL是一个很好的实现异步线程传递变量的工具。然而，在使用线程池的情况下，由于线程不会进行频繁地初始化和销毁等工作，ITL的变量值无法得到更新，因而有可能存在数据错误传递的问题。
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1157
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
redis+spring面试题
github_36510643的博客
07-21 419
redis+spring面试题
Java-Lambda
lizhiwei21的博客
07-21 458
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Java内存模型
weixin_44267758的博客
07-19 797
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Java高并发编程探索：线程池与源码分析
本书针对高并发编程进行了深入探讨，旨在帮助读者理解和掌握在Java环境中处理并发问题的方法。 书中首先提出了一个问题：程序员是否需要阅读源码。作者认为理解源码对于深入学习并发编程至关重要，因为这有助于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值