2024年Android 开发也要掌握的Java知识 -ThreadLocal，Java高级-CSDN博客

本文链接：https://blog.csdn.net/2401_84102653/article/details/138485988

最后

权威指南-第一本Docker书

引领完成Docker的安装、部署、管理和扩展，让其经历从测试到生产的整个开发生命周期，深入了解Docker适用于什么场景。并且这本Docker的学习权威指南介绍了其组件的基础知识，然后用Docker构建容器和服务来完成各种任务：利用Docker为新项目建立测试环境，演示如何使用持续集成的工作流集成Docker，如何构建应用程序服务和平台，如何使用Docker的API，如何扩展Docker。

总共包含了：简介、安装Docker、Docker入门、使用Docker镜像和仓库、在测试中使用Docker、使用Docker构建服务、使用Fig编配Docke、使用Docker API、获得帮助和对Docker进行改进等9个章节的知识。

关于阿里内部都在强烈推荐使用的“K8S+Docker学习指南”—《深入浅出Kubernetes：理论+实战》、《权威指南-第一本Docker书》，看完之后两个字形容，爱了爱了！

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

*/
public ThreadLocal() {
}

2.2 ThreadLocalMap类

2.2.1 Entry

源码可以看到Entry这个类是弱引用的类型。
key放ThreadLocal，value放存放的内容。

/**

The entries in this hash map extend WeakReference, using
its main ref field as the key (which is always a
ThreadLocal object). Note that null keys (i.e. entry.get()
== null) mean that the key is no longer referenced, so the
entry can be expunged from table. Such entries are referred to
as “stale entries” in the code that follows.
/
static class Entry extends WeakReference<ThreadLocal<?>> {
/* The value associated with this ThreadLocal. */
Object value;

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

2.2.2 构造方法

创建一个长度为16的Entry数组，然后存放的位置用hashcode和15做与运算得到，再保存内容。

/**

ThreadLocalMap is a customized hash map suitable only for
maintaining thread local values. No operations are exported
outside of the ThreadLocal class. The class is package private to
allow declaration of fields in class Thread. To help deal with
very large and long-lived usages, the hash table entries use
WeakReferences for keys. However, since reference queues are not
used, stale entries are guaranteed to be removed only when
the table starts running out of space.
*/
static class ThreadLocalMap {

/**

The initial capacity – MUST be a power of two.
*/
private static final int INITIAL_CAPACITY = 16;

/**

The table, resized as necessary.
table.length MUST always be a power of two.
*/
private Entry[] table;

/**

The number of entries in the table.
*/
private int size = 0;

/**

Construct a new map initially containing (firstKey, firstValue).
ThreadLocalMaps are constructed lazily, so we only create
one when we have at least one entry to put in it.
*/
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);
}
.
.
}

2.2.3 set(ThreadLocal<?> key, Object value)

如果计算的位置已经有内容了，就覆盖，否则就新建一个Entry存放，再判断是否达到阈值，不够就扩容。

/**

Set the value associated with key.
@param key the thread local object
@param value the value to be set
*/
private void set(ThreadLocal<?> key, Object value) {

// 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.

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();
}

2.2.4 setInitialValue()

初始化空Entry，因为有的线程ThreadLocal一开始没有存东西，但调用了get方法，这时候没内容，但还是先占个坑，返回null。

/**

Returns the current thread’s “initial value” for this
thread-local variable. This method will be invoked the first
time a thread accesses the variable with the {@link #get}
method, unless the thread previously invoked the {@link #set}
method, in which case the {@code initialValue} method will not
be invoked for the thread. Normally, this method is invoked at
most once per thread, but it may be invoked again in case of
subsequent invocations of {@link #remove} followed by {@link #get}.
This implementation simply returns {@code null}; if the
programmer desires thread-local variables to have an initial
value other than {@code null}, {@code ThreadLocal} must be
subclassed, and this method overridden. Typically, an
anonymous inner class will be used.
@return the initial value for this thread-local
*/
protected T initialValue() {
return null;
}

/**

Variant of set() to establish initialValue. Used instead
of set() in case user has overridden the set() method.
@return the initial value
*/
private T setInitialValue() {
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}

2.2.5 getEntry(ThreadLocal<?> key)

利用hashcode找到对应的Entry，如果一次命中找到最好，但扩容过可能不可以一次命中，就要执行 getEntryAfterMiss 方法找。

/**

Get the entry associated with key. This method
itself handles only the fast path: a direct hit of existing
key. It otherwise relays to getEntryAfterMiss. This is
designed to maximize performance for direct hits, in part
by making this method readily inlinable.
@param key the thread local object
@return the entry associated with key, or null if no such
*/
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);
}

/**

Version of getEntry method for use when key is not found in
its direct hash slot.
@param key the thread local object
@param i the table index for key’s hash code
@param e the entry at table[i]
@return the entry associated with key, or null if no such
*/
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;
}

2.2.6 整理扩容

阈值threshold，为数组容量的2/3。
当满足条件if (!cleanSomeSlots(i, sz) && sz >= threshold)，就是没有删除过，且容量使用了2/3时，先执行**rehash()**就会整理或者扩容。
整理完成，如果满足 if (size >= threshold - threshold / 4) 就会触发扩容，扩容2倍。

/**

Set the resize threshold to maintain at worst a 2/3 load factor.
*/
private void setThreshold(int len) {
//数组长度的2/3
threshold = len * 2 / 3;
}

/**

Re-pack and/or re-size the table. First scan the entire
table removing stale entries. If this doesn’t sufficiently
shrink the size of the table, double the table size.
*/
private void rehash() {
//整理
expungeStaleEntries();

// Use lower threshold for doubling to avoid hysteresis
if (size >= threshold - threshold / 4)
resize();
}

/**