FastThreadLocal是什么鬼？吊打ThreadLocal的存在！！

ThreadLocal 大家都知道是线程本地变量，今天栈长再介绍一个神器：FastThreadLocal，从字面上看就是：Fast + ThreadLocal，一个快的 ThreadLocal?这到底是什么鬼呢?

我们提供的服务有：成都网站建设、成都网站设计、微信公众号开发、网站优化、网站认证、丰都ssl等。为成百上千企事业单位解决了网站和推广的问题。提供周到的售前咨询和贴心的售后服务，是有科学管理、有技术的丰都网站制作公司

一、FastThreadLocal 简介

FastThreadLocal 并不是 JDK 自带的，而是在 Netty 中造的一个轮子，Netty 为什么要重复造轮子呢?

来看下它源码中的注释定义：

 
 
 
 
    
  
  
  
  
  1. /** 
    2. 
  
  
  
  
  2.  * A special variant of {@link ThreadLocal} that yields higher access performance when accessed from a 
    3. 
  
  
  
  
  3.  * {@link FastThreadLocalThread}. 
    4. 
  
  
  
  
  4.  * 
     
    5. 
  
  
  
  
  5.  * Internally, a {@link FastThreadLocal} uses a constant index in an array, instead of using hash code and hash table, 
    6. 
  
  
  
  
  6.  * to look for a variable.  Although seemingly very subtle, it yields slight performance advantage over using a hash 
    7. 
  
  
  
  
  7.  * table, and it is useful when accessed frequently. 
    8. 
  
  
  
  
  8.  * 
     
    9. 
  
  
  
  
  9.  * To take advantage of this thread-local variable, your thread must be a {@link FastThreadLocalThread} or its subtype. 
    10. 
  
  
  
  
  10.  * By default, all threads created by {@link DefaultThreadFactory} are {@link FastThreadLocalThread} due to this reason. 
    11. 
  
  
  
  
  11.  * 
     
    12. 
  
  
  
  
  12.  * Note that the fast path is only possible on threads that extend {@link FastThreadLocalThread}, because it requires 
    13. 
  
  
  
  
  13.  * a special field to store the necessary state.  An access by any other kind of thread falls back to a regular 
    14. 
  
  
  
  
  14.  * {@link ThreadLocal}. 
    15. 
  
  
  
  
  15.  * 
     
    16. 
  
  
  
  
  16.  * 
    17. 
  
  
  
  
  17.  * @param  the type of the thread-local variable 
    18. 
  
  
  
  
  18.  * @see ThreadLocal 
    19. 
  
  
  
  
  19.  */ 
    20. 
  
  
  
  
  20. public class FastThreadLocal { 
    21. 
  
  
  
  
  21.  ... 
    22. 
  
  
  
  
  22. } 
    23.

FastThreadLocal 是一个特殊的 ThreadLocal 变体，当从线程类 FastThreadLocalThread 中访问 FastThreadLocalm时可以获得更高的访问性能。如果你还不知道什么是ThreadLocal，可以关注公众号Java技术栈阅读我之前分享的文章。

二、FastThreadLocal 为什么快?

在 FastThreadLocal 内部，使用了索引常量代替了 Hash Code 和哈希表，源代码如下：

 
 
 
 
    
  
  
  
  
  1. private final int index; 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. public FastThreadLocal() { 
    4. 
  
  
  
  
  4.     index = InternalThreadLocalMap.nextVariableIndex(); 
    5. 
  
  
  
  
  5. } 
    6. 
 
 
 
 
 
 
 
 
    
  
  
  
  
  1. public static int nextVariableIndex() { 
    2. 
  
  
  
  
  2.     int index = nextIndex.getAndIncrement(); 
    3. 
  
  
  
  
  3.     if (index < 0) { 
    4. 
  
  
  
  
  4.         nextIndex.decrementAndGet(); 
    5. 
  
  
  
  
  5.         throw new IllegalStateException("too many thread-local indexed variables"); 
    6. 
  
  
  
  
  6.     } 
    7. 
  
  
  
  
  7.     return index; 
    8. 
  
  
  
  
  8. } 
    9.

FastThreadLocal 内部维护了一个索引常量 index，该常量在每次创建 FastThreadLocal 中都会自动+1，从而保证了下标的不重复性。

这要做虽然会产生大量的 index，但避免了在 ThreadLocal 中计算索引下标位置以及处理 hash 冲突带来的损耗，所以在操作数组时使用固定下标要比使用计算哈希下标有一定的性能优势，特别是在频繁使用时会非常显著，用空间换时间，这就是高性能 Netty 的巧妙之处。

要利用 FastThreadLocal 带来的性能优势，就必须结合使用 FastThreadLocalThread 线程类或其子类，因为 FastThreadLocalThread 线程类会存储必要的状态，如果使用了非 FastThreadLocalThread 线程类则会回到常规 ThreadLocal。

Netty 提供了继承类和实现接口的线程类：

  • FastThreadLocalRunnable
  • FastThreadLocalThread

Netty 也提供了 DefaultThreadFactory 工厂类，所有由 DefaultThreadFactory 工厂类创建的线程默认就是 FastThreadLocalThread 类型，来看下它的创建过程：

先创建 FastThreadLocalRunnable，再创建 FastThreadLocalThread，基友搭配，干活不累，一定要配合使用才“快”。

三、FastThreadLocal 实战

要使用 FastThreadLocal 就需要导入 Netty 的依赖了：

 
 
 
 
    
  
  
  
  
  1.  
    2. 
  
  
  
  
  2.     io.netty 
    3. 
  
  
  
  
  3.     netty-all 
    4. 
  
  
  
  
  4.     4.1.52.Final 
    5. 
  
  
  
  
  5.  
    6.

写一个测试小示例：

 
 
 
 
    
  
  
  
  
  1. import io.netty.util.concurrent.DefaultThreadFactory; 
    2. 
  
  
  
  
  2. import io.netty.util.concurrent.FastThreadLocal; 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4. public class FastThreadLocalTest { 
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6.     public static final int MAX = 100000; 
    7. 
  
  
  
  
  7.  
    8. 
  
  
  
  
  8.     public static void main(String[] args) { 
    9. 
  
  
  
  
  9.         new Thread(() -> threadLocal()).start(); 
    10. 
  
  
  
  
  10.         new Thread(() -> fastThreadLocal()).start(); 
    11. 
  
  
  
  
  11.     } 
    12. 
  
  
  
  
  12.  
    13. 
  
  
  
  
  13.     private static void fastThreadLocal() { 
    14. 
  
  
  
  
  14.         long start = System.currentTimeMillis(); 
    15. 
  
  
  
  
  15.         DefaultThreadFactory defaultThreadFactory = new DefaultThreadFactory(FastThreadLocalTest.class); 
    16. 
  
  
  
  
  16.  
    17. 
  
  
  
  
  17.         FastThreadLocal[] fastThreadLocal = new FastThreadLocal[MAX]; 
    18. 
  
  
  
  
  18.  
    19. 
  
  
  
  
  19.         for (int i = 0; i < MAX; i++) { 
    20. 
  
  
  
  
  20.             fastThreadLocal[i] = new FastThreadLocal<>(); 
    21. 
  
  
  
  
  21.         } 
    22. 
  
  
  
  
  22.  
    23. 
  
  
  
  
  23.         Thread thread = defaultThreadFactory.newThread(() -> { 
    24. 
  
  
  
  
  24.             for (int i = 0; i < MAX; i++) { 
    25. 
  
  
  
  
  25.                 fastThreadLocal[i].set("java: " + i); 
    26. 
  
  
  
  
  26.             } 
    27. 
  
  
  
  
  27.  
    28. 
  
  
  
  
  28.             System.out.println("fastThreadLocal set: " + (System.currentTimeMillis() - start)); 
    29. 
  
  
  
  
  29.  
    30. 
  
  
  
  
  30.             for (int i = 0; i < MAX; i++) { 
    31. 
  
  
  
  
  31.                 for (int j = 0; j < MAX; j++) { 
    32. 
  
  
  
  
  32.                     fastThreadLocal[i].get(); 
    33. 
  
  
  
  
  33.                 } 
    34. 
  
  
  
  
  34.             } 
    35. 
  
  
  
  
  35.         }); 
    36. 
  
  
  
  
  36.         thread.start(); 
    37. 
  
  
  
  
  37.         try { 
    38. 
  
  
  
  
  38.             thread.join(); 
    39. 
  
  
  
  
  39.         } catch (InterruptedException e) { 
    40. 
  
  
  
  
  40.             e.printStackTrace(); 
    41. 
  
  
  
  
  41.         } 
    42. 
  
  
  
  
  42.  
    43. 
  
  
  
  
  43.         System.out.println("fastThreadLocal total: " + (System.currentTimeMillis() - start)); 
    44. 
  
  
  
  
  44.     } 
    45. 
  
  
  
  
  45.  
    46. 
  
  
  
  
  46.     private static void threadLocal() { 
    47. 
  
  
  
  
  47.         long start = System.currentTimeMillis(); 
    48. 
  
  
  
  
  48.         ThreadLocal[] threadLocals = new ThreadLocal[MAX]; 
    49. 
  
  
  
  
  49.  
    50. 
  
  
  
  
  50.         for (int i = 0; i < MAX; i++) { 
    51. 
  
  
  
  
  51.             threadLocals[i] = new ThreadLocal<>(); 
    52. 
  
  
  
  
  52.         } 
    53. 
  
  
  
  
  53.  
    54. 
  
  
  
  
  54.         Thread thread = new Thread(() -> { 
    55. 
  
  
  
  
  55.             for (int i = 0; i < MAX; i++) { 
    56. 
  
  
  
  
  56.                 threadLocals[i].set("java: " + i); 
    57. 
  
  
  
  
  57.             } 
    58. 
  
  
  
  
  58.  
    59. 
  
  
  
  
  59.             System.out.println("threadLocal set: " + (System.currentTimeMillis() - start)); 
    60. 
  
  
  
  
  60.  
    61. 
  
  
  
  
  61.             for (int i = 0; i < MAX; i++) { 
    62. 
  
  
  
  
  62.                 for (int j = 0; j < MAX; j++) { 
    63. 
  
  
  
  
  63.                     threadLocals[i].get(); 
    64. 
  
  
  
  
  64.                 } 
    65. 
  
  
  
  
  65.             } 
    66. 
  
  
  
  
  66.         }); 
    67. 
  
  
  
  
  67.         thread.start(); 
    68. 
  
  
  
  
  68.         try { 
    69. 
  
  
  
  
  69.             thread.join(); 
    70. 
  
  
  
  
  70.         } catch (InterruptedException e) { 
    71. 
  
  
  
  
  71.             e.printStackTrace(); 
    72. 
  
  
  
  
  72.         } 
    73. 
  
  
  
  
  73.  
    74. 
  
  
  
  
  74.         System.out.println("threadLocal total: " + (System.currentTimeMillis() - start)); 
    75. 
  
  
  
  
  75.     } 
    76. 
  
  
  
  
  76.  
    77. 
  
  
  
  
  77. } 
    78.

结果输出：

可以看出，在大量读写面前，写操作的效率差不多，但读操作 FastThreadLocal 比 ThreadLocal 快的不是一个数量级，简直是秒杀 ThreadLocal 的存在。

当我把 MAX 值调整到 1000 时，结果输出：

读写操作不多时，ThreadLocal 明显更胜一筹!

上面的示例是单线程测试多个 *ThreadLocal，即数组形式，另外，我也测试了多线程单个 *ThreadLocal，这时候 FastThreadLocal 效率就明显要落后于 ThreadLocal。。

最后需要说明的是，在使用完 FastThreadLocal 之后不用 remove 了，因为在 FastThreadLocalRunnable 中已经加了移除逻辑，在线程运行完时会移除全部绑定在当前线程上的所有变量。

所以，使用 FastThreadLocal 导致内存溢出的概率会不会要低于 ThreadLocal?

不一定，因为 FastThreadLocal 会产生大量的 index 常量，所谓的空间换时间，所以感觉 FastThreadLocal 内存溢出的概率更大，但好在每次使用完都会自动 remove。

四、总结

Netty 中的 FastThreadLocal 在大量频繁读写操作时效率要高于 ThreadLocal，但要注意结合 Netty 自带的线程类使用，这可能就是 Netty 为什么高性能的奥妙之一吧!

如果没有大量频繁读写操作的场景，JDK 自带的 ThreadLocal 足矣，并且性能还要优于 FastThreadLocal。

本文转载自微信公众号「Java技术栈」，可以通过以下二维码关注。转载本文请联系Java技术栈公众号。

文章名称：FastThreadLocal是什么鬼？吊打ThreadLocal的存在！！
转载来于：http://www.shufengxianlan.com/qtweb/news11/39861.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

外贸网站建设知识

各行业网站

乐山服务器托管　　 　草坪音箱　　 　服务器租用　　 　成都装饰装修　　 　成都做手机网站　　 　微信小程序开发　　 　遂宁海缘科技　　 　四川锦华橡塑　　 　边坡防护网　　 　固迪佳新材料　　 　重庆花箱　　 　成都网络营销　　 　网站定制　　 　广安园林景观设计　　 　成都外贸网站建设　　 　雅安机房托管　　 　网络推广平台　　 　重庆网站制作　　 　深圳纱窗安装　　 　全网营销推广