ThreadLocal原理分析＆＆面试题

桃月十二_

已于 2022-09-20 10:26:12 修改

阅读量210

点赞数

分类专栏：面试题-并发文章标签： java 面试 jvm

于 2021-04-27 11:27:07 首次发布

本文链接：https://blog.csdn.net/yzx3105/article/details/116192566

版权

面试题-并发专栏收录该内容

30 篇文章 4 订阅

订阅专栏

ThreadLocal

1. ThreadLocal Api
2. ThreadLocal结构
3. 面试题
4. ThreadLocal源码分析

提供线程内的局部变量，不同的线程之间不会相互干扰，这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或组件之间一些公共变量传递的复杂度。

1. ThreadLocal Api

方法声明	描述
ThreadLocal()	创建ThreadLocal对象
public void set( T value)	设置当前线程绑定的局部变量
public T get()	获取当前线程绑定的局部变量
public void remove()	移除当前线程绑定的局部变量

1.1 Demo

public class TestThreadLocal {

  private String content;

  public String getContent () {
    return content;
  }

  public void setContent (String content) {
    this.content = content;
  }

  public static void main (String[] args) {

    TestThreadLocal testThreadLocal = new TestThreadLocal();

    for (int i = 0; i < 4; i++) {
      new Thread(() -> {

        testThreadLocal.setContent(Thread.currentThread().getName() + "数据");
        System.out.println("---------------");
        System.out.println((Thread.currentThread().getName() + "----" + testThreadLocal.getContent()));
      }, "线程" + i).start();
    }

  }
}

---------------
---------------
线程2----线程2数据
---------------
线程1----线程3数据
---------------
线程3----线程3数据
线程0----线程2数据

1.2 ThreadLocal优化后

public class TestThreadLocal {

  ThreadLocal<String> tl=new ThreadLocal<>();

  private String content;

  public String getContent () {
    return tl.get();
  }

  public void setContent (String content) {
    tl.set(content);
  }

  public static void main (String[] args) {

    TestThreadLocal testThreadLocal = new TestThreadLocal();

    for (int i = 0; i < 4; i++) {
      new Thread(() -> {

        testThreadLocal.setContent(Thread.currentThread().getName() + "数据");
        System.out.println("---------------");
        System.out.println((Thread.currentThread().getName() + "----" + testThreadLocal.getContent()));
      }, "线程" + i).start();
    }

  }
}

---------------
---------------
线程2----线程2数据
---------------
线程1----线程1数据
---------------
线程3----线程3数据
线程0----线程0数据

从结果来看，这样很好的解决了多线程之间数据隔离的问题，十分方便。

1.3 上面的demo用synchronized也可以实现。

public class TestThreadLocal {
  private String content;

  public String getContent () {
    return content;
  }

  public void setContent (String content) {
    this.content = content;
  }

  public static void main (String[] args) {

    TestThreadLocal testThreadLocal = new TestThreadLocal();

    for (int i = 0; i < 4; i++) {
      new Thread(() -> {

        synchronized (TestThreadLocal.class) {
          testThreadLocal.setContent(Thread.currentThread().getName() + "数据");
          System.out.println("---------------");
          System.out.println((Thread.currentThread().getName() + "----" + testThreadLocal.getContent()));
        }

      }, "线程" + i).start();
    }
  }
}

1.4 ThreadLocal类与synchronized关键字

	synchronized	ThreadLocal
原理	同步机制采用’以时间换空间’的方式, 只提供了一份变量,让不同的线程排队访问	ThreadLocal采用’以空间换时间’的方式, 为每一个线程都提供了一份变量的副本,从而实现同时访问而相不干扰
侧重点	多个线程之间访问资源的同步性	多线程中让每个线程之间的数据相互隔离

总结：
在刚刚的案例中，虽然使用ThreadLocal和synchronized都能解决问题,但是使用ThreadLocal更为合适,因为这样可以使程序拥有更高的并发性。

2. ThreadLocal结构

在这里插入图片描述
JDK8 ThreadLocal的设计是：每个Thread维护一个ThreadLocalMap哈希表，这个哈希表的key是ThreadLocal实例本身，value才是真正要存储的值Object。

每个Thread线程内部都有一个Map (ThreadLocalMap)
Map里面存储ThreadLocal对象（key）和线程的变量副本（value）
Thread内部的Map是由ThreadLocal维护的，由ThreadLocal负责向map获取和设置线程的变量值。
对于不同的线程，每次获取副本值时，别的线程并不能获取到当前线程的副本值，形成了副本的隔离，互不干扰。

好处

这样设计之后每个Map存储的Entry数量就会变少，因为之前的存储数量由Thread的数量决定，现在是由ThreadLocal的数量决定。
当Thread销毁之后，对应的ThreadLocalMap也会随之销毁，能减少内存的使用。

3. 面试题

3.1 hash冲突问题

每个ThreadLocal对象都有一个hash值threadLocalHashCode，每初始化一个ThreadLocal对象，hash值就增加一个固定的大小0x61c88647。

在插入过程中，根据ThreadLocal对象的hash值，定位到table中的位置i，过程如下：
1、如果当前位置是空的，那么正好，就初始化一个Entry对象放在位置i上；
2、不巧，位置i已经有Entry对象了，如果这个Entry对象的key正好是即将设置的key，那么重新设置Entry中的value；
3、很不巧，位置i的Entry对象，和即将设置的key没关系，那么只能找下一个空位置；

这样的话，在get的时候，也会根据ThreadLocal对象的hash值，定位到table中的位置，然后判断该位置Entry对象中的key是否和get的key一致，如果不一致，就判断下一个位置

可以发现，set和get如果冲突严重的话，效率很低，因为ThreadLoalMap是Thread的一个属性，所以即使在自己的代码中控制了设置的元素个数，但还是不能控制其它代码的行为。

3.2 内存泄漏

ThreadLocalMap数组中保存的是一个Entry对象，key被保存到了WeakReference对象中（弱引用），发生GC的时候会被回收，这样value就有可能一直得不到回收，发生内存泄露。

3.3 如何避免内存泄漏

在调用ThreadLocal的get()、set()可能会清除ThreadLocalMap中key为null的Entry对象，这样对应的value就没有GC Roots可达了，下次GC的时候就可以被回收，当然如果调用remove方法，肯定会删除对应的Entry对象。

如果使用ThreadLocal的set方法之后，没有显示的调用remove方法，就有可能发生内存泄露，所以养成良好的编程习惯十分重要，使用完ThreadLocal之后，记得调用remove方法。

4. ThreadLocal源码分析

ThreadLocalMap是ThreadLocal的内部类，没有实现Map接口，用独立的方式实现了Map的功能，其内部的Entry也是独立实现。

get

A. 首先获取当前线程
B. 根据当前线程获取一个Map
C. 如果获取的Map不为空，则在Map中以ThreadLocal的引用作为key来在Map中获取对应的value e，否则转到E
D. 如果e不为null，则返回e.value，否则转到E
E. Map为空或者e为空，则通过initialValue函数获取初始值value，然后用ThreadLocal的引用和value作为firstKey和firstValue创建一个新的Map

总结: 先获取当前线程的 ThreadLocalMap 变量，如果存在则返回值，不存在则创建并返回初始值。

public T get() {
     //获取当前线程
     Thread t = Thread.currentThread();
     //获取此线程对象中维护的ThreadLocalMap对象
     ThreadLocalMap map = getMap(t);
     if (map != null) {
        //以当前的ThreadLocal 为 key，调用getEntry获取对应的存储实体e
         ThreadLocalMap.Entry e = map.getEntry(this);
         if (e != null) {
             @SuppressWarnings("unchecked")
             // 获取存储实体 e 对应的 value值
             // 即为我们想要的当前线程对应此ThreadLocal的值
             T result = (T)e.value;
             return result;
         }
     }
     // 如果map不存在，则证明此线程没有维护的ThreadLocalMap对象
     // 调用setInitialValue进行初始化
     return setInitialValue();
 }

setInitialValue

private T setInitialValue() {
    // 调用initialValue获取初始化的值
     T value = initialValue();
     // 获取当前线程对象
     Thread t = Thread.currentThread();
     // 获取此线程对象中维护的ThreadLocalMap对象
     ThreadLocalMap map = getMap(t);
     // 如果此map存在
     if (map != null)
         // 存在则调用map.set设置此实体entry
         map.set(this, value);
     else
         // 1）当前线程Thread 不存在ThreadLocalMap对象
         // 2）则调用createMap进行ThreadLocalMap对象的初始化
         // 3）并将此实体entry作为第一个值存放至ThreadLocalMap中
         createMap(t, value);
     // 返回设置的值value
     return value;
}

initialValue

 protected T initialValue() {
   return null;
 }

此方法的作用是返回该线程局部变量的初始值。
（1）这个方法是一个延迟调用方法，从上面的代码我们得知，在set方法还未调用而先调用了get方法时才执行，并且仅执行1次。
（2）这个方法缺省实现直接返回一个null。
（3）如果想要一个除null之外的初始值，可以重写此方法。（备注：该方法是一个protected的方法，显然是为了让子类覆盖而设计的）

getMap / createMap

  /**
    * 获取当前线程Thread对应维护的ThreadLocalMap 
    * 
    * @param  t the current thread 当前线程
    * @return the map 对应维护的ThreadLocalMap 
    */
   ThreadLocalMap getMap(Thread t) {
       return t.threadLocals;
   }
  /**
    *创建当前线程Thread对应维护的ThreadLocalMap 
    *
    * @param t 当前线程
    * @param firstValue 存放到map中第一个entry的值
    */
   void createMap(Thread t, T firstValue) {
       //这里的this是调用此方法的threadLocal
       t.threadLocals = new ThreadLocalMap(this, firstValue);
   }

set

A. 首先获取当前线程，并根据当前线程获取一个Map
B. 如果获取的Map不为空，则将参数设置到Map中（当前ThreadLocal的引用作为key）
C. 如果Map为空，则给该线程创建 Map，并设置初始值

public void set(T value) {
   // 获取当前线程对象
    Thread t = Thread.currentThread();
    // 获取此线程对象中维护的ThreadLocalMap对象
    ThreadLocalMap map = getMap(t);
    // 如果此map存在
    if (map != null)
        // 存在则调用map.set设置此实体entry
        map.set(this, value);
    else
        // 1）当前线程Thread 不存在ThreadLocalMap对象
        // 2）则调用createMap进行ThreadLocalMap对象的初始化
        // 3）并将此实体entry作为第一个值存放至ThreadLocalMap中
        createMap(t, value);
 }

remove

A. 首先获取当前线程，并根据当前线程获取一个Map
B. 如果获取的Map不为空，则移除当前ThreadLocal对象对应的entry

 /**
 * 删除当前线程中保存的ThreadLocal对应的实体entry
 */
 public void remove() {
    // 获取当前线程对象中维护的ThreadLocalMap对象
     ThreadLocalMap m = getMap(Thread.currentThread());
    // 如果此map存在
     if (m != null)
        // 存在则调用map.remove
        // 以当前ThreadLocal为key删除对应的实体entry
         m.remove(this);
 }

Entry

// 在ThreadLocalMap中，也是用Entry来保存K-V结构数据的。但是Entry中key只能是ThreadLocal对象，这点被Entry的构造方法已经限定死了
// 另外，Entry继承WeakReference,使用弱引用，可以将ThreadLocal对象的生命周期和线程生命周期解绑，持有对ThreadLocal的弱引用，可以使得ThreadLocal在没有其他强引用的时候被回收掉，这样可以避免因为线程得不到销毁导致ThreadLocal对象无法被回收

static class Entry extends WeakReference<ThreadLocal> {
    /** The value associated with this ThreadLocal. */
    Object value;

    Entry(ThreadLocal k, Object v) {
        super(k);
        value = v;
    }
}

hash冲突的解决

ThreadLocal使用的是自定义的ThreadLocalMap，接下来我们来探究一下ThreadLocalMap的hash冲突解决方式。

先回顾ThreadLocal的set() 方法

 public void set(T value) {
   Thread t = Thread.currentThread();
     ThreadLocal.ThreadLocalMap map = getMap(t);
     if (map != null)
         map.set(this, value);
     else
         createMap(t, value);
 }
 
 ThreadLocal.ThreadLocalMap getMap(Thread t) {
     return t.threadLocals;
 }

 void createMap(Thread t, T firstValue) {
     t.threadLocals = new ThreadLocal.ThreadLocalMap(this, firstValue);
 }

代码很简单，获取当前线程，并获取当前线程的ThreadLocalMap实例（从getMap(Thread t)中很容易看出来）。
如果获取到的map实例不为空，调用map.set()方法，否则调用构造函数 ThreadLocal.ThreadLocalMap(this, firstValue)实例化map。

可以看出来线程中的ThreadLocalMap使用的是延迟初始化，在第一次调用get()或者set()方法的时候才会进行初始化。

下面来看看构造函数ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue)

 ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    //初始化table
     table = new ThreadLocal.ThreadLocalMap.Entry[INITIAL_CAPACITY];
     //计算索引
     int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
     //设置值
     table[i] = new ThreadLocal.ThreadLocalMap.Entry(firstKey, firstValue);
     size = 1;
     //设置阈值
     setThreshold(INITIAL_CAPACITY);
 }

主要说一下计算索引，firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1)。

关于& (INITIAL_CAPACITY - 1),这是取模的一种方式，对于2的幂作为模数取模，用此代替%(2^n)，这也就是为啥容量必须为2的冥，在这个地方也得到了解答。
关于firstKey.threadLocalHashCode：

 private final int threadLocalHashCode = nextHashCode();
    
    private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }
    private static AtomicInteger nextHashCode =  new AtomicInteger();
            
    private static final int HASH_INCREMENT = 0x61c88647;

这里定义了一个AtomicInteger类型，每次获取当前值并加上HASH_INCREMENT，HASH_INCREMENT = 0x61c88647,这个值和斐波那契散列有关（这是一种乘数散列法，只不过这个乘数比较特殊，是32位整型上限2^32-1乘以黄金分割比例0.618…的值2654435769，用有符号整型表示就是-1640531527，去掉符号后16进制表示为0x61c88647），其主要目的就是为了让哈希码能均匀的分布在2的n次方的数组里, 也就是Entry[] table中，这样做可以尽量避免hash冲突。

ThreadLocalMap中的set()

ThreadLocalMap使用开发地址-线性探测法来解决哈希冲突，线性探测法的地址增量di = 1, 2, … 其中，i为探测次数。该方法一次探测下一个地址，直到有空的地址后插入，若整个空间都找不到空余的地址，则产生溢出。假设当前table长度为16，也就是说如果计算出来key的hash值为14，如果table[14]上已经有值，并且其key与当前key不一致，那么就发生了hash冲突，这个时候将14加1得到15，取table[15]进行判断，这个时候如果还是冲突会回到0，取table[0],以此类推，直到可以插入。
hreadLocalMap的set()代码如下：

private void set(ThreadLocal<?> key, Object value) {
	ThreadLocal.ThreadLocalMap.Entry[] tab = table;
	int len = tab.length;
	//计算索引，上面已经有说过。
	int i = key.threadLocalHashCode & (len-1);
	
	/**
	 * 根据获取到的索引进行循环，如果当前索引上的table[i]不为空，在没有return的情况下，
	 * 就使用nextIndex()获取下一个（上面提到到线性探测法）。
	 */
	for (ThreadLocal.ThreadLocalMap.Entry e = tab[i];
	     e != null;
	     e = tab[i = nextIndex(i, len)]) {
	    ThreadLocal<?> k = e.get();
	    //table[i]上key不为空，并且和当前key相同，更新value
	    if (k == key) {
	        e.value = value;
	        return;
	    }
	    /**
	     * table[i]上的key为空，说明被回收了
	     * 这个时候说明改table[i]可以重新使用，用新的key-value将其替换,并删除其他无效的entry
	     */
	    if (k == null) {
	        replaceStaleEntry(key, value, i);
	        return;
	    }
	}

面试题来源：jianshu.com/p/377bb840802f

桃月十二_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ThreadLocal原理分析＆＆面试题

ThreadLocal提供线程内的局部变量，不同的线程之间不会相互干扰，这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或组件之间一些公共变量传递的复杂度。ThreadLocal Api方法声明描述ThreadLocal()创建ThreadLocal对象public void set( T value)设置当前线程绑定的局部变量public T get()获取当前线程绑定的局部变量public void remove()移除当前线程绑定的局部变
复制链接

扫一扫