开场
杭州某商务楼里，正发生着一块儿求职者和面试官的battle。java
面试官：你先自我介绍一下。面试
安琪拉：面试官你好，我是草丛三婊，最强中单（妲己不服），草地摩托车车手，第21套广播体操推广者，火的传人安琪拉，这是个人简历，请过目。算法
面试官：看你简历上写熟悉多线程编程，熟悉到什么程度？编程
安琪拉：精通。后端
对。。。，你没看错，问就是“精通”，把666打在评论区。数组
面试官：服务器
心想 莫不是个憨批，上来就说本身精通，谁把精通挂嘴上，莫不是个愣头青嘞！数据结构
面试官：那咱们开始吧。用过Threadlocal 吧？多线程
安琪拉：用过。并发
面试官：那你跟我讲讲 ThreadLocal 在大家项目中的用法吧。
安琪拉：咱们项目属于保密项目，无可奉告，你仍是换个问题吧！
面试官：那说个不保密的项目，或者你直接告诉我Threadlocal 的实现原理吧。
正题
安琪拉：show time。。。
安琪拉：举个栗子，咱们支付宝每秒钟同时会有不少用户请求，那每一个请求都带有用户信息，咱们知道一般都是一个线程处理一个用户请求，咱们能够把用户信息丢到Threadlocal里面，让每一个线程处理本身的用户信息，线程之间互不干扰。
面试官：等等，问你个私人问题，为何从支付宝跑出来面试，受不了PUA了吗？
安琪拉：PUA我，不存在的，能PUA个人人还没出生呢！公司食堂吃腻了，想换换口味。
面试官：那你来给我讲讲Threadlocal是干什么的？
安琪拉：Threadlocal 主要用来作线程变量的隔离，这么说可能不是很直观。
仍是说前面提到的例子，咱们程序在处理用户请求的时候，一般后端服务器是有一个线程池，来一个请求就交给一个线程来处理，那为了防止多线程并发处理请求的时候发生串数据，好比AB线程分别处理安琪拉和妲己的请求，A线程原本处理安琪拉的请求，结果访问到妲己的数据上了，把妲己支付宝的钱转走了。
因此就能够把安琪拉的数据跟A线程绑定，线程处理完以后解除绑定。
面试官：那把你刚才说的场景用伪代码实现一下，来笔给你！
安琪拉：ok
//存放用户信息的ThreadLocal
private static final ThreadLocal<UserInfo> userInfoThreadLocal = new ThreadLocal<>();
public Response handleRequest(UserInfo userInfo) {
Response response = new Response();
try {
// 1.用户信息set到线程局部变量中
userInfoThreadLocal.set(userInfo);
doHandle();
} finally {
// 3.使用完移除掉
userInfoThreadLocal.remove();
}
return response;
}
//业务逻辑处理
private void doHandle () {
// 2.实际用的时候取出来
UserInfo userInfo = userInfoThreadLocal.get();
//查询用户资产
queryUserAsset(userInfo);
}
1.2.3 步骤很清楚了。
面试官：那你跟我说说Threadlocal 怎么实现线程变量的隔离的？
安琪拉：Oh, 这么快进入正题，我先给你画个图，以下
面试官：图我看了，那你对着前面你写的代码讲一下对应图中流程。
安琪拉：没问题
- 首先咱们经过ThreadLocal<UserInfo> userInfoThreadLocal = new ThreadLocal() 初始化了一个Threadlocal 对象，就是上图中说的Threadlocal 引用，这个引用指向堆中的ThreadLocal 对象；
- 而后咱们调用userInfoThreadLocal.set(userInfo); 这里作了什么事呢？
咱们把源代码拿出来，看一看就清晰了。
咱们知道 Thread 类有个 ThreadLocalMap 成员变量，这个Map key是Threadlocal 对象，value是你要存放的线程局部变量。
这里是在当前线程对象的ThreadlocalMap中put了一个元素(Entry)，key是Threadlocal对象，value是userInfo。
理解二件事就都清楚了：
ThreadLocalMap 类的定义在 Threadlocal中。
- 第一，Thread 对象是Java语言中线程运行的载体，每一个线程都有对应的Thread 对象，存放线程相关的一些信息，
- 第二，Thread类中有个成员变量ThreadlocalMap，你就把他当成普通的Map，key存放的是Threadlocal对象，value是你要跟线程绑定的值（线程隔离的变量），好比这里是用户信息对象（UserInfo）。
面试官：你刚才说Thread 类有个 ThreadlocalMap 属性的成员变量，可是ThreadlocalMap 的定义却在Threadlocal 中，为何这么作？
安琪拉：咱们看下ThreadlocalMap的说明
class ThreadLocalMap * 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.
大概意思是ThreadLocalMap 就是为维护线程本地变量而设计的，只作这一件事情。
这个也是为何 ThreadLocalMap 是Thread的成员变量，可是倒是Threadlocal 的内部类（非public，只有包访问权限，Thread和Threadlocal都在java.lang 包下），就是让使用者知道ThreadLocalMap就只作保存线程局部变量这一件事的。
面试官：既然是线程局部变量，那为何不用线程对象（Thread对象）做为key，这样不是更清晰，直接用线程做为key获取线程变量？
安琪拉：这样设计会有个问题，好比: 我已经把用户信息存在线程变量里了，这个时候须要新增长一个线程变量，比方说新增用户地理位置信息，咱们ThreadlocalMap 的key用的是线程，再存一个地理位置信息，key都是同一个线程（key同样），不就把原来的用户信息覆盖了嘛。Map.put(key,value) 操做熟悉吧，因此网上有些文章说ThreadlocalMap使用线程做为key是瞎扯的。
面试官：那新增地理位置信息应该怎么作？
安琪拉：新建立一个Threadlocal对象就行了，由于ThreadLocalMap的key是Threadlocal 对象，好比新增地理位置，我就再 Threadlocal < Geo> geo = new Threadlocal（）, 存放地理位置信息，这样线程的ThreadlocalMap里面会有二个元素，一个是用户信息，一个是地理位置。
面试官：ThreadlocalMap 是什么数据结构实现的？
安琪拉：跟HashMap 同样，也是数组实现的。
代码以下：
class ThreadLocalMap {
//初始容量
private static final int INITIAL_CAPACITY = 16;
//存放元素的数组
private Entry[] table;
//元素个数
private int size = 0;
}
table 就是存储线程局部变量的数组，数组元素是Entry类，Entry由key和value组成，key是Threadlocal对象，value是存放的对应线程变量
咱们前面举得例子，数组存储结构以下图:
面试官：ThreadlocalMap 发生hash冲突怎么办？跟HashMap 有什么区别？
安琪拉：【心想】第一次碰到有问ThreadlocalMap哈希冲突的，这个面试愈来愈有意思了。
说道：有区别的，对待哈希冲突，HashMap采用的链表 + 红黑树的形式，以下图，链表长度过长(>8) 就会转成红黑树:
HashMap详解：
参考 安琪拉，公众号：安琪拉的博客一个HashMap跟面试官扯了半个小时
ThreadlocalMap既没有链表，也没有红黑树，采用的是开放定址法 ，是这样，是若是发生冲突，ThreadlocalMap直接日后找相邻的下一个节点，若是相邻节点为空，直接存进去，若是不为空，继续日后找，直到找到空的，把元素放进去，或者元素个数超过数组长度阈值，进行扩容。
以下图：仍是以以前的例子讲解，ThreadlocalMap 数组长度是4，如今存地理位置的时候发生hash冲突（位置1已经有数据），那就把日后找，发现2 这个位置为空，就直接存放在2这个位置。
源代码（若是阅读起来困难，能够看完后文回过头来阅读）:
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
// hashcode & 操做其实就是 %数组长度取余数，例如：数组长度是4，hashCode % (4-1) 就找到要存放元素的数组下标
int i = key.threadLocalHashCode & (len-1);
//找到数组的空槽（=null），通常ThreadlocalMap存放元素不会不少
for (Entry e = tab[i];
e != null; //找到数组的空槽（=null）
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
//若是key值同样，算是更新操做，直接替换
if (k == key) {
e.value = value;
return;
}
//key为空，作替换清理动做，这个后面聊WeakReference的时候讲
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
//新new一个Entry
tab[i] = new Entry(key, value);
//数组元素个数+1
int sz = ++size;
//若是没清理掉元素或者存放元素个数超过数组阈值，进行扩容
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
//顺序遍历 +1 到了数组尾部，又回到数组头部（0这个位置）
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}
// get()方法，根据ThreadLocal key获取线程变量
private Entry getEntry(ThreadLocal<?> key) {
//计算hash值 & 操做其实就是 %数组长度取余数，例如：数组长度是4，hashCode % (4-1) 就找到要查询的数组地址
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
//快速判断 若是这个位置有值，key相等表示找到了，直接返回
if (e != null && e.get() == key)
return e;
else
return getEntryAfterMiss(key, i, e); //miss以后顺序日后找（链地址法，这个后面再介绍）
}
面试官：我看你最前面图中画的ThreadlocalMap 中key是 WeakReference类型，能讲讲Java中有几种相似的引用，什么区别吗？
安琪拉：能够
- 强引用是使用最广泛的引用。若是一个对象具备强引用，那垃圾回收器毫不会回收它，当内存空间不足时，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具备强引用的对象来解决内存不足的问题。
- 若是一个对象只具备软引用，则内存空间充足时，垃圾回收器就不会回收它；若是内存空间不足了，就会回收这些对象的内存。
- 弱引用与软引用的区别在于：只具备弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描内存区域时，一旦发现了只具备弱引用的对象，无论当前内存空间足够与否，都会回收它的内存。不过，因为垃圾回收器是一个优先级很低的线程，所以不必定会很快发现那些只具备弱引用的对象。
- 虚引用顾名思义，就是形同虚设。与其余几种引用都不一样，虚引用并不会决定对象的生命周期。若是一个对象仅持有虚引用，那么它就和没有任何引用同样，在任什么时候候均可能被垃圾回收器回收。
妥妥的八股文啊！尴尬(─.─|||。
面试官：那你能讲讲为何ThreadlocalMap 中key 设计成 WeakReference（弱引用）类型吗？
安琪拉：能够的，为了尽最大努力避免内存泄漏。
面试官：能详细讲讲吗？为何是尽最大努力，你前面也讲被WeakReference 引用的对象会直接被GC（内存回收器） 回收，为何不是直接避免了内存泄漏呢？
安琪拉：咱们仍是看下下面这张图
private static final ThreadLocal<UserInfo> userInfoThreadLocal = new ThreadLocal<>(); userInfoThreadLocal.set(userInfo);
这里的引用关系是userInfoThreadLocal 引用了ThreadLocal对象，这是个强引用，ThreadLocal对象同时也被ThreadlocalMap的key引用，这是个WeakReference引用，咱们前面说GC要回收ThreadLocal对象的前提是它只被WeakReference引用，没有任何强引用。
为了方便你们理解弱引用，我写了段Demo程序
public static void main(String[] args) {
Object angela = new Object();
//弱引用
WeakReference<Object> weakReference = new WeakReference<>(angela);
//angela和弱引用指向同一个对象
System.out.println(angela);//java.lang.Object@4550017c
System.out.println(weakReference.get());//java.lang.Object@4550017c
//将强引用angela置为null，这个对象就只剩下弱引用了,内存够用，弱引用也会被回收
angela = null;
System.gc();//内存够用不会自动gc，手动唤醒gc
System.out.println(angela);//null
System.out.println(weakReference.get());//null
}
能够看到一旦一个对象只被弱引用引用，GC的时候就会回收这个对象。
因此只要ThreadLocal对象若是还被 userInfoThreadLocal（强引用） 引用着，GC是不会回收被WeakReference引用的对象的。
面试官：那既然ThreadLocal对象有强引用，回收不掉，干吗还要设计成WeakReference类型呢？
安琪拉：ThreadLocal的设计者考虑到线程每每生命周期很长，好比常常会用到线程池，线程一直存活着，根据JVM 根搜索算法，一直存在 Thread -> ThreadLocalMap -> Entry（元素）这样一条引用链路, 以下图，若是key不设计成WeakReference类型，是强引用的话，就一直不会被GC回收，key就一直不会是null，不为null Entry元素就不会被清理（ThreadLocalMap是根据key是否为null来判断是否清理Entry）
因此ThreadLocal的设计者认为只要ThreadLocal 所在的做用域结束了工做被清理了，GC回收的时候就会把key引用对象回收，key置为null，ThreadLocal会尽力保证Entry清理掉来最大可能避免内存泄漏。
来看下代码
//元素类
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value; //key是从父类继承的，因此这里只有value
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
//WeakReference 继承了Reference，key是继承了范型的referent
public abstract class Reference<T> {
//这个就是被继承的key
private T referent;
Reference(T referent) {
this(referent, null);
}
}
Entry 继承了WeakReference类，Entry 中的 key 是WeakReference类型的，在Java 中当对象只被 WeakReference 引用，没有其余对象引用时，被WeakReference 引用的对象发生GC 时会直接被回收掉。
面试官：那若是Threadlocal 对象一直有强引用，那怎么办？岂不是有内存泄漏风险。
安琪拉：最佳实践是用完手动调用remove函数。
咱们看下源码：
class Threadlocal {
public void remove() {
//这个是拿到线程的ThreadLocalMap
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this); //this就是ThreadLocal对象，移除，方法在下面
}
}
class ThreadlocalMap {
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 int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
//把staleSlot的value置为空，而后数组元素置为空
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--; //元素个数-1
// Rehash until we encounter null
Entry e;
int i;
for (i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
//k 为null表明引用对象被GC回收掉了
if (k == null) {
e.value = null;
tab[i] = null;
size--;
} else {
//由于元素个数减小了，就把后面的元素从新hash
int h = k.threadLocalHashCode & (len - 1);
//hash地址不相等，就表明这个元素以前发生过hash冲突(原本应该放在这没放在这)，
//如今由于有元素被移除了，颇有可能原来冲突的位置空出来了，重试一次
if (h != i) {
tab[i] = null;
//继续采用链地址法存放元素
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}
面试官：你有没有用Threadlocal的工程实际经历，给我讲讲。
安琪拉：有啊！
以前我跟大家一面面试官聊过，我是怎么把支付宝后台负责的系统四十几个核心rpc接口性能大幅度提高的，下面这个就是其中一个接口切流以后的效果，其中就用到了Threadlocal。
面试官：嗯，说说。
安琪拉：我刚才说有四十多个接口要作技改优化，那风险是很高的，我须要保证接口切换后业务不受影响，也叫等效切换。
流程是这样的：
- 把这四十多个接口按照业务含义定义了接口常量名称，好比接口名alipay.quickquick.follow.angela；
- 按照接口的流量从低到高开始切流，提早配置中心配置好每一个接口的切流比例和用户白名单；
- 切流也有讲究，先按照userId白名单切，再按照userId尾号切百分比，彻底没问题再完整切；
- 在顶层抽象模版方法的入口经过ThreadLocal Set 接口名，把接口名塞进去；
- 而后我在切流的地方经过ThreadLocal 获取接口名，用于接口切流判断切流；
面试官：最后一个问题，若是我有不少变量都要塞到ThreadlocalMap中，那岂不是要申明不少个Threadlocal 对象？有没有好的解决办法。
安琪拉：咱们的最佳实践是搞个再封装一下，把ThreadLocalMap 的value 弄成Map就行了，这样只要一个Threadlocal 对象就行了。
面试官：能详细讲讲吗？
安琪拉：讲不动了，太累了。
面试官：讲讲。
安琪拉：真不想讲了。
面试官：那今天先到这，您出了这个门右拐，回去等通知吧！