点击收藏
00 月 00 00:00:00 周几
JSON在线格式化校验工具 - www.qjson.cn

ThreadLocal不好用？那是你没用对！

前端 2023-07-05 17:29:38
90阅读

在 Java 中，假如要问哪一个类应用简易，但用好最不容易?估计你的脑子里一定会闪过出一次词——“ThreadLocal”。

的确这般，ThreadLocal 本来设计方案是为了更好地处理高并发时，进程共享资源自变量的难题，但因为过多设计方案，如弱引用和哈希碰撞，进而造成它的了解难度系数金刚级应用成本费高难题。自然，假如稍不留神或是造成脏数据、内存溢出、共享资源自变量升级等难题，但即使如此，ThreadLocal 依然有合适自身的应用情景，及其无可替代的使用价值，例如文中要详细介绍了这二种应用情景，除开 ThreadLocal 以外，还真沒有适合的取代计划方案。

应用情景1：当地自变量

大家以线程同步恢复出厂设置時间为例子，来演试 ThreadLocal 的使用价值和功效，在我们在好几个进程中恢复出厂设置時间时，一般 会那样实际操作。

① 两个进程恢复出厂设置

当有 2 个进程开展时间格式化时，我们可以那样写：

 
    
  
  1. import java.text.SimpleDateFormat; 
    2. 
  
  2. import java.util.Date; 
    3. 
  
  3.  
    4. 
  
  4. public class Test { 
    5. 
  
  5.     public static void main(String[] args) throws InterruptedException { 
    6. 
  
  6.         // 建立并运行进程1 
    7. 
  
  7.         Thread t1 = new Thread(new Runnable() { 
    8. 
  
  8.             @Override 
    9. 
  
  9.             public void run() { 
    10. 
  
  10.                 // 获得時间目标 
    11. 
  
  11.                 Date date = new Date(1 * 1000); 
    12. 
  
  12.                 // 实行时间格式化 
    13. 
  
  13.                 formatAndPrint(date); 
    14. 
  
  14.             } 
    15. 
  
  15.         }); 
    16. 
  
  16.         t1.start(); 
    17. 
  
  17.         // 建立并运行进程2 
    18. 
  
  18.         Thread t2 = new Thread(new Runnable() { 
    19. 
  
  19.             @Override 
    20. 
  
  20.             public void run() { 
    21. 
  
  21.                 // 获得時间目标 
    22. 
  
  22.                 Date date = new Date(2 * 1000); 
    23. 
  
  23.                 // 实行时间格式化 
    24. 
  
  24.                 formatAndPrint(date); 
    25. 
  
  25.             } 
    26. 
  
  26.         }); 
    27. 
  
  27.         t2.start(); 
    28. 
  
  28.     } 
    29. 
  
  29.  
    30. 
  
  30.     /** 
    31. 
  
  31.      * 恢复出厂设置并打印結果 
    32. 
  
  32.      * @param date 時间目标 
    33. 
  
  33.      */ 
    34. 
  
  34.     private static void formatAndPrint(Date date) { 
    35. 
  
  35.         // 恢复出厂设置時间目标 
    36. 
  
  36.         SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss"); 
    37. 
  
  37.         // 实行恢复出厂设置 
    38. 
  
  38.         String result = simpleDateFormat.format(date); 
    39. 
  
  39.         // 打印出最后結果 
    40. 
  
  40.         System.out.println("時间："   result); 
    41. 
  
  41.     } 
    42. 
  
  42. } 
    43.

之上程序流程的实行結果为：

上边的编码由于建立的进程总数并不是很多，因此我们可以给每一个进程建立一个独享目标 SimpleDateFormat 来开展时间格式化。

② 10个进程恢复出厂设置

当进程的总数从 2 个升級为 10 个时，我们可以应用 for 循环系统来建立好几个进程实行时间格式化，实际完成编码以下：

 
    
  
  1. import java.text.SimpleDateFormat; 
    2. 
  
  2. import java.util.Date; 
    3. 
  
  3.  
    4. 
  
  4. public class Test { 
    5. 
  
  5.     public static void main(String[] args) throws InterruptedException { 
    6. 
  
  6.         for (int i = 0; i < 10; i  ) { 
    7. 
  
  7.             int finalI = i; 
    8. 
  
  8.             // 建立进程 
    9. 
  
  9.             Thread thread = new Thread(new Runnable() { 
    10. 
  
  10.                 @Override 
    11. 
  
  11.                 public void run() { 
    12. 
  
  12.                     // 获得時间目标 
    13. 
  
  13.                     Date date = new Date(finalI * 1000); 
    14. 
  
  14.                     // 实行时间格式化 
    15. 
  
  15.                     formatAndPrint(date); 
    16. 
  
  16.                 } 
    17. 
  
  17.             }); 
    18. 
  
  18.             // 运行进程 
    19. 
  
  19.             thread.start(); 
    20. 
  
  20.         } 
    21. 
  
  21.     } 
    22. 
  
  22.     /** 
    23. 
  
  23.      * 恢复出厂设置并打印時间 
    24. 
  
  24.      * @param date 時间目标 
    25. 
  
  25.      */ 
    26. 
  
  26.     private static void formatAndPrint(Date date) { 
    27. 
  
  27.         // 恢复出厂设置時间目标 
    28. 
  
  28.         SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss"); 
    29. 
  
  29.         // 实行恢复出厂设置 
    30. 
  
  30.         String result = simpleDateFormat.format(date); 
    31. 
  
  31.         // 打印出最后結果 
    32. 
  
  32.         System.out.println("時间："   result); 
    33. 
  
  33.     } 
    34. 
  
  34. } 
    35.

之上程序流程的实行結果为：

从以上結果能够看得出，尽管这时建立的线程数和 SimpleDateFormat 的总数算不上少，但程序流程或是能够一切正常运作的。

③ 1000个进程恢复出厂设置

殊不知在我们将进程的总数从 10 个变为 1000 个的情况下，大家就不可以单纯性的应用 for 循环系统来建立 1000 个进程的方法来解决困难了，由于那样经常的新创建和消毁进程会导致很多的系统软件花销和进程过多争夺 CPU 資源的难题。

因此历经一番思索后，我们决定应用线程池来实行这 1000 次的每日任务，由于线程池能够多路复用进程資源，不用经常的新创建和消毁进程，还可以根据操纵线程池中进程的总数来防止过线程同步所造成的 CPU 資源过多争夺和进程经常转换所导致的特性难题，并且我们可以将 SimpleDateFormat 提高为全局变量，进而防止每一次实行都需要新创建 SimpleDateFormat 的难题，因此大家写出了那样的编码：

 
    
  
  1. import java.text.SimpleDateFormat; 
    2. 
  
  2. import java.util.Date; 
    3. 
  
  3. import java.util.concurrent.LinkedBlockingQueue; 
    4. 
  
  4. import java.util.concurrent.ThreadPoolExecutor; 
    5. 
  
  5. import java.util.concurrent.TimeUnit; 
    6. 
  
  6.  
    7. 
  
  7. public class App { 
    8. 
  
  8.     // 时间格式化目标 
    9. 
  
  9.     private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss"); 
    10. 
  
  10.  
    11. 
  
  11.     public static void main(String[] args) throws InterruptedException { 
    12. 
  
  12.         // 建立线程池执行任务 
    13. 
  
  13.         ThreadPoolExecutor threadPool = new ThreadPoolExecutor(10, 10, 60, 
    14. 
  
  14.                 TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000)); 
    15. 
  
  15.         for (int i = 0; i < 1000; i  ) { 
    16. 
  
  16.             int finalI = i; 
    17. 
  
  17.             // 执行任务 
    18. 
  
  18.             threadPool.execute(new Runnable() { 
    19. 
  
  19.                 @Override 
    20. 
  
  20.                 public void run() { 
    21. 
  
  21.                     // 获得時间目标 
    22. 
  
  22.                     Date date = new Date(finalI * 1000); 
    23. 
  
  23.                     // 实行时间格式化 
    24. 
  
  24.                     formatAndPrint(date); 
    25. 
  
  25.                 } 
    26. 
  
  26.             }); 
    27. 
  
  27.         } 
    28. 
  
  28.         // 线程池实行完每日任务以后关掉 
    29. 
  
  29.         threadPool.shutdown(); 
    30. 
  
  30.     } 
    31. 
  
  31.  
    32. 
  
  32.     /** 
    33. 
  
  33.      * 恢复出厂设置并打印時间 
    34. 
  
  34.      * @param date 時间目标 
    35. 
  
  35.      */ 
    36. 
  
  36.     private static void formatAndPrint(Date date) { 
    37. 
  
  37.         // 实行恢复出厂设置 
    38. 
  
  38.         String result = simpleDateFormat.format(date); 
    39. 
  
  39.         // 打印出最后結果 
    40. 
  
  40.         System.out.println("時间："   result); 
    41. 
  
  41.     } 
    42. 
  
  42. } 
    43.

之上程序流程的实行結果为：

在我们满怀极其愉悦的情绪去运作程序流程的情况下，却发觉出现意外发生了，那样敲代码居然会发生线程安全的难题。从以上結果能够看得出，程序流程的打印出結果居然有反复內容的，恰当的状况应该是沒有反复的時间才对。

PS：说白了的线程安全难题就是指：在线程同步的实行中，程序流程的实行結果与预期成果不相符合的状况。

a) 线程安全问题分析

为了更好地寻找存在的问题，大家试着查询 SimpleDateFormat 中 format 方式的源代码来清查一下难题，format 源代码以下：

 
    
  
  1. private StringBuffer format(Date date, StringBuffer toAppendTo, 
    2. 
  
  2.                                 FieldDelegate delegate) { 
    3. 
  
  3.     // 留意此番编码 
    4. 
  
  4.     calendar.setTime(date); 
    5. 
  
  5.  
    6. 
  
  6.     boolean useDateFormatSymbols = useDateFormatSymbols(); 
    7. 
  
  7.  
    8. 
  
  8.     for (int i = 0; i < compiledPattern.length; ) { 
    9. 
  
  9.         int tag = compiledPattern[i] >>> 8; 
    10. 
  
  10.         int count = compiledPattern[i  ] & 0xff; 
    11. 
  
  11.         if (count == 255) { 
    12. 
  
  12.             count = compiledPattern[i  ] << 16; 
    13. 
  
  13.             count |= compiledPattern[i  ]; 
    14. 
  
  14.         } 
    15. 
  
  15.  
    16. 
  
  16.         switch (tag) { 
    17. 
  
  17.             case TAG_QUOTE_ASCII_CHAR: 
    18. 
  
  18.                 toAppendTo.append((char)count); 
    19. 
  
  19.                 break; 
    20. 
  
  20.  
    21. 
  
  21.             case TAG_QUOTE_CHARS: 
    22. 
  
  22.                 toAppendTo.append(compiledPattern, i, count); 
    23. 
  
  23.                 i  = count; 
    24. 
  
  24.                 break; 
    25. 
  
  25.  
    26. 
  
  26.             default: 
    27. 
  
  27.                 subFormat(tag, count, delegate, toAppendTo, useDateFormatSymbols); 
    28. 
  
  28.                 break; 
    29. 
  
  29.         } 
    30. 
  
  30.     } 
    31. 
  
  31.     return toAppendTo; 
    32. 
  
  32. } 
    33.

从以上源代码能够看得出，在实行 SimpleDateFormat.format 方式时，会应用 calendar.setTime 方式将键入的時间开展变换，那麼大家想一想一下那样的情景：

  1. 进程 1 实行了 calendar.setTime(date) 方式，将客户键入的時间转化成了后边恢复出厂设置时需必须的時间;
  2. 进程 1 中止实行，进程 2 获得 CPU 時间片逐渐实行;
  3. 进程 2 实行了 calendar.setTime(date) 方式，时间观念开展了改动;
  4. 进程 2 中止实行，进程 1 得到 CPU 時间片执行，由于进程 1 和进程 2 应用的是同一目标，而時间早已被进程 2 改动了，因此这时当进程 1 执行的情况下便会发生线程安全的难题了。

一切正常的状况下，程序流程的实行是那样的：

非线程安全的实行步骤是那样的：

b) 处理线程安全难题：上锁

当发生线程安全难题时，大家想起的第一解决方法便是上锁，实际的完成编码以下：

 
    
  
  1. import java.text.SimpleDateFormat; 
    2. 
  
  2. import java.util.Date; 
    3. 
  
  3. import java.util.concurrent.LinkedBlockingQueue; 
    4. 
  
  4. import java.util.concurrent.ThreadPoolExecutor; 
    5. 
  
  5. import java.util.concurrent.TimeUnit; 
    6. 
  
  6.  
    7. 
  
  7. public class App { 
    8. 
  
  8.     // 时间格式化目标 
    9. 
  
  9.     private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss"); 
    10. 
  
  10.  
    11. 
  
  11.     public static void main(String[] args) throws InterruptedException { 
    12. 
  
  12.         // 建立线程池执行任务 
    13. 
  
  13.         ThreadPoolExecutor threadPool = new ThreadPoolExecutor(10, 10, 60, 
    14. 
  
  14.                 TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000)); 
    15. 
  
  15.         for (int i = 0; i < 1000; i  ) { 
    16. 
  
  16.             int finalI = i; 
    17. 
  
  17.             // 执行任务 
    18. 
  
  18.             threadPool.execute(new Runnable() { 
    19. 
  
  19.                 @Override 
    20. 
  
  20.                 public void run() { 
    21. 
  
  21.                     // 获得時间目标 
    22. 
  
  22.                     Date date = new Date(finalI * 1000); 
    23. 
  
  23.                     // 实行时间格式化 
    24. 
  
  24.                     formatAndPrint(date); 
    25. 
  
  25.                 } 
    26. 
  
  26.             }); 
    27. 
  
  27.         } 
    28. 
  
  28.         // 线程池实行完每日任务以后关掉 
    29. 
  
  29.         threadPool.shutdown(); 
    30. 
  
  30.     } 
    31. 
  
  31.  
    32. 
  
  32.     /** 
    33. 
  
  33.      * 恢复出厂设置并打印時间 
    34. 
  
  34.      * @param date 時间目标 
    35. 
  
  35.      */ 
    36. 
  
  36.     private static void formatAndPrint(Date date) { 
    37. 
  
  37.         // 实行恢复出厂设置 
    38. 
  
  38.         String result = null; 
    39. 
  
  39.         // 上锁 
    40. 
  
  40.         synchronized (App.class) { 
    41. 
  
  41.             result = simpleDateFormat.format(date); 
    42. 
  
  42.         } 
    43. 
  
  43.         // 打印出最后結果 
    44. 
  
  44.         System.out.println("時间："   result); 
    45. 
  
  45.     } 
    46. 
  
  46. } 
    47.

之上程序流程的实行結果为：

从以上結果能够看得出，应用了 synchronized 上锁以后程序流程就可以一切正常的实行了。

上锁的缺陷

上锁的方法尽管能够处理线程安全的难题，但另外也产生了新的难题，当程序流程上锁以后，全部的进程务必排长队实行一些业务流程才行，那样无形之中就减少了程序流程的运作高效率了。

是否有既能处理线程安全难题，又能提升 程序流程的实行速率的解决方法呢?

回答是：有的，这个时候 ThreadLocal就需要出场了。

c) 处理线程安全难题：ThreadLocal

1.ThreadLocal 详细介绍

ThreadLocal 从字面上的含意来理解是进程当地自变量的含意，换句话说它是进程中的独享自变量，每一个进程只有应用自身的自变量。

以上边线程池恢复出厂设置時间为例子，当线程池中有 10 个进程时，SimpleDateFormat 会存进 ThreadLocal 中，它也总是建立 10 个目标，即便 要实行 1000 次时间格式化每日任务，仍然总是新创建 10 个 SimpleDateFormat 目标，每一个进程启用自身的 ThreadLocal 自变量。

2.ThreadLocal 基本应用

ThreadLocal 常见的关键方式有三个：

  1. set 方式：用以设定进程单独自变量团本。沒有 set 实际操作的 ThreadLocal 非常容易造成脏数据。
  2. get 方式：用以获得进程单独自变量团本。沒有 get 实际操作的 ThreadLocal 目标没有意义。
  3. remove 方式：用以清除进程单独自变量团本。沒有 remove 实际操作非常容易造成内存泄漏。

ThreadLocal 全部方式如下图所显示：

官方网表明文本文档：https://docs.oracle.com/javase/8/docs/api/

ThreadLocal 基本使用方法以下：

 
    
  
  1. /** 
    2. 
  
  2.  * @微信公众号：Java汉语社群营销 
    3. 
  
  3.  */ 
    4. 
  
  4. public class ThreadLocalExample { 
    5. 
  
  5.     // 建立一个 ThreadLocal 目标 
    6. 
  
  6.     private static ThreadLocal<String> threadLocal = new ThreadLocal<>(); 
    7. 
  
  7.  
    8. 
  
  8.     public static void main(String[] args) { 
    9. 
  
  9.         // 进程执行任务 
    10. 
  
  10.         Runnable runnable = new Runnable() { 
    11. 
  
  11.             @Override 
    12. 
  
  12.             public void run() { 
    13. 
  
  13.                 String threadName = Thread.currentThread().getName(); 
    14. 
  
  14.                 System.out.println(threadName   " 存进值："   threadName); 
    15. 
  
  15.                 // 在 ThreadLocal 中设定值 
    16. 
  
  16.                 threadLocal.set(threadName); 
    17. 
  
  17.                 // 实行方式，打印出进程中设定的值 
    18. 
  
  18.                 print(threadName); 
    19. 
  
  19.             } 
    20. 
  
  20.         }; 
    21. 
  
  21.         // 建立并运行进程 1 
    22. 
  
  22.         new Thread(runnable, "MyThread-1").start(); 
    23. 
  
  23.         // 建立并运行进程 2 
    24. 
  
  24.         new Thread(runnable, "MyThread-2").start(); 
    25. 
  
  25.     } 
    26. 
  
  26.  
    27. 
  
  27.     /** 
    28. 
  
  28.      * 打印出进程中的 ThreadLocal 值 
    29. 
  
  29.      * @param threadName 进程名字 
    30. 
  
  30.      */ 
    31. 
  
  31.     private static void print(String threadName) { 
    32. 
  
  32.         try { 
    33. 
  
  33.             // 获得 ThreadLocal 中的值 
    34. 
  
  34.             String result = threadLocal.get(); 
    35. 
  
  35.             // 打印出結果 
    36. 
  
  36.             System.out.println(threadName   " 取下值："   result); 
    37. 
  
  37.         } finally { 
    38. 
  
  38.             // 清除 ThreadLocal 中的值（避免 内存溢出） 
    39. 
  
  39.             threadLocal.remove(); 
    40. 
  
  40.         } 
    41. 
  
  41.     } 
    42. 
  
  42. } 
    43.

之上程序流程的实行結果为：

从以上結果能够看得出，每一个进程总是载入到归属于自身的 ThreadLocal 值。

3.ThreadLocal 高級使用方法

① 复位：initialValue

 
    
  
  1. public class ThreadLocalByInitExample { 
    2. 
  
  2.     // 界定 ThreadLocal 
    3. 
  
  3.     private static ThreadLocal<String> threadLocal = new ThreadLocal(){ 
    4. 
  
  4.         @Override 
    5. 
  
  5.         protected String initialValue() { 
    6. 
  
  6.             System.out.println("实行 initialValue() 方式"); 
    7. 
  
  7.             return "初始值"; 
    8. 
  
  8.         } 
    9. 
  
  9.     }; 
    10. 
  
  10.  
    11. 
  
  11.     public static void main(String[] args) { 
    12. 
  
  12.         // 进程执行任务 
    13. 
  
  13.         Runnable runnable = new Runnable() { 
    14. 
  
  14.             @Override 
    15. 
  
  15.             public void run() { 
    16. 
  
  16.                 // 实行方式，打印出进程中数据（未设定值打印出） 
    17. 
  
  17.                 print(threadName); 
    18. 
  
  18.             } 
    19. 
  
  19.         }; 
    20. 
  
  20.         // 建立并运行进程 1 
    21. 
  
  21.         new Thread(runnable, "MyThread-1").start(); 
    22. 
  
  22.         // 建立并运行进程 2 
    23. 
  
  23.         new Thread(runnable, "MyThread-2").start(); 
    24. 
  
  24.     } 
    25. 
  
  25.  
    26. 
  
  26.     /** 
    27. 
  
  27.      * 打印出进程中的 ThreadLocal 值 
    28. 
  
  28.      * @param threadName 进程名字 
    29. 
  
  29.      */ 
    30. 
  
  30.     private static void print(String threadName) { 
    31. 
  
  31.         // 获得 ThreadLocal 中的值 
    32. 
  
  32.         String result = threadLocal.get(); 
    33. 
  
  33.         // 打印出結果 
    34. 
  
  34.         System.out.println(threadName   " 获得值："   result); 
    35. 
  
  35.     } 
    36. 
  
  36. } 
    37.

之上程序流程的实行結果为：

当应用了 #threadLocal.set 方式以后，initialValue 方式就不容易强制执行了，以下编码所显示：

 
    
  
  1. public class ThreadLocalByInitExample { 
    2. 
  
  2.     // 界定 ThreadLocal 
    3. 
  
  3.     private static ThreadLocal<String> threadLocal = new ThreadLocal() { 
    4. 
  
  4.         @Override 
    5. 
  
  5.         protected String initialValue() { 
    6. 
  
  6.             System.out.println("实行 initialValue() 方式"); 
    7. 
  
  7.             return "初始值"; 
    8. 
  
  8.         } 
    9. 
  
  9.     }; 
    10. 
  
  10.  
    11. 
  
  11.     public static void main(String[] args) { 
    12. 
  
  12.         // 进程执行任务 
    13. 
  
  13.         Runnable runnable = new Runnable() { 
    14. 
  
  14.             @Override 
    15. 
  
  15.             public void run() { 
    16. 
  
  16.                 String threadName = Thread.currentThread().getName(); 
    17. 
  
  17.                 System.out.println(threadName   " 存进值："   threadName); 
    18. 
  
  18.                 // 在 ThreadLocal 中设定值 
    19. 
  
  19.                 threadLocal.set(threadName); 
    20. 
  
  20.                 // 实行方式，打印出进程中设定的值 
    21. 
  
  21.                 print(threadName); 
    22. 
  
  22.             } 
    23. 
  
  23.         }; 
    24. 
  
  24.         // 建立并运行进程 1 
    25. 
  
  25.         new Thread(runnable, "MyThread-1").start(); 
    26. 
  
  26.         // 建立并运行进程 2 
    27. 
  
  27.         new Thread(runnable, "MyThread-2").start(); 
    28. 
  
  28.     } 
    29. 
  
  29.  
    30. 
  
  30.     /** 
    31. 
  
  31.      * 打印出进程中的 ThreadLocal 值 
    32. 
  
  32.      * @param threadName 进程名字 
    33. 
  
  33.      */ 
    34. 
  
  34.     private static void print(String threadName) { 
    35. 
  
  35.         try { 
    36. 
  
  36.             // 获得 ThreadLocal 中的值 
    37. 
  
  37.             String result = threadLocal.get(); 
    38. 
  
  38.             // 打印出結果 
    39. 
  
  39.             System.out.println(threadName   "取下值："   result); 
    40. 
  
  40.         } finally { 
    41. 
  
  41.             // 清除 ThreadLocal 中的值（避免 内存溢出） 
    42. 
  
  42.             threadLocal.remove(); 
    43. 
  
  43.         } 
    44. 
  
  44.     } 
    45. 
  
  45. } 
    46.

之上程序流程的实行結果为：

为何 set 以后，复位编码也不实行了?

要了解这个问题，必须从 ThreadLocal.get() 方式的源代码中获得回答，由于复位方式 initialValue 在 ThreadLocal 建立时并不会立即执行，只是在启用了 get 方式总是才会实行，测试程序以下：

 
    
  
  1. import java.util.Date; 
    2. 
  
  2.  
    3. 
  
  3. public class ThreadLocalByInitExample { 
    4. 
  
  4.     // 界定 ThreadLocal 
    5. 
  
  5.     private static ThreadLocal<String> threadLocal = new ThreadLocal() { 
    6. 
  
  6.         @Override 
    7. 
  
  7.         protected String initialValue() { 
    8. 
  
  8.             System.out.println("实行 initialValue() 方式 "   new Date()); 
    9. 
  
  9.             return "初始值"; 
    10. 
  
  10.         } 
    11. 
  
  11.     }; 
    12. 
  
  12.     public static void main(String[] args) { 
    13. 
  
  13.         // 进程执行任务 
    14. 
  
  14.         Runnable runnable = new Runnable() { 
    15. 
  
  15.             @Override 
    16. 
  
  16.             public void run() { 
    17. 
  
  17.                 // 获得当今进程名字 
    18. 
  
  18.                 String threadName = Thread.currentThread().getName(); 
    19. 
  
  19.                 // 实行方式，打印出进程中设定的值 
    20. 
  
  20.                 print(threadName); 
    21. 
  
  21.             } 
    22. 
  
  22.         }; 
    23. 
  
  23.         // 建立并运行进程 1 
    24. 
  
  24.         new Thread(runnable, "MyThread-1").start(); 
    25. 
  
  25.         // 建立并运行进程 2 
    26. 
  
  26.         new Thread(runnable, "MyThread-2").start(); 
    27. 
  
  27.     } 
    28. 
  
  28.  
    29. 
  
  29.     /** 
    30. 
  
  30.      * 打印出进程中的 ThreadLocal 值 
    31. 
  
  31.      * @param threadName 进程名字 
    32. 
  
  32.      */ 
    33. 
  
  33.     private static void print(String threadName) { 
    34. 
  
  34.         System.out.println("进到 print() 方式 "   new Date()); 
    35. 
  
  35.         try { 
    36. 
  
  36.             // 休眠状态 1s 
    37. 
  
  37.             Thread.sleep(1000); 
    38. 
  
  38.         } catch (InterruptedException e) { 
    39. 
  
  39.             e.printStackTrace(); 
    40. 
  
  40.         } 
    41. 
  
  41.         // 获得 ThreadLocal 中的值 
    42. 
  
  42.         String result = threadLocal.get(); 
    43. 
  
  43.         // 打印出結果 
    44. 
  
  44.         System.out.println(String.format("%s 获得值：%s %s", 
    45. 
  
  45.                 threadName, result, new Date())); 
    46. 
  
  46.     } 
    47. 
  
  47. } 
    48.

之上程序流程的实行結果为：

从以上打印出的時间能够看得出：initialValue 方式并并不是在 ThreadLocal 建立时实行的，只是在启用 Thread.get 方式时才实行的。

下面看来 Threadlocal.get 源代码的完成：

 
    
  
  1. public T get() { 
    2. 
  
  2.     // 获得当今的进程 
    3. 
  
  3.     Thread t = Thread.currentThread(); 
    4. 
  
  4.     ThreadLocalMap map = getMap(t); 
    5. 
  
  5.     // 分辨 ThreadLocal 中是不是有数据信息 
    6. 
  
  6.     if (map != null) { 
    7. 
  
  7.         ThreadLocalMap.Entry e = map.getEntry(this); 
    8. 
  
  8.         if (e != null) { 
    9. 
  
  9.             @SuppressWarnings("unchecked") 
    10. 
  
  10.             T result = (T)e.value; 
    11. 
  
  11.             // 有 set 值，立即回到数据信息 
    12. 
  
  12.             return result; 
    13. 
  
  13.         } 
    14. 
  
  14.     } 
    15. 
  
  15.     // 实行复位方式【重点关注】 
    16. 
  
  16.     return setInitialValue(); 
    17. 
  
  17. } 
    18. 
  
  18. private T setInitialValue() { 
    19. 
  
  19.     // 实行复位方式【重点关注】 
    20. 
  
  20.     T value = initialValue(); 
    21. 
  
  21.     Thread t = Thread.currentThread(); 
    22. 
  
  22.     ThreadLocalMap map = getMap(t); 
    23. 
  
  23.     if (map != null) 
    24. 
  
  24.         map.set(this, value); 
    25. 
  
  25.     else 
    26. 
  
  26.         createMap(t, value); 
    27. 
  
  27.     return value; 
    28. 
  
  28. } 
    29.

从以上源代码能够看得出，当 ThreadLocal 中有值的时候会立即传参 e.value，仅有 Threadlocal 中沒有一切值时才会实行复位方式 initialValue。

常见问题—种类务必保持一致

留意在应用 initialValue 时，传参的种类要和 ThreadLoca 界定的基本数据类型保持一致，如下图所显示：

假如数据信息不一致便会导致 ClassCaseException 数据转换出现异常，如下图所显示：

② 复位2：withInitial

 
    
  
  1. import java.util.function.Supplier; 
    2. 
  
  2.  
    3. 
  
  3. public class ThreadLocalByInitExample { 
    4. 
  
  4.     // 界定 ThreadLocal 
    5. 
  
  5.     private static ThreadLocal<String> threadLocal = 
    6. 
  
  6.             ThreadLocal.withInitial(new Supplier<String>() { 
    7. 
  
  7.                 @Override 
    8. 
  
  8.                 public String get() { 
    9. 
  
  9.                     System.out.println("实行 withInitial() 方式"); 
    10. 
  
  10.                     return "初始值"; 
    11. 
  
  11.                 } 
    12. 
  
  12.             }); 
    13. 
  
  13.     public static void main(String[] args) { 
    14. 
  
  14.         // 进程执行任务 
    15. 
  
  15.         Runnable runnable = new Runnable() { 
    16. 
  
  16.             @Override 
    17. 
  
  17.             public void run() { 
    18. 
  
  18.                 String threadName = Thread.currentThread().getName(); 
    19. 
  
  19.                 // 实行方式，打印出进程中设定的值 
    20. 
  
  20.                 print(threadName); 
    21. 
  
  21.             } 
    22. 
  
  22.         }; 
    23. 
  
  23.         // 建立并运行进程 1 
    24. 
  
  24.         new Thread(runnable, "MyThread-1").start(); 
    25. 
  
  25.         // 建立并运行进程 2 
    26. 
  
  26.         new Thread(runnable, "MyThread-2").start(); 
    27. 
  
  27.     } 
    28. 
  
  28.  
    29. 
  
  29.     /** 
    30. 
  
  30.      * 打印出进程中的 ThreadLocal 值 
    31. 
  
  31.      * @param threadName 进程名字 
    32. 
  
  32.      */ 
    33. 
  
  33.     private static void print(String threadName) { 
    34. 
  
  34.         // 获得 ThreadLocal 中的值 
    35. 
  
  35.         String result = threadLocal.get(); 
    36. 
  
  36.         // 打印出結果 
    37. 
  
  37.         System.out.println(threadName   " 获得值："   result); 
    38. 
  
  38.     } 
    39. 
  
  39. } 
    40.

之上程序流程的实行結果为：

根据以上的编码发觉，withInitial 方式的应用好和 initialValue 仿佛没啥差别，那为什么也要造出2个相近的方式呢?客官莫心急，再次往下看。

③ 更简约的 withInitial 应用

withInitial 方式的优点取决于能够更简易的完成自变量复位，以下编码所显示：

 
    
  
  1. public class ThreadLocalByInitExample { 
    2. 
  
  2.     // 界定 ThreadLocal 
    3. 
  
  3.     private static ThreadLocal<String> threadLocal = ThreadLocal.withInitial(() -> "初始值"); 
    4. 
  
  4.     public static void main(String[] args) { 
    5. 
  
  5.         // 进程执行任务 
    6. 
  
  6.         Runnable runnable = new Runnable() { 
    7. 
  
  7.             @Override 
    8. 
  
  8.             public void run() { 
    9. 
  
  9.                 String threadName = Thread.currentThread().getName(); 
    10. 
  
  10.                 // 实行方式，打印出进程中设定的值 
    11. 
  
  11.                 print(threadName); 
    12. 
  
  12.             } 
    13. 
  
  13.         }; 
    14. 
  
  14.         // 建立并运行进程 1 
    15. 
  
  15.         new Thread(runnable, "MyThread-1").start(); 
    16. 
  
  16.         // 建立并运行进程 2 
    17. 
  
  17.         new Thread(runnable, "MyThread-2").start(); 
    18. 
  
  18.     } 
    19. 
  
  19.  
    20. 
  
  20.     /** 
    21. 
  
  21.      * 打印出进程中的 ThreadLocal 值 
    22. 
  
  22.      * @param threadName 进程名字 
    23. 
  
  23.      */ 
    24. 
  
  24.     private static void print(String threadName) { 
    25. 
  
  25.         // 获得 ThreadLocal 中的值 
    26. 
  
  26.         String result = threadLocal.get(); 
    27. 
  
  27.         // 打印出結果 
    28. 
  
  28.         System.out.println(threadName   " 获得值："   result); 
    29. 
  
  29.     } 
    30. 
  
  30. } 
    31.

之上程序流程的实行結果为：

4.ThreadLocal 版时间格式化

了解了 ThreadLocal 的应用以后，大家返回文中的主题风格，下面大家将应用 ThreadLocal 来完成 1000 个時间的恢复出厂设置，实际完成编码以下：

 
    
  
  1. import java.text.SimpleDateFormat; 
    2. 
  
  2. import java.util.Date; 
    3. 
  
  3. import java.util.concurrent.LinkedBlockingQueue; 
    4. 
  
  4. import java.util.concurrent.ThreadPoolExecutor; 
    5. 
  
  5. import java.util.concurrent.TimeUnit; 
    6. 
  
  6.  
    7. 
  
  7. public class MyThreadLocalByDateFormat { 
    8. 
  
  8.     // 建立 ThreadLocal 并设定初始值 
    9. 
  
  9.     private static ThreadLocal<SimpleDateFormat> dateFormatThreadLocal = 
    10. 
  
  10.             ThreadLocal.withInitial(() -> new SimpleDateFormat("mm:ss")); 
    11. 
  
  11.  
    12. 
  
  12.     public static void main(String[] args) { 
    13. 
  
  13.         // 建立线程池执行任务 
    14. 
  
  14.         ThreadPoolExecutor threadPool = new ThreadPoolExecutor(10, 10, 60, 
    15. 
  
  15.                 TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000)); 
    16. 
  
  16.         // 执行任务 
    17. 
  
  17.         for (int i = 0; i < 1000; i  ) { 
    18. 
  
  18.             int finalI = i; 
    19. 
  
  19.             // 执行任务 
    20. 
  
  20.             threadPool.execute(new Runnable() { 
    21. 
  
  21.                 @Override 
    22. 
  
  22.                 public void run() { 
    23. 
  
  23.                     // 获得時间目标 
    24. 
  
  24.                     Date date = new Date(finalI * 1000); 
    25. 
  
  25.                     // 实行时间格式化 
    26. 
  
  26.                     formatAndPrint(date); 
    27. 
  
  27.                 } 
    28. 
  
  28.             }); 
    29. 
  
  29.         } 
    30. 
  
  30.         // 线程池实行完每日任务以后关掉 
    31. 
  
  31.         threadPool.shutdown(); 
    32. 
  
  32.         // 线程池实行完每日任务以后关掉 
    33. 
  
  33.         threadPool.shutdown(); 
    34. 
  
  34.     } 
    35. 
  
  35.     /** 
    36. 
  
  36.      * 恢复出厂设置并打印時间 
    37. 
  
  37.      * @param date 時间目标 
    38. 
  
  38.      */ 
    39. 
  
  39.     private static void formatAndPrint(Date date) { 
    40. 
  
  40.         // 实行恢复出厂设置 
    41. 
  
  41.         String result = dateFormatThreadLocal.get().format(date); 
    42. 
  
  42.         // 打印出最后結果 
    43. 
  
  43.         System.out.println("時间："   result); 
    44. 
  
  44.     } 
    45. 
  
  45. } 
    46.

之上程序流程的实行結果为：

从以上結果能够看得出，应用 ThreadLocal 还可以处理进程高并发难题，而且防止了编码上锁排长队实行的难题。

应用情景2：跨类传递数据

除开上边的应用情景以外，大家还能够应用 ThreadLocal 来完成进程中跨类、跨方式的数据信息传送。例如登陆客户的 User 目标信息内容，大家必须在不一样的分系统中数次应用，假如应用传统式的方法，大家必须操作方法传参和传参的方法来传送 User 目标，殊不知那样就无形之中导致了类和类中间，乃至是系统软件和系统软件中间的互相藕合了，因此这时我们可以应用 ThreadLocal 来完成 User 目标的传送。

明确了计划方案以后，下面大家来完成实际的业务流程编码。我们可以先在主线任务程中结构并复位一个 User 目标，并将此 User 阿里云oss在 ThreadLocal 中，储存进行以后，大家就可以在同一个进程的别的类中，如仓储物流类或订单信息类中立即获得并应用 User 目标了，实际完成编码以下。

主线任务程中的业务流程编码：

 
    
  
  1. public class ThreadLocalByUser { 
    2. 
  
  2.     public static void main(String[] args) { 
    3. 
  
  3.         // 复位客户信息 
    4. 
  
  4.         User user = new User("Java"); 
    5. 
  
  5.         // 将 User 阿里云oss在 ThreadLocal 中 
    6. 
  
  6.         UserStorage.setUser(user); 
    7. 
  
  7.         // 启用订单管理系统 
    8. 
  
  8.         OrderSystem orderSystem = new OrderSystem(); 
    9. 
  
  9.         // 加上订单信息（方式内获得客户信息） 
    10. 
  
  10.         orderSystem.add(); 
    11. 
  
  11.         // 启用仓储管理系统 
    12. 
  
  12.         RepertorySystem repertory = new RepertorySystem(); 
    13. 
  
  13.         // 减库存量（方式内获得客户信息） 
    14. 
  
  14.         repertory.decrement(); 
    15. 
  
  15.     } 
    16. 
  
  16. } 
    17.

User dao层：

 
    
  
  1. /** 
    2. 
  
  2.  * 客户dao层 
    3. 
  
  3.  */ 
    4. 
  
  4. class User { 
    5. 
  
  5.     public User(String name) { 
    6. 
  
  6.         this.name = name; 
    7. 
  
  7.     } 
    8. 
  
  8.     private String name; 
    9. 
  
  9.     public String getName() { 
    10. 
  
  10.         return name; 
    11. 
  
  11.     } 
    12. 
  
  12.     public void setName(String name) { 
    13. 
  
  13.         this.name = name; 
    14. 
  
  14.     } 
    15. 
  
  15. } 
    16.

ThreadLocal 实际操作类：

 
    
  
  1. /** 
    2. 
  
  2.  * 客户信息储存类 
    3. 
  
  3.  */ 
    4. 
  
  4. class UserStorage { 
    5. 
  
  5.     // 客户信息 
    6. 
  
  6.     public static ThreadLocal<User> USER = new ThreadLocal(); 
    7. 
  
  7.  
    8. 
  
  8.     /** 
    9. 
  
  9.      * 加密存储信息内容 
    10. 
  
  10.      * @param user 客户数据信息 
    11. 
  
  11.      */ 
    12. 
  
  12.     public static void setUser(User user) { 
    13. 
  
  13.         USER.set(user); 
    14. 
  
  14.     } 
    15. 
  
  15. } 
    16.

* 订单信息类

 
    
  
  1. /** 
    2. 
  
  2.  * 订单信息类 
    3. 
  
  3.  */ 
    4. 
  
  4. class OrderSystem { 
    5. 
  
  5.     /** 
    6. 
  
  6.      * 订单信息加上方式 
    7. 
  
  7.      */ 
    8. 
  
  8.     public void add() { 
    9. 
  
  9.         // 获得客户信息 
    10. 
  
  10.         User user = UserStorage.USER.get(); 
    11. 
  
  11.         // 业务流程解决编码（忽视）... 
    12. 
  
  12.         System.out.println(String.format("订单管理系统接到客户：%s 的要求。", 
    13. 
  
  13.                 user.getName())); 
    14. 
  
  14.     } 
    15. 
  
  15. } 
    16.

仓储物流类：

 
    
  
  1. /** 
    2. 
  
  2.  * 仓储物流类 
    3. 
  
  3.  */ 
    4. 
  
  4. class RepertorySystem { 
    5. 
  
  5.     /** 
    6. 
  
  6.      * 减库存量方式 
    7. 
  
  7.      */ 
    8. 
  
  8.     public void decrement() { 
    9. 
  
  9.         // 获得客户信息 
    10. 
  
  10.         User user = UserStorage.USER.get(); 
    11. 
  
  11.         // 业务流程解决编码（忽视）... 
    12. 
  
  12.         System.out.println(String.format("仓储管理系统接到客户：%s 的要求。", 
    13. 
  
  13.                 user.getName())); 
    14. 
  
  14.     } 
    15. 
  
  15. } 
    16.

之上程序流程的最后实行結果：

从以上結果能够看得出，在我们在主线任务程中先复位了 User 目标以后，订单信息类和仓储物流类不用开展一切的参数传递还可以一切正常得到 User 目标了，进而完成了一个进程中，跨类和跨方式的数据信息传送。

汇总

应用 ThreadLocal 能够建立进程独享自变量，因此不容易造成线程安全难题，另外应用 ThreadLocal 还能够防止由于引进锁而导致进程排长队实行所产生的特性耗费;其次应用 ThreadLocal 还能够完成一个进程内跨类、跨方式的数据信息传送。

参照 & 鸣谢

《码出高效：Java开发手册》

《Java 并发编程 78 讲》

the end
免责声明：本文不代表本站的观点和立场，如有侵权请联系本站删除！本站仅提供信息存储空间服务。

精选推荐

随机推荐