【Java并发编程】ThreadLocal（二）：从设计思路到源码分析

最新推荐文章于 2024-03-20 22:56:36 发布
最新推荐文章于 2024-03-20 22:56:36 发布
阅读量1.5w 收藏 5
点赞数 5
分类专栏： # Java并发编程 文章标签： java 并发编程 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43935927/article/details/108889167
版权

ThreadLocal 系列：

在开始看源码之前，我们必须要知道 ThreadLocal 有什么作用：ThreadLocal 使同一个变量在不同线程间隔离，即每个线程都可以有自己独立的副本，然后可以在该线程的方法间共享（随时取出使用）。不明白的话可以看文章最后一部分的使用示例。

这其实是一种空间换时间的思路，因为如果每个线程都有自己独立的副本，就不用通过加锁使线程串行化执行去保证线程安全了，节省了时间，但作为代价要为每个线程开辟一块独立的空间。

了解了 ThreadLocal 的功能后，那我们该如何设计ThreadLocal？

1.如何设计线程间隔离

首先，很容易想到每个线程都必须为 ThreadLocal 开辟一块单独的内存，但仅仅开辟一块大小等于 ThreadLocal 的内存是不够的的。因为一个线程可能有多个独立的副本，换句话说就是可以在多个类中创建 ThreadLocal，比如：

public static void main(String[] args) {
	new A().f1();
	new B().f2()；
}

public class A {
	private static ThreadLocal<String> threadLocal1 = new ThreadLocal<>();
	
	public void f1(){ threadLocal1.set("test");
}
public class B {
	private static ThreadLocal<Integer> threadLocal2 = new ThreadLocal<>();

	public void f2(){ threadLocal1.set(001);
}

那么对于main线程来说，test 和 001 都是它的独立副本，都要保存起来，而他俩的区别就在于保存的 ThreadLocal 实例对象不同。

PS：在我们实际开发中，TheadLocal 会常用于拦截器中，比如 LoginInterceptor 获取到 token 中保存的 userId，然后放到一个 ThreadLocal 中，后面在需要 userId 的时候就可以通过 LoginInterceptor.threadLocal.get() 就能拿到。同样的，我可能还有一个 UVInterceptor 用于获取到请求中携带的客户唯一端标识 ID，那么我就就需要再创建一个 ThreadLocal 去保存。所以说，在一个线程中，可能会有多个 TheadLocal 实例。

接下来，我们就看看在线程(Thread类)中到底是如何保存ThreadLocal的：

在这里插入图片描述
可以看到，每个Thread维护一个ThreadLocalMap，而存储在ThreadLocalMap内的就是一个以Entry为元素的table数组（Entry就是一个key-value结构：key为ThreadLocal，value为存储的值），所以我们可以得到以下两点信息：

  1. 数组保证了每个线程可以存储多个独立的副本
  2. Entry 提供了区分不同副本方式，即ThreadLocal实例对象不同

另外，虽然这里有两个变量，但只有 threadLocals 是直接进行set/get操作的。若在父线程中创建子线程，会拷贝父线程的 inheritableThreadLocals 到子线程。

问题：创建子线程时，子线程是得不到父线程的 ThreadLocal，有什么办法可以解决这个问题？

答：可以使用 InheritableThreadLocal 来代替 ThreadLocal，ThreadLocal 和 InheritableThreadLocal 都是线程的属性，所以可以做到线程之间的数据隔离，在多线程环境下我们经常使用，但在有子线程被创建的情况下，父线程 ThreadLocal 是无法传递给子线程的，但 InheritableThreadLocal 可以，主要是因为在线程创建的过程中，会把InheritableThreadLocal 里面的所有值传递给子线程，具体代码如下：

// 当父线程的 inheritableThreadLocals 的值不为空时
// 会把 inheritableThreadLocals 里面的值全部传递给子线程
if (parent.inheritableThreadLocals != null)
    this.inheritableThreadLocals =
        ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);

看源码前的要理解的逻辑终于说完了，下面进入正戏…

2.ThreadLocal

ThreadLocal 核心成员变量及主要构造函数：

// ThreadLocal使用了泛型，所以可以存放任何类型
public class ThreadLocal<T> {
    
    // 当前 ThreadLocal 的 hashCode，作用是计算当前 ThreadLocal 在 ThreadLocalMap 中的索引位置
    // nextHashCode() { return nextHashCode.getAndAdd(HASH_INCREMENT);}
    private final int threadLocalHashCode = nextHashCode();
   
    // nextHashCode 直接决定 threadLocalHashCode（= nextHashCode++）
    // 这么做因为ThreadLocal可能在不同类中new出来多个，但线程只有一个，若每次下标都从同一位置开始，虽然有hash碰撞处理策略，但仍然会影响效率
    // static：保证了nextHashCode的唯一性，间接保证了threadHashCode唯一性
    private static AtomicInteger nextHashCode = new AtomicInteger();
    
    // ThreadLocalMap（核心）
    // 注：虽然 ThreadLocal 是它的 Entry 的 key，但是它是 ThreadLocal 的静态内部类
    static class ThreadLocalMap{...}
    
    // 只有空参构造
    public ThreadLocal() {
    }
	
	// 计算 ThreadLocal 的 hashCode 值，就是通过CAS让 nextHashCode++
	private static int nextHashCode() {
    	return nextHashCode.getAndAdd(HASH_INCREMENT);
	}
	
	//......
}

2.1 set()

拿到当前线程的 threadLocals 并将 Entry(当前ThreadLocal对象，value）放入。另外，因为 set 操作每个线程都是串行的，所以不会有线程安全的问题

public void set(T value) {
    // 拿到当前线程
    Thread t = Thread.currentThread();
    // 拿到当前线程的ThreadLocalMap，即threadLocals变量
    ThreadLocalMap map = getMap(t);
    
    // 当前 threadLocal 非空，即之前已经有独立的副本数据了
    if (map != null)
        map.set(this, value); // 直接将当前 threadLocal和value传入
    // 当前threadLocal为空
    else
        createMap(t, value); // 初始化ThreadLocalMap
}

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

这里说一下 createMap 初始化 ThreadLocalMap，它最后会走到内部类 ThreadLocalMap 的构造函数
在这里插入图片描述
可以看到数组的初始大小跟 HashMap 一样，都是 16；值得注意的是，它的扩容阈值并不是 HashMap 那样等于数组容量乘扩容因子（一般为0.75），而是扩容阈值直接等于当前数组程度，即空间用完了就扩容（2倍）。

注：其实这样做合理，因为毕竟只有一个线程在使用，初始的 16 个位置已经够多了，没必要在我用 12/13 个时扩个容。

2.2 get()

在当前线程的 theadLocals 中获取当前ThreadLocal对象对应的value

  1. 在当前线程拿到threadLocals
  2. 若threadLocals=null，则将其初始化
  3. 通过当前ThreadLocal对象获取到相应Entry
    • entry != null ，返回result
    • entry = null ，返回null
public T get() {
    // 拿出当前线程
    Thread t = Thread.currentThread();
    // 从线程中拿到 threadLocals(ThreadLocalMap)
    ThreadLocalMap map = getMap(t);
    
    if (map != null) {
        // 从 map 中拿到相应entry
        ThreadLocalMap.Entry e = map.getEntry(this);
        // 如果不为空，读取当前 ThreadLocal 中保存的值
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    // 否则给当前线程的 ThreadLocal 初始化，并返回初始值 null
    return setInitialValue();
}

3.ThreadLocalMap

  • 虽然是内部类，但 ThreadLocalMap 不像 List 的 Node 是 List 的组成部分（List > Node)
  • ThreadLocalMap是用来给Thread作为属性，并保存ThreadLocal的 (Thread > ThreadLocalMap > ThreadLocal)
// 静态内部类,可直接被外部调用
static class ThreadLocalMap {
        // Entry(k,v)
    	// k = WeakReference 是弱引用，当没有引用指向时，会直接被回收
        static class Entry extends WeakReference<ThreadLocal<?>> {
            // 当前 ThreadLocal 关联的值
            Object value;
            // WeakReference 的引用 referent 就是 ThreadLocal
            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
    	
    	// 存储 (ThreadLocal,Obj) 的数组
    	// 这里其实采用的是哈希表，后面可以看到解决哈希冲突的办法是开放寻址法
        private Entry[] table;
        // 数组的初始化大小
        private static final int INITIAL_CAPACITY = 16; 
        // 扩容的阈值，默认是数组大小的三分之二
        private int threshold;
		
		//.......
}

这里放一个链接吧：【数据结构】哈希表，从特性到哈希冲突再到应用，可以先看看哈希表解决冲突的几种方案，然后再看 set 方法…

3.1 set()

将 Entry（threadLocal，Object Value）放入 threadLocals的数组

  1. 获取到 threadLocals 的数组
  2. 计算当前ThreadLocal对应的数组下标
  3. 将Entry（threadLocal，Object Value）放入数组
    • 无hash碰撞，new Entry放入
    • 若出现hash碰撞，则i++，直到找到没有Entry的位置，new Entry放入（开放寻址法）
    • 若碰见key相同（ThreadLocal），则替换value
  4. 判断是否需要扩容
private void set(ThreadLocal<?> key, Object value) {
    // 1.拿到当前threadLocals的数组
    Entry[] tab = table;
    int len = tab.length;
    // 2.计算当前 ThreadLocal 在数组中的下标，其实就是 ThreadLocal 的 hashCode 和数组大小-1取余
    int i = key.threadLocalHashCode & (len-1);
	
	// 可以看到循环的结束条件是 tab[i]==null，即无哈希冲突
	// 若出现哈希冲突时，依次向后（i++）寻找空槽点。nextIndex方法就是让在不超过数组长度的基础上，把数组的索引位置 + 1
	// nextIndex(int i, int len) {return ((i + 1 < len) ? i + 1 : 0);} 如果到数组末尾了，返回 0（循环）
    for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get();
        // 找到内存地址一样的 ThreadLocal，直接替换
        if (k == key) {
            e.value = value;
            return;
        }
        // 当前 key 是 null，说明 ThreadLocal 被清理了，直接替换掉
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }
    // 当前 i 位置是无值的，可以被当前 thradLocal 使用
    tab[i] = new Entry(key, value);
    int sz = ++size;
    
    // 当数组大小大于等于扩容阈值(数组的长度)时，进行扩容
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

3.2 getEntry()

获取相应节点Entry

  1. 计算当前ThreadLocal对应的索引位置（hashcode 取模数组大小-1 ）
  2. 若 e != null，返回当前Entry
  3. 若 e == null 或 有但key(ThreadLocal)不符，调用 getEntryAfterMiss 自旋进行寻找
private Entry getEntry(ThreadLocal<?> key) {
    // 计算索引位置：ThreadLocal 的 hashCode 取模数组大小-1
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    
    // e 不为空 && e 的 ThreadLocal 的内存地址和 key 相同
    if (e != null && e.get() == key)
        return e; // 直接返回
    // 因为上面解决Hash冲突的方法是i++，所以会出现计算出的槽点为空或者不等于当前ThreadLocal的情况
    else
        return getEntryAfterMiss(key, i, e); // 继续通过 getEntryAfterMiss 方法找
}

getEntryAfterMiss：根据 thradLocalMap set 时解决数组索引位置冲突的逻辑，该方法的寻找逻辑也是对应的，即自旋 i+1，直到找到为止

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    Entry[] tab = table;
    int len = tab.length;
    // 在大量使用不同 key 的 ThreadLocal 时，其实还蛮耗性能的
    while (e != null) {
        ThreadLocal<?> k = e.get();
        // 内存地址一样，表示找到了
        if (k == key)
            return e;
        // 删除没用的 key
        if (k == null)
            expungeStaleEntry(i);
        // 继续使索引位置 + 1
        else
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null;
}

3.3 resize()

ThreadLocalMap 中的 ThreadLocal 的个数超过阈值时，ThreadLocalMap 就要开始扩容了

  1. 拿到 threadLocals 的table
  2. 初始化新数组，大小为原来2倍
  3. 将老数组拷贝到新数组
    • 根据key（ThreadLocal）计算新的索引位置
    • 若出现hash碰撞，i++
  4. 计算新的扩容阈值，将新数组赋给table

注：由于是一个线程，所以所有操作都是串行的，所以不存在线程安全问题。

private void resize() {
    // 1.拿出旧的数组
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    // 2.计算新数组的大小，为老数组的两倍
    int newLen = oldLen * 2;
    // 初始化新数组
    Entry[] newTab = new Entry[newLen];
    int count = 0;
    
    // 3.老数组的值拷贝到新数组上
    for (int j = 0; j < oldLen; ++j) {
        Entry e = oldTab[j];
        if (e != null) {
            ThreadLocal<?> k = e.get();
            if (k == null) {
                e.value = null; // Help the GC
            } else {
                // 计算 ThreadLocal 在新数组中的位置
                int h = k.threadLocalHashCode & (newLen - 1);
                // 如果出现哈希冲突，即索引 h 的位置值不为空，往后+1，直到找到值为空的索引位置
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                // 给新数组赋值
                newTab[h] = e;
                count++;
            }
        }
    }
    // 4.计算新数组下次扩容阈值，为数组长度的长度
    setThreshold(newLen);
    size = count;
    table = newTab;
}
A minor
关注
专栏目录
java中的ThreadLocal详解及示例代码
poker_zero的博客
04-18 436
ThreadLocal 根据名字我们可以知道这是一个线程本地变量，每一个线程都回copy一个副本，可以为创造对象减少不必要的开销(单例)，但是不能保证线程安全(每个线程的结果可能是不一样的) ThreadLocal对比锁机制： 锁机制是以时间换空间，让多个线程依次访问一个资源 ThreadLocal是以空间换时间，每个线程拥有资源的一个副本，不会相互影响 ThreadLocal类常用方法： get：获得线程局部变量中的值 set：设置值 remove：删除值 initialValue：给值进行初始
ThreadLocal示例及源码浅析
lhxaiee123的博客
08-30 358
实现数据隔离了解一个东西，我们当然要先问为什么要了解他。在多线程的访问环境下，我们都会考虑线程安全的问题，所谓线程安全，就是为了确保多个线程访问的资源能与在单线程访问时返回的结果一致，不会产生二义性，也可以说是保证多线程安全访问竞争资源的一种手段。常规来说，synchronized关键字和Java5新增的java.util.concurrent.locks下的Lock和ReentrantLock包从
ThreadLocal 示例
amy841221的博客
09-30 185
ThreadLocal, 从字面意思上看是本地线程. 但实际上它是一个线程本地变量.它的功能就是为每一个使用该变量的线程都提供一个变量值的副本, 从而使得不会与其他线程的副本冲突. 与使用synchronized解决同步问题一样的作用, 区别是synchronized是通过使用加锁的方式来实现的,而ThreadLocal是通过其内部定义的一个Map来存放每一个线程的变量副本来实现的. ...
ThreadLocal示例
xiaomage0077的博客
03-25 189
ThreadLocal示例
java threadlocal用法_Java中ThreadLocal的详细介绍（代码示例）
weixin_42114645的博客
02-16 3393
本篇文章给大家带来的内容是关于Java中ThreadLocal的详细介绍(代码示例)，有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。ThreadLocal基本在项目开发中基本不会用到, 但是面试官是比较喜欢问这类问题的;所以还是有必要了解一下该类的功能与原理的.ThreadLocal是什么ThreadLocal是一个将在多线程中为每一个线程创建单独的变量副本的类; 当使用Threa...
Java并发编程艺术
nalanmingdian的博客
07-26 1063
一、并发编程面临的挑战 并发编程的目的是为了让程序运行更快，但并不是启动多线程就能让程序最大限度地并发执行。还会面临上下文切换、死锁、软硬件的资源限制等问题。 上下文切换 CPU通过给每个线程分配CPU时间片来实现多线程并发执行。时间片一般几十毫秒，因此CPU通过不停地切换线程执行，让我们感官上觉得多个线程是同时执行的。 通过时间片分配算法来循环执行任务，当前任务执行一个时间片后切到下一时间片，但在切换前会保存上一任务的状态，以便下次切回来时可以再加载该任务状态。 任务从保存到再加载的过程就
Java并发编程基础（一篇入门）
行者无疆的博客
03-09 5394
1 并发编程简介 1.1 什么是并发编程 所谓并发编程是指在一台处理器上 “同时” 处理多个任务。并发是在同一实体上的多个事件。多个事件在同一时间间隔发生。 并发编程，从程序设计的角度来说，是希望通过某些机制让计算机可以在一个时间段内，执行多个任务。从计算机 CPU 硬件层面来说，是一个或多个物理 CPU 在多个程序之间多路复用，提高对计算机资源的利用率。从调度算法角度来说，当任务数量多于 CPU 的核数时，并发编程能够通过操作系统的任务调度算法，实现多个任务一起执行。 1.2 并发编程的重要性 对于一个
Java 高并发九：锁的优化和注意事项详解
09-01
Java高并发编程中，锁的优化与注意事项是关键议题，特别是在多线程环境下，正确地使用锁能够确保程序的正确性和提升系统性能。本文将详细探讨锁优化的思路与方法，虚拟机内的锁优化策略，一个错误使用锁的案例，以及...
Java并发编程的艺术_Conc
qq_38777662的博客
09-13 998
Java并发编程的艺术 1 并发编程的挑战 1.1 上下文切换 即使是单核处理器也支持多线程执行代码，CPU通过给每个线程分配CPU时间片来实现这个机制。时间片是CPU分配给各个线程的时间，因为时间片非常短，所以CPU通过不停地切换线程执行，让我们感觉多个线程是同时执行的，时间片一般是几十毫秒（ms）。 CPU通过时间片分配算法来循环执行任务，当前任务执行一个时间片后会切换到下一个任务。但是，在切换前会保存上一个任务的状态，以便下次切换回这个任务时，可以再加载这 个任务的状态。所以任务从保存到再加载的过程就
Java并发编程之美pdf百度云，顺利通过阿里Java岗面试
fanzhang_vip0723的博客
07-27 594
面试整体事项 简历要准备好，联系方式一定要正确清晰醒目，项目经历按照时间倒序阐述，注意描述自己在项目中承担的职责，简历的模板尽量选择简洁的，毕竟程序员大部分还是喜欢简单明了的。 推荐boss直聘，我觉得很好用（不是广告）。 一般的整体面试流程都是电面->现场面->HR面->等着。 不要觉得HR说让你回去等消息就是GG了，他们也要跟你之前的面试官讨论，再向领导汇报，如果说不急可能还要和其他候选人比较，所以HR让你回去等消息绝对不是说明你完蛋了。 面试前准备好自我介绍，1分钟左右就可以，可以
ThreadLocal应用示例及理解
11-25
ThreadLocal应用示例及理解，这个写了相关的示例，可以参考一下。
ThreadLocal详解及用法示例
最新发布
Rcain_R的博客
03-20 5130
ThreadLocal详解及用法示例
Java线程池几个参数的理解
Jungle_hello的博客
10-11 1002
线程池几个参数的理解:比如去火车站买票, 有10个售票窗口, 但只有5个窗口对外开放. 那么对外开放的5个窗口称为核心线程数, 而最大线程数是10个窗口.如果5个窗口都被占用, 那么后来的人就必须在后面排队, 但后来售票厅人越来越多, 已经人满为患, 就类似于线程队列已满.这时候火车站站长下令, 把剩下的5个窗口也打开, 也就是目前已经有10个窗口同时运行. 后来又来了一批人,10个窗口也处理不过来
ThreadLocal测试代码示例
lucky的专栏
12-12 916
package com.bjsxt.base.conn010; public class ConnThreadLocal {     public static ThreadLocal&lt;String&gt; th = new ThreadLocal&lt;String&gt;();          public void setTh(String value){         th....
ThreadLocal代码演示
窗外的羊
08-16 92
给每个线程提供局部变量，解决线程安全，直接上代码演示 package com; class Res{ public static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>() { @Override protected Integer initialValue() { return 0; } }; pu
ThreadLocal例子
飞奔的小强
03-16 175
ThreadLocal的方法 ThreadLocal类接口很简单，只有4个方法，我们先来了解一下： void set(Object value)设置当前线程的线程局部变量的值。 public Object get()该方法返回当前线程所对应的线程局部变量。 public void remove()将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是JDK 5.0新增的方法。需要...
ThreadLocal 例子
GaoShanLiShui123456的博客
03-06 277
ThreadLocal 例子一看就懂 测试启动了两个线程，此时threadLocal 在两个线程中分别有一个值，互不影响。 threadlocal 里面的数据是当前线程相关的，threadlocal 里面取的数据就是当前线程的数据。 public class threadLocalTest { private static ThreadLocal&lt;Integer&gt; x=new Thre...
ThreadLocal实例
代码写的越急，程序跑得越慢。
08-29 233
如果你定义了一个单实例的java bean，它有若干属性，但是有一个属性不是线程安全的，比如说HashMap。并且碰巧你并不需要在不同的线程中共享这个属性，也就是说这个属性不存在跨线程的意义。那么你不要sychronize这么复杂的东西，ThreadLocal将是你不错的选择。 import java.util.HashMap; public class TreadLocalTest { static ThreadLocal<HashMap> map0 = new ThreadLoc
ThreadLocal简单举例
longdragen的专栏
10-18 364
public class ThreadLocalTest { public static void main(String[] args) throws InterruptedException { for(int i=0;i<10;i++) { ThreadT t=new ThreadT(); t.start(); } } } class Thre
Java并发编程：ThreadLocal源码深度解析
"Java并发编程中的ThreadLocal源码解析，探讨了ThreadLocal如何解决线程安全问题，并分析了ThreadLocal的内部实现机制，包括ThreadLocalMap的使用" 在Java并发编程中，线程安全是一个核心议题。传统的解决线程安全...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

A minor

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值