标签：margin sid some number private ima ado hat his
JDK5以前就有了ThreadLocal，又叫线程本地变量，提供了get与set等方法，这些方法为每一个使用该变量的线程都存有一份独立的副本，因此get总是返回由当前执行线程在调用set方法时设置的最新值。
使用方法比较简单，如下。
ThreadLocal<M> threadLocal = new ThreadLocal<>();
threadLocal.set(new M());
threadLocal.get();
threadLocal.remove();
那么问题来了，什么场景下用 ThreadLocal 比较好呢？
ThreadLocal对象通常用于防止对可变的单例变量或全局变量进行共享，这样维持了线程的封闭性，不用再考虑线程安全问题。项目中，通常搭配Spring的AOP来使用，比如之前写的《Redis实现可重入的分布式锁》，使用ThreadLocal来保存锁的拥有者标记。
先看Thread类的代码部分
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
/*
* InheritableThreadLocal values pertaining to this thread. This map is
* maintained by the InheritableThreadLocal class.
*/
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
ThreadLocalMap是Thread的静态内部类，可以看出同一个线程只有持有一个ThreadLocal。但是这里为什么会有两个ThreadLocalMap呢？
通过注释内容可知当我们使用ThreadLocal时用的就是变量threadLocals，inheritableThreadLocals是可继承的ThreadLocal，当我们使用InheritableThreadLocal时，就会使用inheritableThreadLocals来保存父线程的本地变量。详细原理可以查看这篇文章，《ThreadLocal父子线程传递实现方案》。
ThreadLocal的set方法源码如下:
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
这里的代码很容易看懂，就是把ThreadLocal自己当key和传进来的value保存到ThreadLocalMap中，如果map没有初始化就new一个。
ThreadLocal的get方法源码如下:
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
// 重点是这行获取Entry对象
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
private T setInitialValue() {
// 这里直接返回的null
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}
大致逻辑就是先拿到当前线程的ThreadLocalMap，如果map不是null就取entry的值，否则直接返回null。
通过上面可以分析出，ThreadLocal的get、set方法本质上都是对ThreadLocalMap的操作，所以重点看看这个类的实现。
static class ThreadLocalMap {
/**
* 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的N次方
private static final int INITIAL_CAPACITY = 16;
// table数组，它的长度必须一直是2的N次方
private Entry[] table;
// table中实体的数量
private int size = 0;
/**
* The next size value at which to resize.
*/
private int threshold; // Default to 0
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
// 初始化table
table = new Entry[INITIAL_CAPACITY];
// 计算索引，这里用二进制与运算代替 %取模，效率更高
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
setThreshold(INITIAL_CAPACITY);
}
...
}
ThreadLocalMap是一个自定义的hash map，数据其实都保存在table数组中，内部类Entry是一个弱引用可以防止内存溢出。
重点看看这行代码，int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
ThreadLocal.ThreadLocalMap规定了table的大小必须是2的N次幂，这样就可以用位运算代替数学运算，更加高效。
比方说当前table长度是16，那么16-1=15，也就是二进制的1111。现在有一个数字是23，也就是二进制的00010111。23%16=7，&运算的结果也是7。
firstKey.threadLocalHashCode这个hashcode又是如何计算的呢?
private final int threadLocalHashCode = nextHashCode();
/**
* The next hash code to be given out. Updated atomically. Starts at
* zero.
*/
private static AtomicInteger nextHashCode =
new AtomicInteger();
/**
* The difference between successively generated hash codes - turns
* implicit sequential thread-local IDs into near-optimally spread
* multiplicative hash values for power-of-two-sized tables.
*/
private static final int HASH_INCREMENT = 0x61c88647;
/**
* Returns the next hash code.
*/
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
每次计算ThreadLocal的hashcode都会调用nextHashCode（）这个方法，然后利用nextHashCode这个线程安全的原子类来累加0x61c88647，最后得到hashcode。
为什么增量是0x61c88647呢？
0x61c88647是斐波那契散列乘数,它的优点是通过它散列(hash)出来的结果分布会比较均匀，可以很大程度上避免hash冲突，已初始容量16为例，hash并与15位运算计算数组下标结果如下：
现在再分析ThreadLocalMap的set()方法：
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
// 这里就解释了为什么tab.length要是2的N次幂
int i = key.threadLocalHashCode & (len-1);
// 遍历tab
for (Entry e = tab[i];
e != null;
// 给索引+1继续
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
// 判断当前的ThreadLocal和这个位置上的是不是同一个，是的话就覆盖
if (k == key) {
e.value = value;
return;
}
// 如果当前位置是空的，则直接设置
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
//如果上面没有遍历成功则创建新值
tab[i] = new Entry(key, value);
int sz = ++size;
//满足条件数组扩容x2
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
// 将索引的值+1
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}
ThreadLocalMap的getEntry方法：
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 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;
}
总结：
标签：margin sid some number private ima ado hat his
原文地址：https://www.cnblogs.com/2YSP/p/11621111.html
