Android 开发也要掌握的Java知识 -ThreadLocal

m0_70083062

于 2022-05-08 08:58:19 发布

阅读量144

点赞数

分类专栏： Android 文章标签：经验分享面试 android

本文链接：https://blog.csdn.net/m0_70083062/article/details/124643340

版权

Android 专栏收录该内容

92 篇文章 6 订阅

订阅专栏

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(ThreadL 《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》无偿开源徽信搜索公众号【编程进阶路】 ocal<?> 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();
}

/**

Double the capacity of the table.
*/
private void resize() {
Entry[] oldTab = table;
int oldLen = oldTab.length;
//扩容为原来的2倍
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;
}