ThreadLocal源码分析：（一）set(T value)方法

最新推荐文章于 2024-09-05 12:44:17 发布
最新推荐文章于 2024-09-05 12:44:17 发布
阅读量1.2k 收藏 2
点赞数 2
分类专栏： java 源码分析 ThreadLocal 并发控制 文章标签： java 源码分析  ThreadLocal
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/noodleprince/article/details/79711307
版权

在ThreadLocal的get(),set()的时候都会清除线程ThreadLocalMap里所有key为null的value。
而ThreadLocal的remove()方法会先将Entry中对key的弱引用断开，设置为null，然后再清除对应的key为null的value。
本文分析set方法

ThreadLocal类的set方法

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);     // 获取线程t中的ThreadLocalMap
    if (map != null)
        map.set(this, value);   // 见代码1
    else
        createMap(t, value);    // 创建新的ThreadLocalMap
}

可以看到，set()方法中就是map.set()方法是在干实事，深入进去看看。

代码1：
ThreadLocal.ThreadLocalMap类的set方法

private void set(ThreadLocal<?> key, Object value) {
    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);

    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get(); // 通过value来反查key，比较少见的操作，见代码2

        if (k == key) { // 在ThreadLocalMap对象中找到了要设置的key，则直接覆盖原来的value
            e.value = value;
            return;
        }

        if (k == null) {
            replaceStaleEntry(key, value, i);   // 见代码8
            return;
        }
    }

    tab[i] = new Entry(key, value);     // 新增一个Entry节点
    int sz = ++size;
    if (!cleanSomeSlots(i, sz) && sz >= threshold)      // 如果size大于等于threshold，且执行cleanSomeSlots方法（见代码3）返回为false
        rehash();   // 执行rehash方法，见代码5
}

这里面查找ThreadLocalMap的key，居然是通过value来反查的，比较少见。先看看Entry的定义吧：

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

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

Entry又是定义在ThreadLocalMap中的静态内部类，继承了WeakReference类，WeakReference类又继承自Reference类，在Reference类中，有一个引用变量：

public abstract class Reference<T> {
    private T referent;
}

在Entry的构造方法中，构造新的Entry对象，referent变量存储传入的ThreadLocal对象的引用作为key，value则存储真正的值，这样将ThreadLocal对象和value的对应关系给存储下来。
那么我们看到上面的e.get()方法，实际上是调用的Reference类的get方法。

代码2：
Reference类的get方法：

public T get() {
    return this.referent;
}

很简单的实现，就是返回存储的referent。

接下来先看看要对table进行rehash的条件判断和实际操作
代码3
ThreadLocal.ThreadLocalMap类的cleanSomeSlots方法

private boolean cleanSomeSlots(int i, int n) {
    boolean removed = false;
    Entry[] tab = table;
    int len = tab.length;
    do {
        i = nextIndex(i, len);
        Entry e = tab[i];
        if (e != null && e.get() == null) { // entry不为null且entry中的key为null
            n = len;
            removed = true;
            i = expungeStaleEntry(i);   // 见代码4
        }
    } while ( (n >>>= 1) != 0); // 等价于n=n>>>1，>>>为无符号右移
    return removed;
}

该方法只是做了几次检查，没有把table整个扫一遍。源码注释的解释是说这样子性能是介于完全不检查（快速但是会遗留内存垃圾）与检查与table长度比例的元素个数（时间复杂度是O(n)）之间的。这里贴出源码注释，如果有更深刻的理解可以探讨一下。
Heuristically scan some cells looking for stale entries. This is invoked when either a new element is added, or another stale one has been expunged. It performs a logarithmic number of scans, as a balance between no scanning (fast but retains garbage) and a number of scans proportional to number of elements, that would find all garbage but would cause some insertions to take O(n) time.

代码4
ThreadLocal.ThreadLocalMap类的expungeStaleEntry方法

private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;

    // expunge entry at staleSlot
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    size--;     // 以上代码，将entry的value赋值为null，这样方便GC时将真正value占用的内存给释放出来；将entry赋值为null，size减1，这样这个slot就又可以重新存放新的entry了

    // Rehash until we encounter null
    Entry e;
    int i;
    for (i = nextIndex(staleSlot, len); // 从staleSlot后一个index开始向后遍历，直到遇到为null的entry
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();
        if (k == null) {    // 如果entry的key为null，则清除掉该entry
            e.value = null;
            tab[i] = null;
            size--;
        } else {
            int h = k.threadLocalHashCode & (len - 1);
            if (h != i) {   // key的hash值不等于目前的index，说明该entry是因为有哈希冲突导致向后移动到当前index位置的
                tab[i] = null;

                // Unlike Knuth 6.4 Algorithm R, we must scan until
                // null because multiple entries could have been stale.
                while (tab[h] != null)      // 对该entry，重新进行hash并解决冲突
                    h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    return i;   // 返回经过整理后的，位于staleSlot位置后的第一个为null的entry的index值
}

expungeStaleEntry方法不止清理了staleSlot位置上的entry，还把staleSlot之后的key为null的entry都清理了，并且顺带将一些有哈希冲突的entry给填充回可用的index中。

代码5
ThreadLocal.ThreadLocalMap类的rehash方法

private void rehash() {
    expungeStaleEntries();  // 见代码6

    // Use lower threshold for doubling to avoid hysteresis
    if (size >= threshold - threshold / 4)  // 进行resize的条件更苛刻了，只要大于等于3/4*threshold就进行resize
        resize();   // 见代码7
}

首先整理table中key为null的entry，然后进行可能的resize操作

代码6
ThreadLocal.ThreadLocalMap类的expungeStaleEntries方法

private void expungeStaleEntries() {
    Entry[] tab = table;
    int len = tab.length;
    for (int j = 0; j < len; j++) {
        Entry e = tab[j];
        if (e != null && e.get() == null)   // entry不为null且entry的key为null
            expungeStaleEntry(j);       // 调用代码1.4的expungeStaleEntry方法
    }
}

这里见到了前面分析过的expungeStaleEntry方法，也就是对table中entry进行清理。

代码7
ThreadLocal.ThreadLocalMap类的resize方法

private void resize() {
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    int newLen = oldLen * 2;
    Entry[] newTab = new Entry[newLen];
    int count = 0;

    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 {
                int h = k.threadLocalHashCode & (newLen - 1);
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                newTab[h] = e;
                count++;
            }
        }
    }

    setThreshold(newLen);
    size = count;
    table = newTab;
}

resize方法很熟悉了，将table容量翻倍，不过多分析了。

代码8
最后看看ThreadLocal.ThreadLocalMap类的replaceStaleEntry方法

private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                               int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    Entry e;

    int slotToExpunge = staleSlot;
    for (int i = prevIndex(staleSlot, len); // 从staleSlot位置向前找，找到最先一个需要清理的entry
         (e = tab[i]) != null;
         i = prevIndex(i, len))
        if (e.get() == null)
            slotToExpunge = i;

    for (int i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) 
{
        ThreadLocal<?> k = e.get();

        if (k == key) { // 发生这种情况，说明在key本应存储的hash位置和key实际存储位置之间有出现了key为null的entry
            e.value = value;

            tab[i] = tab[staleSlot];
            tab[staleSlot] = e;
// 这两句代码，将要清理的staleSlot位置的entry，和后面发现的因冲突而存储到i位置的两个entry进行对调

            if (slotToExpunge == staleSlot)
                slotToExpunge = i;
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            return;
        }

        if (k == null && slotToExpunge == staleSlot)
            slotToExpunge = i;
    }

    // If key not found, put new entry in stale slot
    tab[staleSlot].value = null;    // 先将原来entry的value引用断开，再讲新entry放到staleSlot位置中
    tab[staleSlot] = new Entry(key, value);

    // If there are any other stale entries in run, expunge them
    if (slotToExpunge != staleSlot) // 清理其他key为null的entry
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}

这个方法比较复杂，逻辑看的有点混乱，大概是清理了一下staleSlot位置的entry，还做了进一步的清理工作，我也有点理不清楚了。如果有错误请各位读者帮忙斧正。

ThreadLocal类的set(T value)方法就分析完了，做了两部分工作，一是把新的value和相对应的threadLocal对象存放进ThreadLocalMap中了，二就是对ThreadLocalMap中key已经为null的entry进行了清理，方便GC来回收这部分内存。

系列文章链接：
ThreadLocal源码分析：（一）set(T value)方法
ThreadLocal源码分析：（二）get()方法
ThreadLocal源码分析：（三）remove()方法

noodleprince
关注
专栏目录
ThreadLocal源码分析和使用
12-25
ThreadLocal 源码分析和使用 ThreadLocal 是 Java 语言中的一种多线程编程机制，用于解决多线程程序的并发问题。它不是一个 Thread，而是一个 Thread 的局部变量。ThreadLocal 的出现是为了解决多线程程序中的共享...
死磕Java之聊聊ThreadLocal源码(基于JDK1.8)
XYC3939的博客
05-07 311
记得在一次面试中被问到ThreadLocal，答得马马虎虎，所以打算研究一下ThreadLocal的源码 面试官 ： 用过ThreadLocal吗？ 楼主答 ： 用过，当时使用ThreadLocal的时候，使用Spring实现横切整个Controller层，使用ThreadLocal实现了统计每次请求对应方法的执行时间，具体代码如下 ...
Java：ThreadLocal解析
qq_46119575的博客
07-05 1877
ThreadLocal 是java中非常重要的内容，本文尽可能的全面介绍了 ThreadLocal内容，包括内存泄漏，key弱引用等问题第一种解释：ThreadLocal叫做线程变量，意思是ThreadLocal中填充的变量属于当前线程，该变量对其他线程而言是隔离的，也就是说该变量是当前线程独有的变量。ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。
深入理解 `ThreadLocal` 的 `set` 和 `get` 方法
最新发布
weixin_54574094的博客
09-05 483
的set和get方法提供了线程局部变量的存储和检索机制。每个线程维护自己的，即使使用相同的实例，不同线程间的数据也不会互相干扰。理解的内部工作机制有助于更好地管理线程局部数据和提高并发编程的效率。
ThreadLocal知识点
weixin_45866849的博客
08-09 164
ThreadLocal知识点 1.线程封闭 在了解ThreadLocal之前，我们先了解下什么是线程封闭。 对象封闭在一个线程里，即便这个对象不是线程安全的，也不会出现并发安全问题。 例如 栈封闭：就是用栈（stack）来保证线程安全。 public void testThread() { StringBuilder s = new StringBuilder(); s.append("Hello"); } StringBuilder是线程不安全的，但是它只是个局部变量，局部存储在虚拟
ThreadLocal 基本原理与set源码解析
HeiheiChihiro的博客
08-07 704
看文章前先了解java弱引用和多线程 简介 当我们想要多个线程使用同一个变量时，会出现并发安全问题，这时候我们必须采取措施，对变量的访问进行同步。 为了达到这个目的，我们一般是采用加锁的方式解决，但是加锁的方式太重了，会使系统的并发量大大降低，有什么办法能够解决这个问题呢？ 当然有，不过是另辟蹊径: 不对访问进行同步，而是对每个线程，复制一份该变量，每个线程操作自己的那部分变量，来消除并发安全。Threadlocal就是用来干这个的 Threadlocal的使用 public class MyThrea.
史上最全最详细的ThreadLocal 使用
热门推荐
半夏_2021的博客
08-31 1万+
文章目录ThreadLocal 简介ThreadLocal 的四个方法 ThreadLocal 简介 一种解决多线程环境下成员变量的问题的方案，但是与线程同步无关，其思路是为每一个线程创建一个单独的变量副本，从而每个线程都可以独立地改变所拥有的变量副本，而不会影响其他线程所对应的副本。 ThreadLocal不是用于解决共享变量的问题的，也不是为了协调线程同步而存在，而是为了方便每个线程处理自己的状态而引入的一个机制。 ThreadLocal 的四个方法 void set(Object value)
ThreadLocal set方法解析
weixin_38965431的博客
03-04 4480
ThreadLocal 源码 原理
ThreadLocal_ThreadLocal源码分析_源码.zip
10-18
2. 设置值：使用`set(T value)`方法为当前线程设置值，这个值只对当前线程可见。 3. 获取值：使用`get()`方法获取当前线程的值。如果之前没有设置过值，那么get()会返回null。 4. 清除值：使用`remove()`方法可以...
ThreadLocal 线程本地变量 及 源码分析.rar_开发_设计
09-20
以上是对ThreadLocal的简单介绍和源码分析，实际使用中还需要结合具体业务场景进行合理设计和优化。通过深入理解ThreadLocal的工作原理，可以帮助我们更好地利用这一工具，提高代码的并发性能和可维护性。
java并发包源码分析(3)ThreadLocal
07-05
ThreadLocal的set方法用于将一个值放入当前线程的ThreadLocalMap中。这个方法首先会创建一个Entry对象，这个对象包含了一个ThreadLocal的弱引用和要存储的值。然后将这个Entry对象加入到当前线程的ThreadLocalMap中...
Java ThreadLocal用法实例详解
08-25
ThreadLocal的基本使用非常简单，只需要定义一个ThreadLocal变量，然后使用set方法设置初始值，使用get方法获取当前线程的值。 ThreadLocal的实现原理基于ThreadLocalMap，该map将每个线程作为key，线程局部变量...
ThreadLocal详解包括Get、Set方法以及，ThreadLocal内存泄漏问题。
zzzzzzzzzzzzzzzy的博客
06-17 1025
我们可以看到此处的set方法，set方法的入参为泛型对应我们上述创建的ThreadLocal时填入的泛型。我们可以看到该类是由泛型修饰的，所以我们在创建的时候可以通过泛型去控制ThreadLocal里面存放的数据类型。这里我定义的泛型为String，我们通过set方法往对应线程里面设置参数。所以它具体的初始化应该是在它的其他方法调用的时候进行初始化的。ThreadLocal的创建是通过New的方式生成的。为C实现的一个本地方法是为了获取当前的线程信息。首先获取到Enrty数组，获取数组的长度。
ThreadLocal的set，get源码解析
zhouhengzhe的博客
07-31 2040
1、set源码 public void set(T value) { Thread t = Thread.currentThread();//获取当前线程 ThreadLocalMap map = getMap(t);//获取ThreadLocalMap 对象 if (map != null)//判断对象是否为空 map.set(this, value);//map不为null，设置值 else
ThreadLocal的get方法、set方法，以及其内存泄露问题
小金的博客
02-03 826
既然多线程访问同一个变量会造成线程安全的问题，那么创建出来一个变量，需要使用这个变量的线程将该变量拷贝一份，并且拷贝到每一个线程的变量是线程私有的，使得变量在线程之间隔离起来使用，避免了线程之间的交错使用数据造成的线程安全问题。
ThreadLocal分析二：set()方法解读
Chen_leilei的博客
12-09 3248
ThreadLocal的Set()方法
ThreadLocal源码分析
Yuwen_forJava的博客
03-11 925
1.ThreadLocal 是什么 Threadlocal 是 jdk 中一个非常重要的工作类。它是线程本地存储，可以保证各个线程之间的变量互不干扰。 它的数据结构： ThreadLocalMap有点类似HashMap的结构，只是HashMap是由数组+链表实现的，而ThreadLocalMap中并没有链表结构。 注意Entry， 它的key是继承自WeakReference， 是弱引用类型，在 GC 时，key 有可能会被回收掉。 2.ThreadLocal 的方法 2.1 set()
十分钟带你了解清楚什么是ThreadLocal
m0_62609939的博客
03-13 995
ThreadLocal
java 浅谈ThreadLocal底层源码（通俗易懂）
Cyan_RA9的博客
09-01 2007
java ThreadLocal介绍及源码分析 通俗易懂！
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值