ThreadLocal 实现原理

已于 2022-09-22 19:18:53 修改
阅读量256 收藏
点赞数
分类专栏： Java 文章标签： java
于 2022-09-21 23:58:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30763385/article/details/126983178
版权

ThreadLocal 的作用是，对某一共享变量的操作，仅对当前线程可见

public static void main(String[] args) throws InterruptedException {
  ThreadLocal<String> threadLocal = new ThreadLocal<>();
  Thread thread = new Thread(() -> {
    System.out.println(threadLocal.get());    // null
    threadLocal.set("thread");
    System.out.println(threadLocal.get());    // thread
  });
  thread.start();
  thread.join();
  
  System.out.println(threadLocal.get());    // null  其他线程对 threadLocal 的修改，在另外一个线程中，不可见
  threadLocal.set("main");
  System.out.println(threadLocal.get());    // main
}

set 方法

public class ThreadLocal<T> {

  static class ThreadLocalMap {
    static class Entry extends WeakReference<ThreadLocal<?>> {
      //......  
    }
    private void set(ThreadLocal<?> key, Object value) {  
      //......  
    }
  }

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

Thread 类中有一个 threadLocals的成员变量，其类型为ThreadLocal.ThreadLocalMap

public class Thread implements Runnable {
    ThreadLocal.ThreadLocalMap threadLocals = null;
}

通过 threadLocals ，可将 Thread 与 ThreadLocal 关联起来

你可以这样理解：ThreadLocal 中的 set 操作的都是 threadLocals ，也就是，只操作当前线程的 threadLocals ，因此，对其他线程不可见
threadlocal图片
ThreadLocalMap 上有个 table 的数组，用于存放 Entry （数组中的元素要么为 Entry、要么为 null）

Entry 中：

  • key 为指向 ThreadLocal 实例的弱引用
  • value 为 ThreadLocal 的初始化值或当前线程中 set 方法的值

同一线程下的 ThreadLocal 共用同一个 ThreadLocalMap（通过 Thread 下的 threadLocals 变量）

不同线程，不同 threadLocals -> 不同 ThreadLocalMap

相同线程，共用 threadLocals -> 相同线程下，不同 ThreadLocal，都是存放在 ThreadLocalMap的 table中

createMap

public class ThreadLocal<T> {
  void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
  }
  
  static class ThreadLocalMap {
    private Entry[] table;    // <------ 给 table 初始化
    ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
      table = new Entry[16];
      // firstKey.threadLocalHashCode = new AtomicInteger().getAndAdd(0x61c88647)
      int i = firstKey.threadLocalHashCode & (16- 1);
      table[i] = new Entry(firstKey, firstValue);
      size = 1;
      setThreshold(INITIAL_CAPACITY);
    }
  }
}

在 createMap 函数中执行 new ThreadLocalMap 的时候，将 this 传入，即将 ThreadLocal 实例作为参数，该参数之后通过 hash 计算，可得到 table 中对应索引

通过斐波那契散列，可使分布更加均匀

（32位整数）hash_increment: 2 32 × 0.618 = − 1640531527 ( 十进制 ) = 61 c 88647 ( 十六进制 ) 2 ^ {32} \times 0.618 = -1640531527(十进制) = 61c88647(十六进制) 232×0.618=−1640531527(十进制)=61c88647(十六进制)

table 数组中存放的是 Entry 对象，该对象的 key 是个弱引用

static class Entry extends WeakReference<ThreadLocal<?>> {
  Object value;
  Entry(ThreadLocal<?> k, Object v) {
    super(k);    // <----- k 为弱引用
    value = v;
  }
}

调用过 ThreadLocal.set() 方法后，每个线程都会维护一个类型为 ThreadLocalMap 的成员变量

该成员变量名为 threadLocals ，内部有个 table 的数组，存放 Entry 的对象

weakreference

static Object object = new Object();
public static void main(String[] args) {
  WeakReference<Object> objectWeakReference = new WeakReference<>(object);
  objectWeakReference = null;
  System.gc();
  System.out.println(objectWeakReference.get());
}

Exception in thread “main” java.lang.NullPointerException
at org.example.zhang.Demo.main(Demo.java:19)

map.set(this, value)

private void set(ThreadLocal<?> key, Object value) {    // key 为 ThreadLocal 的 this
  // We don't use a fast path as with get() because it is at
  // least as common to use set() to create new entries as
  // it is to replace existing ones, in which case, a fast
  // path would fail more often than not.
  // 我们不像 get() 那样使用 fast path ，因为使用 set() 创建新 entries 与替换现有 entries 一样普遍，在这种情况下，fast path 往往会失败.

  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)]) {    // 情况三：槽位上不为空，但 Entry 上的 key 与当前 ThreadLocal 不相等，进入下一次循环
    ThreadLocal<?> k = e.get();    // 返回 Entry 的 key，实际调用 Reference#get{  return this.referent;  }（WeakReference extends Reference）

    if (k == key) {    // 情况一：槽位上不为空，Entry 上的 key 与当前 ThreadLocal 相等，覆盖
      e.value = value;
      return;
    }

    if (k == null) {    // 情况二：槽位上不为空，而 Entry 上的 key 为空，说明 key(弱引用)被回收了
      replaceStaleEntry(key, value, i);
      return;
    }
  }

  tab[i] = new Entry(key, value);    // 情况四：槽位上为空，直接更新
  int sz = ++size;
  if (!cleanSomeSlots(i, sz) && sz >= threshold)
    rehash();    // 扩容
}

private static int nextIndex(int i, int len) {
  return ((i + 1 < len) ? i + 1 : 0);
}

通过 threadlocal 实例的 hash 值可定位到 table 的具体槽位

  • 情况一：槽位上不为空，Entry 上的 key 与当前 ThreadLocal 相等，覆盖
  • 情况二：槽位上不为空，而 Entry 上的 key 为空，说明 key(弱引用)被回收了，执行 replaceStaleEntry 方法
    • 后面的 Entry key 相等：交换
    • 后端的槽位上为空：在当前 Entry key 为 null 的槽位上直接更新
  • 情况三：槽位上不为空，但 Entry 上的 key 与当前 ThreadLocal 不相等，进入下一次循环
  • 情况四：槽位上为空，直接更新

在这里插入图片描述

replaceStaleEntry

情况二：槽位上不为空，而 Entry 上的 key 为空，说明 key(弱引用)被回收了，执行 replaceStaleEntry 方法

当前位置的 key 已被回收，ThreadLocal 认为这些 key 是无效的，需替换和清理

向前遍历

向前遍历，寻找过期 key，即 Entry 为 null 的槽位（遍历过程中，若遇到槽位上为空的情况，则结束向前遍历）

  • 找到：slotToExpunge = i;
  • 遍历结束后未找到过期 key：因为 prevIndex 为 (i - 1 >= 0) ? i - 1 : len - 1，i = 0 会返回 len -1，即数组中最后一个元素
    这里有个疑问，若整个数组内的元素都不为 null，则永远无法满足 (e = tab[i]) != null 条件，是否会发生死循环？

向后遍历

  • 槽位上为空 ：跳出循环，在当前槽位上直接更新
  • Entry key 相等：交换
  • Entry key 不相等：若 Entry key 为 null（过期 key），且 slotToExpunge = staleSlot，则更新 slotToExpunge，即 slotToExpunge = i， 然后进入下一次循环；否则直接进入下一次循环
private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                               int staleSlot) {
  Entry[] tab = table;
  int len = tab.length;
  Entry e;

  // Back up to check for prior stale entry in current run.
  // We clean out whole runs at a time to avoid continual
  // incremental rehashing due to garbage collector freeing
  // up refs in bunches (i.e., whenever the collector runs).
  // 备份以检查当前运行中的先前的stale(过期)entry。我们一次清理整个运行，以避免由于垃圾收集器释放成束的引用（即，每当收集器运行时）而导致的持续增量的重新散列。
  int slotToExpunge = staleSlot;
  for (int i = prevIndex(staleSlot, len);    // int prevIndex(int i, int len) {  return ((i - 1 >= 0) ? i - 1 : len - 1)  }
       (e = tab[i]) != null;
       i = prevIndex(i, len))
    if (e.get() == null)
      slotToExpunge = i;    // expunge：删除

  // Find either the key or trailing null slot of run, whichever
  // occurs first
  // 查找运行的 key 或尾部为 null 的空槽，以先发生者为准
  for (int i = nextIndex(staleSlot, len);
       (e = tab[i]) != null;
       i = nextIndex(i, len)) {
    ThreadLocal<?> k = e.get();

    // If we find key, then we need to swap it
    // with the stale entry to maintain hash table order.
    // The newly stale slot, or any other stale slot
    // encountered above it, can then be sent to expungeStaleEntry
    // to remove or rehash all of the other entries in run.
    // 如果我们找到key，那么我们需要将它与过时的entry交换以维护哈希表的顺序。
    // 然后可以将新的stale slot或在其上方遇到的任何其他stale slot发送到 expungeStaleEntry 以删除或重新散列运行中的所有其他条目。
    if (k == key) {    // Entry key 相等：交换
      e.value = value;

      tab[i] = tab[staleSlot];    // 交换
      tab[staleSlot] = e;

      // Start expunge at preceding stale entry if it exists
      // 如果存在，则从先前的stale entry开始删除
      if (slotToExpunge == staleSlot)
        slotToExpunge = i;
      cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
      return;
    }

    // If we didn't find stale entry on backward scan, the
    // first stale entry seen while scanning for key is the
    // first still present in the run.
    // 如果我们在反向扫描中没有找到stale entry，那么在扫描key时看到的第一个stale entry是第一个仍然存在于运行中的entry。
    if (k == null && slotToExpunge == staleSlot)
      slotToExpunge = i;
  }

  // If key not found, put new entry in stale slot    未找到，在当前槽位上直接更新
  tab[staleSlot].value = null;
  tab[staleSlot] = new Entry(key, value);

  // If there are any other stale entries in run, expunge them
  // 如果运行中有任何其他 stale entries，删除它们
  if (slotToExpunge != staleSlot)
    cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}

cleanSomeSlots

  • 在前向遍历的时候，如果还未找到过期 key，遇到了槽位上为 null，则会结束循环，符合 slotToExpunge == staleSlot 条件
    向后遍历时，在交换的情况，之后会执行 cleanSomeSlots(expungeStaleEntry(i), len);，i为要交换的索引（后面的索引）
  • 在前向遍历的时候，如果找到过期 key
    向后遍历时，遇到槽位上为空，直接更新的情况，之后会执行 cleanSomeSlots(expungeStaleEntry(slotToExpunge), len) 方法
private int expungeStaleEntry(int staleSlot) {
  ThreadLocal.ThreadLocalMap.Entry[] tab = table;
  int len = tab.length;

  // expunge entry at staleSlot
  tab[staleSlot].value = null;
  tab[staleSlot] = null;
  size--;

  // Rehash until we encounter null
  ThreadLocal.ThreadLocalMap.Entry e;
  int i;
  for (i = nextIndex(staleSlot, len);
       (e = tab[i]) != null;
       i = nextIndex(i, len)) {
    ThreadLocal<?> k = e.get();
    if (k == null) {  // Entry key 为空，清空过期的 Entry，将其设为 null
      e.value = null;
      tab[i] = null;
      size--;
    } else {    // Entry key 不为空
      int h = k.threadLocalHashCode & (len - 1);     // rehash，使得原本槽位与当前槽位之间的距离更加近
      if (h != i) {
        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)
          h = nextIndex(h, len);
        tab[h] = e;
      }
    }
  }
  return i;
}

private boolean cleanSomeSlots(int i, int n) {
  boolean removed = false;
  ThreadLocal.ThreadLocalMap.Entry[] tab = table;
  int len = tab.length;
  do {
    i = nextIndex(i, len);
    ThreadLocal.ThreadLocalMap.Entry e = tab[i];
    if (e != null && e.get() == null) {
      n = len;
      removed = true;
      i = expungeStaleEntry(i);
    }
  } while ((n >>>= 1) != 0);
  return removed;
}

探测式清理流程：从开始位置向后清理数据，清理过程中：（遇到槽位上为 null，跳出循环）

  • Entry key 为空，设为 null
  • Entry key 不为空，rehash，定位到某一槽位，若该槽位不为 null，向后遍历，知道遇到槽位上为 null 的

通过这种方式，使得原本槽位位置（因为槽位上已占据元素，不得不往后移动）与当前槽位位置之间的距离更近了（假设原本槽位位置与当前槽位位置的中间位置的某一槽位上的 key 过期，调用 expungeStaleEntry后，减少两槽位之间的距离），可优化散列表的查询性能

rehash

情况四：槽位上为空，直接更新，之后，会进行扩容

tab[i] = new ThreadLocal.ThreadLocalMap.Entry(key, value);    // 情况四：槽位上为空，直接更新
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
  rehash();

t h r e s h o l d = 16 × 2 3 = 10 ( 小数部位舍去 ) 1 4 t h r e s h o l d = 10 4 = 2 t h r e s h o l d − 1 4 t h r e s h o l d = 10 − 2 = 8 threshold = 16 \times \frac{2}{3} = 10(小数部位舍去) \\ \frac{1}{4}threshold = \frac{10}{4} = 2 \\ threshold - \frac{1}{4}threshold = 10 -2 = 8 threshold=16×32​=10(小数部位舍去)41​threshold=410​=2threshold−41​threshold=10−2=8

两倍扩容，然后进行 rehash

private void rehash() {
  expungeStaleEntries();    // 清除所有过期 entry

  // Use lower threshold for doubling to avoid hysteresis
  if (size >= threshold - threshold / 4)    // threshold = 16 * 2 / 3 = 10(小数部位舍去)，threshold / 4 = 10 / 4 = 2，threshold - threshold / 4 = 8
    resize();
}

/**
 * Double the capacity of the table.
 */
private void resize() {
  ThreadLocal.ThreadLocalMap.Entry[] oldTab = table;
  int oldLen = oldTab.length;
  int newLen = oldLen * 2;
  ThreadLocal.ThreadLocalMap.Entry[] newTab = new ThreadLocal.ThreadLocalMap.Entry[newLen];
  int count = 0;

  for (int j = 0; j < oldLen; ++j) {
    ThreadLocal.ThreadLocalMap.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;
}

get 方法

public T get() {
  Thread t = Thread.currentThread();
  ThreadLocal.ThreadLocalMap map = getMap(t);
  if (map != null) {
    ThreadLocal.ThreadLocalMap.Entry e = map.getEntry(this);
    if (e != null) {
      @SuppressWarnings("unchecked")
      T result = (T)e.value;
      return result;
    }
  }
  return setInitialValue();    // map 为空，初始化
}

private ThreadLocal.ThreadLocalMap.Entry getEntry(ThreadLocal<?> key) {
  int i = key.threadLocalHashCode & (table.length - 1);
  ThreadLocal.ThreadLocalMap.Entry e = table[i];
  if (e != null && e.get() == key)
    return e;
  else
    return getEntryAfterMiss(key, i, e);  // 槽位上为空，向后查找
}

private ThreadLocal.ThreadLocalMap.Entry getEntryAfterMiss(ThreadLocal<?> key, int i, ThreadLocal.ThreadLocalMap.Entry e) {
  ThreadLocal.ThreadLocalMap.Entry[] tab = table;
  int len = tab.length;
  while (e != null) {
    ThreadLocal<?> k = e.get();
    if (k == key)
      return e;
    if (k == null)
      expungeStaleEntry(i);
    else
      i = nextIndex(i, len);
    e = tab[i];
  }
  return null;
}

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

参考资料

小的时候可菜了
关注
专栏目录
ThreadLocal的实现原理
小一的专栏
05-22 4658
ThreadLocal的实现原理ThreadLocal是线程内部的数据存储类，通过它可以指定的线程中存储数据，数据存储以后，只有在指定线程中可以获取到存储的数据，对于其他线程来说则无法获取数据. 这里基于JDK7进行ThreadLocal的源码实现分析.自定义ThreadLocal实现如何让大家去实现一个ThreadLocal，我相信很多同学第一时间会写出如下代码：public class Thr
ThreadLocal实现原理分析
盛夏温暖流年
04-27 835
一. ThreadLocal是什么 ThreadLocal 可以理解为线程本地变量，每个线程拥有本地变量的副本，各个线程之间的变量互不干扰，主要用于保证多线程环境下变量的安全。 也就是对于同一个 ThreadLocal，每个线程通过 get、set、remove 接口操作只会影响自身线程的数据，不会干扰其他线程中的数据。 二. ThreadLocal的数据结构 ThreadLocal 的数据结构如下图所示： 可以看出，每个线程都拥有自己的一个 ThreadLocalMap，它是 ThreadLocal 中
【原理】Java的ThreadLocal实现原理浅读
dongjizheng9270的博客
05-27 95
当前线程的值传递，ThreadLocal ThreadLocal，顾名思义，即线程本地环境。 具体用途是，在本线程上下文内，通过ThreadLocal.set()设值，可通过ThreadLocal.get()取值。 public class BasicUsage { private static ThreadLocal<Integer> threadLoca...
ThreadLocal实现原理
tangedegushi的博客
04-11 826
ThreadLocal个人理解是Thread的一个工具类，他为Thread保存这个Thread的全局变量，比如我们有这样一个需求，Thread保存一个变量，但这个变量在这个Thread中的任何地方都可以获取，要实现这样的一个需求，用到的就是ThreadLocal，Android中的Looper就是这样实现的。 ThreadLocal是怎么样实现这样的功能呢？那就让...
jKill#basic-notes#ThreadLocal实现原理1
07-25
通过ThreadLocal对象定位到线程：Thread.currentThread()通过ThreadLocal对象拿到所在的ThreadLocalMap: T
说说ThreadLocal的实现原理
最新发布
qq_62923382的博客
06-25 804
独立性：每个线程拥有自己的 ThreadLocalMap 实例，因此对 ThreadLocal 的操作不会相互干扰。线程安全：由于每个线程有独立的 ThreadLocalMap，不存在并发访问 ThreadLocalMap 的问题，因此操作是线程安全的。这种设计使得 ThreadLocal 非常适合在多线程环境下使用，用于存储线程私有的变量，从而避免了线程间的数据共享问题。
ThreadLocal （本地线程）的实现原理
y_mk的博客
05-06 2819
概述 ThreadLocal 会为每个线程创建一个副本，类似于线程的私有变量，仅限于这些变量互不影响的前提下；但如果传入的是共享变量，取出的还是那个共享变量，多线程并发安全问题还是要通过其他方法去解决。 ThreadLocal 只是提供了保持对象的方法和避免参数的传递，适用 ThreadLocal 的变量应该互相没有依赖关系，常用与：数据库连接、Session管理等 ThreadLocal ...
ThreadLocal底层实现原理
sinat_34814635的博客
03-21 4318
一、基础概念 ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。 1.1 同步机制的比较 对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。 前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。 与volatile关键字的对比 在并发编程中，多个线程访问同一个变量，可能读到另一个线程修改后的值，也可能不是修改后的值。 所.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值