【并发】ThreadLocalMap 的结构
ThreadLocalMap 是 ThreadLocal 类的一个静态内部类，用于存储每个线程的局部变量。与通常的 Map 不同，ThreadLocalMap 是专门为 ThreadLocal 设计的，并且具有一些特殊的设计和实现细节。以下是对 ThreadLocalMap 结构和工作原理的详细说明。
ThreadLocalMap 结构
ThreadLocalMap 是一个定制的哈希表，它的主要特点包括：
- Entry 类：
ThreadLocalMap使用一个自定义的Entry类来存储键值对。 - 弱引用键：
Entry类的键是ThreadLocal的弱引用，这样可以防止ThreadLocal实例被垃圾回收时造成内存泄漏。 - 线性探测：在发生哈希冲突时，使用线性探测法来寻找下一个空闲槽位。
ThreadLocalMap 的关键实现
以下是 ThreadLocalMap 的关键代码片段：
public class ThreadLocal<T> {
// 其他 ThreadLocal 的实现代码...
// 内部类 ThreadLocalMap
static class ThreadLocalMap {
// 定义 Entry 类，继承自 WeakReference
static class Entry extends WeakReference<ThreadLocal<?>> {
// 保存实际的值
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
// 存储 Entry 的数组
private Entry[] table;
private int size = 0;
private int threshold;
// 初始容量
private static final int INITIAL_CAPACITY = 16;
// 构造函数
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
table = new Entry[INITIAL_CAPACITY];
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
setThreshold(INITIAL_CAPACITY);
}
// 获取 Entry
private Entry getEntry(ThreadLocal<?> key) {
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
if (e != null && e.get() == key)
return e;
else
return getEntryAfterMiss(key, i, e);
}
// 设置值
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();
if (k == key) {
e.value = value;
return;
}
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
// 移除 Entry
private void remove(ThreadLocal<?> key) {
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)]) {
if (e.get() == key) {
e.clear();
expungeStaleEntry(i);
return;
}
}
}
// 其他方法...
private void setThreshold(int len) {
threshold = len * 2 / 3;
}
private int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
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 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);
(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) {
e.value = value;
tab[i] = tab[staleSlot];
tab[staleSlot] = e;
if (slotToExpunge == staleSlot)
slotToExpunge = i;
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
return;
}
if (k == null && slotToExpunge == staleSlot)
slotToExpunge = i;
}
tab[staleSlot].value = null;
tab[staleSlot] = new Entry(key, value);
if (slotToExpunge != staleSlot)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}
private int prevIndex(int i, int len) {
return ((i - 1 >= 0) ? i - 1 : len - 1);
}
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
Entry e;
int i;
for (i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
if (k == null) {
e.value = null;
tab[i] = null;
size--;
} else {
int h = k.threadLocalHashCode & (len - 1);
if (h != i) {
tab[i] = null;
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}
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) {
n = len;
removed = true;
i = expungeStaleEntry(i);
}
} while ((n >>>= 1) != 0);
return removed;
}
private void rehash() {
expungeStaleEntries();
if (size >= threshold - threshold / 4)
resize();
}
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)
expungeStaleEntry(j);
}
}
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;
} 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;
}
}
}
关键点解析
-
Entry 类：
Entry类继承自WeakReference<ThreadLocal<?>>，用于存储ThreadLocal的键。- 这种设计允许键（
ThreadLocal实例）在没有强引用时被垃圾回收，从而避免内存泄漏。
-
线性探测：
ThreadLocalMap使用线性探测法来解决哈希冲突。这意味着如果哈希冲突发生，它将查找下一个空闲槽位。- 线性探测的实现通过
nextIndex和prevIndex方法完成。
-
内存清理：
- 使用
expungeStaleEntry方法来处理键为null的条目，并清理过时的条目。 cleanSomeSlots方法定期清理槽位，防止内存占用过大。
- 使用
-
哈希重排：
- 当
ThreadLocalMap的负载因子达到一定阈值时，它会进行哈希重排。重排操作将旧的条目移动到新的、更大的表中，从而减少冲突和提升性能。
- 当
-
线程本地存储：
- 每个线程拥有自己的
ThreadLocalMap，确保每个线程的ThreadLocal实例是隔离的，不会互相干扰。
- 每个线程拥有自己的
总结
ThreadLocalMap 是 ThreadLocal 的关键数据结构，用于在每个线程中存储线程局部变量。它的设计考虑了线程安全、内存管理以及性能优化等方面，通过使用弱引用来处理键，并采用线性探测法和定期清理机制来管理内存和处理哈希冲突。正确地使用和管理 ThreadLocal 可以有效地避免内存泄漏和性能问题。
原文地址：https://blog.csdn.net/hui_zai_/article/details/140724597
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！