ThreadLocal使用与原理

时间:2022-05-10 01:59:21

ThreadLocal使用与原理

在处理多线程并发安全的方法中,最常用的方法,就是使用锁,通过锁来控制多个不同线程对临界区的访问。

但是,无论是什么样的锁,乐观锁或者悲观锁,都会在并发冲突的时候对性能产生一定的影响。

那有没有一种方法,可以彻底避免竞争呢?

答案是肯定的,这就是ThreadLocal

从字面意思上看,ThreadLocal可以解释成线程的局部变量,也就是说一个ThreadLocal的变量只有当前自身线程可以访问,别的线程都访问不了,那么自然就避免了线程竞争。

因此,ThreadLocal提供了一种与众不同的线程安全方式,它不是在发生线程冲突时想办法解决冲突,而是彻底的避免了冲突的发生。

ThreadLocal的基本使用

 

创建一个ThreadLocal对象:

  1. private ThreadLocal<Integer> localInt = new ThreadLocal<>(); 

上述代码创建一个localInt变量,由于ThreadLocal是一个泛型类,这里指定了localInt的类型为整数。

下面展示了如果设置和获取这个变量的值:

  1. public int setAndGet(){ 
  2.     localInt.set(8); 
  3.     return localInt.get(); 

上述代码设置变量的值为8,接着取得这个值。

由于ThreadLocal里设置的值,只有当前线程自己看得见,这意味着你不可能通过其他线程为它初始化值。为了弥补这一点,ThreadLocal提供了一个withInitial()方法统一初始化所有线程的ThreadLocal的值:

  1. private ThreadLocal<Integer> localInt = ThreadLocal.withInitial(() -> 6); 

上述代码将ThreadLocal的初始值设置为6,这对全体线程都是可见的。

ThreadLocal的实现原理

 

ThreadLocal变量只在单个线程内可见,那它是如何做到的呢?我们先从最基本的get()方法说起:

  1. public T get() { 
  2.     //获得当前线程 
  3.     Thread t = Thread.currentThread(); 
  4.     //每个线程 都有一个自己的ThreadLocalMap, 
  5.     //ThreadLocalMap里就保存着所有的ThreadLocal变量 
  6.     ThreadLocalMap map = getMap(t); 
  7.     if (map != null) { 
  8.         //ThreadLocalMap的key就是当前ThreadLocal对象实例, 
  9.         //多个ThreadLocal变量都是放在这个map中的 
  10.         ThreadLocalMap.Entry e = map.getEntry(this); 
  11.         if (e != null) { 
  12.             @SuppressWarnings("unchecked"
  13.             //从map里取出来的值就是我们需要的这个ThreadLocal变量 
  14.             T result = (T)e.value; 
  15.             return result; 
  16.         } 
  17.     } 
  18.     // 如果map没有初始化,那么在这里初始化一下 
  19.     return setInitialValue(); 

可以看到,所谓的ThreadLocal变量就是保存在每个线程的map中的。这个map就是Thread对象中的threadLocals字段。如下:

  1. ThreadLocal.ThreadLocalMap threadLocals = null

ThreadLocal.ThreadLocalMap是一个比较特殊的Map,它的每个Entry的key都是一个弱引用:

  1. static class Entry extends WeakReference<ThreadLocal<?>> { 
  2.     /** The value associated with this ThreadLocal. */ 
  3.     Object value; 
  4.     //key就是一个弱引用 
  5.     Entry(ThreadLocal<?> k, Object v) { 
  6.         super(k); 
  7.         value = v; 
  8.     } 

这样设计的好处是,如果这个变量不再被其他对象使用时,可以自动回收这个ThreadLocal对象,避免可能的内存泄露(注意,Entry中的value,依然是强引用,如何回收,见下文分解)。

理解ThreadLocal中的内存泄漏问题

 

虽然ThreadLocalMap中的key是弱引用,当不存在外部强引用的时候,就会自动被回收,但是Entry中的value依然是强引用。这个value的引用链条如下:

ThreadLocal使用与原理

可以看到,只有当Thread被回收时,这个value才有被回收的机会,否则,只要线程不退出,value总是会存在一个强引用。但是,要求每个Thread都会退出,是一个极其苛刻的要求,对于线程池来说,大部分线程会一直存在在系统的整个生命周期内,那样的话,就会造成value对象出现泄漏的可能。处理的方法是,在ThreadLocalMap进行set(),get(),remove()的时候,都会进行清理:

以getEntry()为例:

  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.         //如果找到key,直接返回 
  6.         return e; 
  7.     else 
  8.         //如果找不到,就会尝试清理,如果你总是访问存在的key,那么这个清理永远不会进来 
  9.         return getEntryAfterMiss(key, i, e); 

下面是getEntryAfterMiss()的实现:

  1. private Entry getEntryAfterMiss(ThreadLocal<?> keyint i, Entry e) { 
  2.     Entry[] tab = table
  3.     int len = tab.length; 
  4.  
  5.     while (e != null) { 
  6.         // 整个e是entry ,也就是一个弱引用 
  7.         ThreadLocal<?> k = e.get(); 
  8.         //如果找到了,就返回 
  9.         if (k == key
  10.             return e; 
  11.         if (k == null
  12.             //如果keynull,说明弱引用已经被回收了 
  13.             //那么就要在这里回收里面的value了 
  14.             expungeStaleEntry(i); 
  15.         else 
  16.             //如果key不是要找的那个,那说明有hash冲突,这里是处理冲突,找下一个entry 
  17.             i = nextIndex(i, len); 
  18.         e = tab[i]; 
  19.     } 
  20.     return null

真正用来回收value的是expungeStaleEntry()方法,在remove()和set()方法中,都会直接或者间接调用到这个方法进行value的清理:

从这里可以看到,ThreadLocal为了避免内存泄露,也算是花了一番大心思。不仅使用了弱引用维护key,还会在每个操作上检查key是否被回收,进而再回收value。

但是从中也可以看到,ThreadLocal并不能100%保证不发生内存泄漏。

比如,很不幸的,你的get()方法总是访问固定几个一直存在的ThreadLocal,那么清理动作就不会执行,如果你没有机会调用set()和remove(),那么这个内存泄漏依然会发生。

因此,一个良好的习惯依然是:当你不需要这个ThreadLocal变量时,主动调用remove(),这样对整个系统是有好处的。

ThreadLocalMap中的Hash冲突处理

 

ThreadLocalMap作为一个HashMap和java.util.HashMap的实现是不同的。对于java.util.HashMap使用的是链表法来处理冲突:

ThreadLocal使用与原理

但是,对于ThreadLocalMap,它使用的是简单的线性探测法,如果发生了元素冲突,那么就使用下一个槽位存放:

ThreadLocal使用与原理

具体来说,整个set()的过程如下:

ThreadLocal使用与原理

可以被继承的ThreadLocal——InheritableThreadLocal

 

在实际开发过程中,我们可能会遇到这么一种场景。主线程开了一个子线程,但是我们希望在子线程中可以访问主线程中的ThreadLocal对象,也就是说有些数据需要进行父子线程间的传递。比如像这样:

  1. public static void main(String[] args) { 
  2.     ThreadLocal threadLocal = new ThreadLocal(); 
  3.     IntStream.range(0,10).forEach(i -> { 
  4.         //每个线程的序列号,希望在子线程中能够拿到 
  5.         threadLocal.set(i); 
  6.         //这里来了一个子线程,我们希望可以访问上面的threadLocal 
  7.         new Thread(() -> { 
  8.             System.out.println(Thread.currentThread().getName() + ":" + threadLocal.get()); 
  9.         }).start(); 
  10.         try { 
  11.             Thread.sleep(1000); 
  12.         } catch (InterruptedException e) { 
  13.             e.printStackTrace(); 
  14.         } 
  15.     }); 

执行上述代码,你会看到:

  1. Thread-0:null 
  2. Thread-1:null 
  3. Thread-2:null 
  4. Thread-3:null 

因为在子线程中,是没有threadLocal的。如果我们希望子线可以看到父线程的ThreadLocal,那么就可以使用InheritableThreadLocal。顾名思义,这就是一个支持线程间父子继承的ThreadLocal,将上述代码中的threadLocal使用InheritableThreadLocal:

  1. InheritableThreadLocal threadLocal = new InheritableThreadLocal(); 

再执行,就能看到:

  1. Thread-0:0 
  2. Thread-1:1 
  3. Thread-2:2 
  4. Thread-3:3 
  5. Thread-4:4 

可以看到,每个线程都可以访问到从父进程传递过来的一个数据。虽然InheritableThreadLocal看起来挺方便的,但是依然要注意以下几点:

变量的传递是发生在线程创建的时候,如果不是新建线程,而是用了线程池里的线程,就不灵了

变量的赋值就是从主线程的map复制到子线程,它们的value是同一个对象,如果这个对象本身不是线程安全的,那么就会有线程安全问题

写在最后的话

 

今天,我们介绍了ThreadLocal,ThreadLocal在Java的多线程开发中有着十分重要的作用。

在这里,我们介绍了ThreadLocal的基本使用和实现原理,尤其重点介绍了基于当前实现原理下可能存在的内存泄漏问题。

最后,还介绍了一个用于在父子线程间传递数据的特殊的ThreadLocal实现,希望对大家有所帮助。

原文地址:https://mp.weixin.qq.com/s/fo9fe16fHIWwnhFMsFeVfA