Java并发：ThreadLocal详解

2401_84010165

于 2024-04-02 11:05:13 发布

阅读量1k

点赞数 22

分类专栏：程序员文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/2401_84010165/article/details/137263021

版权

程序员专栏收录该内容

246 篇文章 3 订阅

订阅专栏

/**

demo
@author joonwhee
@date 2018年2月24日

public class ThreadLocalDemo {

public static ThreadLocal threadLocal = new ThreadLocal();

public static ThreadLocal threadLocalUser = new ThreadLocal();

public static void main(String args[]) {

threadLocal.set(100); // 保存值

System.out.println(threadLocal.get()); // 获取值

User user = new User();

user.setName(“JoonWhee”);

user.setAge(25);

threadLocalUser.set(user); // 保存值

System.out.println(threadLocalUser.get()); // 获取值

}

static class User{

String name;

Integer age;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public Integer getAge() {

return age;

}

public void setAge(Integer age) {

this.age = age;

}

@Override

public String toString() {

return “User [name=” + name + “, age=” + age + “]”;

}

输出结果：

100

User [name=JoonWhee, age=25]

2.ThreadLocal的定义

====================

这个类提供了线程局部变量。这个类能使线程中的某个值与保存值的对象关联起来，例如：“threadLocal.set(5)”，会将“threadLocal”和“5”作为键值对保存在该线程的threadLocals里。ThreadLocal提供了get与set等访问接口或方法，这些方法为每个使用该变量的线程都存有一份独立的副本（即每个线程的threadLocals属性），因此get总是返回由当前执行线程在调用set时设置的最新值。

只要线程处于活动状态并且Threadocal实例可以访问，每个线程就拥有对其线程局部变量副本的隐式引用；在一个线程消失之后，线程本地实例的所有副本都会被垃圾收集（除非存在对这些副本的其他引用）。

// hash code

private final int threadLocalHashCode = nextHashCode();

// AtomicInteger类型，从0开始

private static AtomicInteger nextHashCode =

new AtomicInteger();

// hash code每次增加1640531527

private static final int HASH_INCREMENT = 0x61c88647;

// 下一个hash code

private static int nextHashCode() {

return nextHashCode.getAndAdd(HASH_INCREMENT);

}

从上面的定义可以知道，ThreadLocal的hashcode（threadLocalHashCode）是从0开始，每新建一个ThreadLocal，对应的hashcode就加0x61c88647。

3.ThreadLocalMap的定义

===================

static class Entry extends WeakReference<ThreadLocal<?>> {

/** The value associated with this ThreadLocal. */

Object value;

Entry(ThreadLocal<?> k, Object v) {

super(k);

value = v;

}

ThreadLocalMap是一个自定义哈希映射，仅用于维护线程本地变量值。ThreadLocalMap是ThreadLocal的内部类，主要有一个Entry数组，Entry的key为ThreadLocal，value为ThreadLocal对应的值。每个线程都有一个ThreadLocalMap类型的threadLocals变量。

4.set()方法

=========

public void set(T value) {

Thread t = Thread.currentThread();

ThreadLocalMap map = getMap(t); // 获取当前线程的ThreadLocalMap

// 当前线程的ThreadLocalMap不为空则调用set方法, this为调用该方法的ThreadLocal对象

if (map != null)

map.set(this, value);

// map为空则调用createMap方法创建一个新的ThreadLocalMap, 并新建一个Entry放入该

// ThreadLocalMap, 调用set方法的ThreadLocal和传入的value作为该Entry的key和value

else

createMap(t, value);

}

ThreadLocalMap getMap(Thread t) {

return t.threadLocals; // 返回线程t的threadLocals属性

}

先拿到当前线程，再使用getMap方法拿到当前线程的threadLocals变量
如果threadLocals不为空，则将当前ThreadLocal作为key，传入的值作为value，调用set方法（见下文代码块1详解）插入threadLocals。
如果threadLocals为空则调用创建一个ThreadLocalMap，并新建一个Entry放入该ThreadLocalMap, 调用set方法的ThreadLocal和传入的value作为该Entry的key和value

注意此处的threadLocals变量是一个ThreadLocalMap，是Thread的一个局部变量，因此它只与当前线程绑定。

代码块1：set方法

private void set(ThreadLocal<?> key, Object value) {

Entry[] tab = table;

int len = tab.length;

int i = key.threadLocalHashCode & (len-1); // 计算出索引的位置

// 从索引位置开始遍历,由于不是链表结构,因此通过nextIndex方法来寻找下一个索引位置

for (Entry e = tab[i];

e != null; // 当遍历到的Entry为空时结束遍历

e = tab[i = nextIndex(i, len)]) {

ThreadLocal<?> k = e.get(); // 拿到Entry的key，也就是ThreadLocal

// 该Entry的key和传入的key相等, 则用传入的value替换掉原来的value

if (k == key) {

e.value = value;

return;

}

// 该Entry的key为空, 则代表该Entry需要被清空,

// 调用replaceStaleEntry方法

if (k == null) {

// 该方法会继续寻找传入key的安放位置, 并清理掉key为空的Entry

replaceStaleEntry(key, value, i);

return;

}

// 寻找到一个空位置,　则放置在该位置上

tab[i] = new Entry(key, value);

int sz = ++size;

// cleanSomeSlots是用来清理掉key为空的Entry,如果此方法返回true,则代表至少清理

// 了1个元素, 则此次set必然不需要扩容, 如果此方法返回false则判断sz是否大于阈值

if (!cleanSomeSlots(i, sz) && sz >= threshold)

rehash(); // 扩容

}

通过传入的key的hashCode计算出索引的位置
从索引位置开始遍历，由于不是链表结构，因此通过nextIndex方法来寻找下一个索引位置
如果找到某个Entry的key和传入的key相同，则用传入的value替换掉该Entry的value。
如果遍历到某个Entry的key为空，则调用replaceStaleEntry方法（见下文代码块2详解）
如果通过nextIndex寻找到一个空位置（代表没有找到key相同的），则将元素放在该位置上
调用cleanSomeSlots方法清理key为null的Entry，并判断是否需要扩容，如果需要则调用rehash方法进行扩容（见下文rehash方法详解）。

代码块2：replaceStaleEntry方法

private void replaceStaleEntry(ThreadLocal<?> key, Object value,

int staleSlot) {

Entry[] tab = table;

int len = tab.length;

Entry e;

int slotToExpunge = staleSlot; // 清除元素的开始位置（记录索引位置最前面的）

// 向前遍历，直到遇到Entry为空

for (int i = prevIndex(staleSlot, len);

(e = tab[i]) != null;

i = prevIndex(i, len))

if (e.get() == null)

slotToExpunge = i; // 记录最后一个key为null的索引位置

// Find either the key or trailing null slot of run, whichever

// occurs first

for (int i = nextIndex(staleSlot, len); // 向后遍历，直到遇到Entry为空

(e = tab[i]) != null;

i = nextIndex(i, len)) {

ThreadLocal<?> k = e.get();

// 该Entry的key和传入的key相等, 则将传入的value替换掉该Entry的value

if (k == key) {

e.value = value;

// 将i位置和staleSlot位置的元素对换（staleSlot位置较前，是要清除的元素）

tab[i] = tab[staleSlot];

tab[staleSlot] = e;

// 如果相等, 则代表上面的向前寻找key为null的遍历没有找到，

// 即staleSlot位置前面的元素没有需要清除的，此时将slotToExpunge设置为i,

// 因为原staleSlot的元素已经被放到i位置了，这时位置i前面的元素都不需要清除

if (slotToExpunge == staleSlot)

slotToExpunge = i;

// 从slotToExpunge位置开始清除key为空的Entry

cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);

return;

}

// 如果第一次遍历到key为null的元素，并且上面的向前寻找key为null的遍历没有找到，

// 则将slotToExpunge设置为当前的位置

if (k == null && slotToExpunge == staleSlot)

slotToExpunge = i;

}

// 如果key没有找到，则新建一个Entry，放在staleSlot位置

tab[staleSlot].value = null;

tab[staleSlot] = new Entry(key, value);

// 如果slotToExpunge!=staleSlot，代表除了staleSlot位置还有其他位置的元素需要清除

// 需要清除的定义：key为null的Entry，调用cleanSomeSlots方法清除key为null的Entry

if (slotToExpunge != staleSlot)

cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);

}

slotToExpunge始终记录着需要清除的元素的最前面的位置（即slotToExpunge前面的元素是不需要清除的）
从位置staleSlot向前遍历，直到遇到Entry为空，用staleSlot记录最后一个key为null的索引位置（也就是遍历过位置最前的key为null的位置）
从位置staleSlot向后遍历，直到遇到Entry为空，如果遍历到key和入参key相同的，则将入参的value替换掉该Entry的value，并将i位置和staleSlot位置的元素对换（staleSlot位置较前，是要清除的元素），遍历的时候判断slotToExpunge的值是否需要调整，最后调用expungeStaleEntry方法（见下文expungeStaleEntry方法详解）和cleanSomeSlots方法（见下文代码块3详解）清除key为null的元素。
如果key没有找到，则使用入参的key和value新建一个Entry，放在staleSlot位置
判断是否还有其他位置的元素key为null，如果有则调用expungeStaleEntry方法和cleanSomeSlots方法清除key为null的元素

代码块3：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) { // 遍历到key为null的元素

n = len; // 重置n的值

removed = true; // 标志有移除元素

i = expungeStaleEntry(i); // 移除i位置及之后的key为null的元素

}

} while ( (n >>>= 1) != 0);

return removed;

}

从 i 开始，清除key为空的Entry，遍历次数由当前的table长度决定，当遍历到一个key为null的元素时，调用expungeStaleEntry清除，并将遍历次数重置。至于为什么使用table长度来决定遍历次数，官方给出的解释是这个方法简单、快速，并且效果不错。

5.get()方法

=============

public T get() {

Thread t = Thread.currentThread();

ThreadLocalMap map = getMap(t);

if (map != null) {

// 调用getEntry方法, 通过this（调用get()方法的ThreadLocal）获取对应的Entry

ThreadLocalMap.Entry e = map.getEntry(this);

// Entry不为空则代表找到目标Entry, 返回该Entry的value值

if (e != null) {

@SuppressWarnings(“unchecked”)

T result = (T)e.value;

return result;

}

// 该线程的ThreadLocalMap为空，或者没有找到目标Entry，则调用setInitialValue方法

return setInitialValue();

}

跟set方法差不多，先拿到当前的线程，再使用getMap方法拿到当前线程的threadLocals变量
如果threadLocals不为空，则将调用get方法的ThreadLocal作为key，调用getEntry方法（见下文代码块5详解）找到对应的Entry。
如果threadLocals为空或者找不到目标Entry，则调用setInitialValue方法（见下文代码块4详解）进行初始化。

代码块4：setInitialValue方法

private T setInitialValue() {

T value = initialValue(); // 默认null，需要用户自己重写该方法，

Thread t = Thread.currentThread(); // 当前线程

ThreadLocalMap map = getMap(t); // 拿到当前线程的threadLocals

// threadLocals不为空则将当前的ThreadLocal作为key，null作为value，插入到ThreadLocalMap

if (map != null)

map.set(this, value);

// threadLocals为空则调用创建一个ThreadLocalMap，并新建一个Entry放入该ThreadLocalMap,

// 调用set方法的ThreadLocal和value作为该Entry的key和value

else

createMap(t, value);

return value;

}

如果是threadLocals为空，创建一个新的ThreadLocalMap，并将当前的ThreadLocal作为key，null作为value，插入到新创建的ThreadLocalMap，并返回null。
如果threadLocals不为空，则将当前的ThreadLocal作为key，null作为value，插入到threadLocals。
注意上面的 initialValue()方法为protected，如果希望线程局部变量具有非null的初始值，则必须对ThreadLocal进行子类化，并重写此方法。

代码块5：getEntry方法

private Entry getEntry(ThreadLocal<?> key) {

//根据hash code计算出索引位置

int i = key.threadLocalHashCode & (table.length - 1);

Entry e = table[i];

// 如果该Entry的key和传入的key相等, 则为目标Entry, 直接返回

if (e != null && e.get() == key)

return e;

// 否则，e不是目标Entry, 则从e之后继续寻找目标Entry

else

return getEntryAfterMiss(key, i, e);

}