1.ThreadLocal的相关面试题
1）Java中的引用类型有哪几种？
2）每种引用类型的特点？
3）每种引用类型的场景是什么？
4）ThreadLocal你了解吗？
5）ThreadLocal应用在什么地方？
6）Thread会产生内存泄漏吗？
在学习ThreadLocal之前，先了解一下java中的四种引用，大厂面试的时候，面试官一般都是先问四种引用，然后过渡到ThreadLocal。
2.Java中的引用类型
从Java SE2开始，就提供了四种类型的引用：强引用、软引用、弱引用和虚引用。Java中提供这四种引用类型主要有两个目的：第一是可以让程序员通过代码的方式决定某些对象的生命周期；第二是有利于JVM进行垃圾回收。
1）强引用：使用最普遍的引用，比如下面的这段代码中的o和str都是强引用
Object o = new Object();
String str = "hello world";
如果一个对象具有强引用，那么它永远不会被 GC,当内存空间不足时，JVM 宁愿抛出OutOfMemoryError(OOM)，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题。如果想中断强引用和某个对象之间的关联，可以显示地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象。
2）软引用（SoftReference）：软引用是用来描述一些有用但并不是必需的对象，在Java中用java.lang.ref.SoftReference类来表示。如果一个对象只具有软引用(Soft Reference)，当内存空间充足时，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。因此，这一点可以很好地用来解决OOM的问题，并且这个特性很适合用来实现缓存：比如网页缓存、图片缓存等。
mport java.lang.ref.SoftReference;
public class Main {
public static void main(String[] args) {
SoftReference<String> sr = new SoftReference<String>(new String("hello"));
System.out.println(sr.get());
}
}
3）弱引用（WeakReference）：弱引用也是用来描述非必需对象的，如果一个对象只具有弱引用(Weak Reference)，其生命周期相比于软引用更加短暂。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会对它进行回收。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。在java中，用java.lang.ref.WeakReference类来表示。ThreadLocal中就是用的弱引用，具体怎么用的，下面会讲。
import java.lang.ref.WeakReference;
public class Main {
public static void main(String[] args) {
WeakReference<String> sr = new WeakReference<String>(new String("hello"));
System.out.println(sr.get());//hello
System.gc(); //通知JVM的gc进行垃圾回收
System.out.println(sr.get()); //null
}
}
4）虚引用（PhantomReference）：虚引用和前面的软引用、弱引用不同，它并不影响对象的生命周期。在java中用java.lang.ref.PhantomReference类表示。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收,永远拿不到虚引用指向的对象。
要注意的是，虚引用必须和引用队列关联使用，当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会把这个虚引用加入到与之关联的引用队列中，相当于发出一个通知。程序（垃圾回收器）可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。虚引用被用来管理JVM中的堆外内存，JVM中有个DirectByteBuffer,管理操作操作系统的一小块内存（堆外内存），DirectByteBuffer没有的时候，会放到队列中，垃圾回收器发现这个虚引用被加载到队列中，就会清理堆外内存，如果不用虚引用，那么堆外内存就无法被清理，因为不是被JVM管理的。
import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
public class Main {
public static void main(String[] args) {
ReferenceQueue<String> queue = new ReferenceQueue<String>();
PhantomReference<String> pr = new PhantomReference<String>(new String("hello"), queue);
System.out.println(pr.get());
}
}
3.ThreadLocal
1）ThreadLocal是什么？
ThreadLocal是在Thread类之外实现的一个功能（java.lang.ThreadLocal）， 它会为每个线程分别存储一份唯一的数据。正如它的名字所说的，它为线程提供了本地存储，也就是说你所创建出来变量对每个线程实例来说都是唯一的。当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。通过下面这段代码，可以更好的理解。
public class ThreadLocal1 {
volatile static Person p = new Person();
public static void main(String[] args) {
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(p.name);
}).start();
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
p.name = "lisi";
}).start();
}
}
class Person {
String name = "zhangsan";
}
结果为lisi。
现在这两个线程是互相影响的；第二个线程改了名字之后，第一个线程就能读的到了；
有的时候就想线程2的改变，不想让线程1知道，这时候怎么做？
/**
* ThreadLocal线程局部变量
*
* ThreadLocal是使用空间换时间，synchronized是使用时间换空间
* 比如在hibernate中session就存在与ThreadLocal中，避免synchronized的使用
*
* 运行下面的程序，理解ThreadLocal
*/
package yxxy.c_022;
import java.util.concurrent.TimeUnit;
public class ThreadLocal2 {
static ThreadLocal<Person> tl = new ThreadLocal<>();
public static void main(String[] args) {
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(tl.get());
}).start();
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
tl.set(new Person());
}).start();
}
static class Person {
String name = "zhangsan";
}
}
结果为null。
ThreadLocal的意思就是，ThreadLocal里面的变量，自己的线程自己用；你别的线程里要想用的话，不好意思你自己往里扔；不能用我线程里面放的东西；相当于每个线程都有自己的变量，互相之间不会产生冲突；可以理解为person对象每个线程里面拷贝了一份，改的都是自己那份，都是自己线程本地的变量，所以空间换时间；ThreadLocal在效率上会更高一些；有一些需要加锁的对象，如果它们在使用的时候自己进行的改变，自己维护这个状态，不用通知其他线程，那么这个时候可以使用ThreadLocal；
从数据结构入手
下图为ThreadLocal的内部结构图
2）ThreadLocal的使用场景
- 线程间数据隔离
- Spring中的声明式事务
- 数据库连接，Session会话管理，会将Connection对象放到ThreadLocal中，这样一个线程中所有方法使用的都是同一个Connection对象，不同线程使用的是不同的Connection对象。
3）ThreadLocal底层原理
当一个线程往ThreadLocal里存放数据时，
- 会先获取当前线程
- 得到当前线程的ThreadLocalMap，如果当前线程的ThreadLocalMap为空，就新建一个
- 把ThreadLocal对象当做key,把数据当做value存放到map中
源码如下：
set(T value)方法
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
下面来看getMpa(Thread t)
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
返回的是t.threadLocals,一个ThreadLocalMap对象，就是一个map。
下面来看一下这个ThreadLocals
ThreadLocal.ThreadLocalMap threadLocals = null;
这是Thread类中的代码，也就是说，每创建一个线程，线程就有一个ThreadLocalMap(threadLocals)。当一个线程往ThreadLocal里存放数据时，实际上是存到了自己的ThreadLocalMap里，这就解释了，为什么一个线程往ThreaLocal里存放数据时，其他的线程无法得到数据。
get()方法
- 获取当前线程的ThreadLocalMap对象（threadLocals）
- 从map中获取线程存储的K-V Entry节点。
- 从Entry节点获取存储的Value副本值返回。
- map为空的话返回初始值null，即线程变量副本为null，在使用时需要注意判断NullPointerException。
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
protected T initialValue() {
return null;
}
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;
}
remove()方法
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
4）ThreadLocalMap
ThreadLocalMap是ThreadLocal的内部类，没有实现Map接口，用独立的方式实现了Map的功能，其内部的Entry也独立实现。
在ThreadLocalMap中，也是用Entry来保存K-V结构数据的。但是Entry中key只能是ThreadLocal对象，这点被Entry的构造方法已经限定死了。从源码中可以看出，Entry类继承了弱引用类，构造函数中，调用了弱引用类的构造函数，也就是说，Entry对象和ThreadLocal对象之间是弱引用，但只有Key是弱引用类型的，Value并非弱引用。
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
ThreadLocalMap的成员变量：
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;
/**
* The next size value at which to resize.
*/
private int threshold; // Default to 0
Hash冲突怎么解决
和HashMap的最大的不同在于，ThreadLocalMap结构非常简单，没有next引用，也就是说ThreadLocalMap中解决Hash冲突的方式并非链表的方式，而是采用线性探测的方式，所谓线性探测，就是根据初始key的hashcode值确定元素在table数组中的位置，如果发现这个位置上已经有其他key值的元素被占用，则利用固定的算法寻找一定步长的下个位置，依次判断，直至找到能够存放的位置。
ThreadLocalMap解决Hash冲突的方式就是简单的步长加1或减1，寻找下一个相邻的位置
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}
/**
* Decrement i modulo len.
*/
private static int prevIndex(int i, int len) {
return ((i - 1 >= 0) ? i - 1 : len - 1);
}
显然ThreadLocalMap采用线性探测的方式解决Hash冲突的效率很低，如果有大量不同的ThreadLocal对象放入map中时发送冲突，或者发生二次冲突，则效率很低。
所以这里引出的良好建议是：每个线程只存一个变量，这样的话所有的线程存放到map中的Key都是相同的ThreadLocal，如果一个线程要保存多个变量，就需要创建多个ThreadLocal，多个ThreadLocal放入Map中时会极大的增加Hash冲突的可能。
5）ThreadLocal 内存泄漏问题
现在，根据图片重新理一下思路，一个线程使用ThreadLocal存放数据时（调用set方法），会先获取当前线程，并且获取线程的ThreadLocalMap，tl与ThreadLocal之间是强引用，ThreadLocalMap中，存储的是Entry对象，Entry对象中key与ThreadLocal之间是弱引用。
3）ThreadLocal中为什么要用弱引用
若是强引用的话，即使tl = null,但key的引用依然指向ThreadLocal对象，所以会有内存泄漏（一直站着内存不放），而使用弱引用则不会，当tl=null时，ThreadLocal会在下一次GC时被回收。
使用了弱引用，还是会有内存泄漏，ThreadLocal被回收，key的值变为null，则导致整个value再也无法被访问到，因此依然存在内存泄漏。所以在使用完ThreadLocal后，要调用remove()方法，删除对应的Entry对象（这里是另entry = null）。
总结
Java中的四种引用：强软弱虚。强引用：最普通的一个引用，只有等于null的时候，才会被回收。软引用：当JVM内存满的时候，会将软引用的对象进行回收，软引用主要用于图片缓存、网页缓存。虚引用：当一个对象只被虚引用时，下一次GC时，会被回收，虚引用主要用于HashMap、ThreadLocalMap中防止内存泄漏。虚引用：虚引用的对象，无法获得，必须和队列一起使用，当被回收时，会被放进队列，相当于给出一个通知，虚引用主要用于管理堆外内存。
ThreadLocal：ThreadLocal是给线程提供了一个本地存储，当一个线程使用ThreadLocal存储数据时，其他线程是看不到的，原理是，当调用ThreadLocal的set（）方法时，会先获取当前线程，然后获取到线程的ThreadLocalMap，将ThreadLocal作为key、数据作为value存储起来，当然ThreadLocal将key、value封装成了一个Entry对象，Entry类继承了弱引用类，key和ThreadLocal之间是弱引用，这样避免了ThreadLocal内存泄漏，为了避免value内存泄漏，每次s使用完之后，调用remove方法，对Entry对象进行回收。
参考：马士兵老师公开课
ThreadLocal-面试必问深度解析
文中如有不足之处，欢迎指正
