简介
ThreadLocal叫线程变量，意思是ThreadLocal中填充的变量属于当前线程，该变量对于其他线程而言是隔离的，也就是说该变量是线程独有的变量。ThreadLocal为变量在每个线程中都创建了一个副本，每个线程都可以访问自己内服的副本变量
ThreadLocal变量，线程局部变量，同一个ThreadLocal所包含的对象，在不同的Thread中有不同的副本。
注意：
- 因为每个Thread内有自己的实例副本，且该副本只能由当前Thread使用。这就是ThreadLocal命名的由来
- 既然每个Thread都有自己的实例副本，而且其他Thread不可访问，也就不存在多线程间共享的问题
ThreadLocal提供了线程本地实例。他与普通变量的区别在于，每个使用该变量的线程都会初始化一个完全独立的实例副本
ThreadLocal变量通常被private static修饰。当一个线程结束时，他所使用的所有ThreadLocal相对的实例副本都可被回收
总的来说，ThreadLocal适用于每个线程需要自己独立的实例需要在多个方法中被使用，即变量在线程间隔离而在方法或者类之间共享
图示如下：
ThreadLocal与Synchronized的区别
ThreadLocal其实是与线程绑定的一个变量。ThreadLocal和Synchronized都用于解决多线程并发访问
但是ThreadLocal与Synchronized有本质区别
- Synchronized用于线程之间的数据共享，而ThreadLocal则用于线程间的数据隔离
- Synchronized是利用锁的机制，使变量或者代码块在某一时刻只能被一个线程访问。而ThreadLocal为每个线程都提供了一个变量副本，使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。而Synchronized却正好相反，它用于在多个线程间通信时能够获得数据共享
一句话理解ThreadLocal，ThreadLocal是作为当前线程中属性ThreadLocalMap集合中的某一个Entry的key值
Entry（ThreadLocal，value），虽然不同的线程之间ThreadLocal这个key值是一样的，但是不同线程所有用的ThreadLocalMap却是独一无二的，也就是不同的线程之间同一个ThreadLocal（key）对应存储的值（value）不一样，从而达到了线程间变量隔离的目的，但在一个线程中，这个value变量地址是一样的
ThreadLocal原理
set（）方法
public void set(T value) {
//1、获取当前线程
Thread t = Thread.currentThread();
//2、获取线程中的属性 threadLocalMap ,如果threadLocalMap 不为空，
//则直接更新要保存的变量值，否则创建threadLocalMap，并赋值
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
// 初始化thradLocalMap 并赋值
createMap(t, value);
}
从上面的代码可以看到，ThreadLocal的set赋值的时候，首先就获取当前线程的Thread，并获取Thread线程中的ThreadLocalMap属性。如果map不为空，则直接更新value值，如果map为空， 则是梨花ThreadLocalMap，并将value值初始化
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;
}
}
}
可以看到ThreadLocalMap是ThreadLocal的内部静态类，而他的构成主要是用Entry来保存数据，而且还是继承的弱引用。在Entry内部使用ThreadLocal作为key，并且设置value
//这个是threadlocal 的内部方法
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
//ThreadLocalMap 构造方法
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);
}
get（）方法
public T get() {
//1、获取当前线程
Thread t = Thread.currentThread();
//2、获取当前线程的ThreadLocalMap
ThreadLocalMap map = getMap(t);
//3、如果map数据不为空，
if (map != null) {
//3.1、获取threalLocalMap中存储的值
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
//如果是数据为null，则初始化，初始化的结果，TheralLocalMap中存放key值为threadLocal，值为null
return setInitialValue();
}
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;
}
从代码中可以看到get方法就很简单了，直接获取ThreadLocalMap，使用变量副本直接获取内容。如果不为空则返回，如果为空则init
remove（）方法
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
remove（）方法，直接将ThreadLocal对用的值从当前的Thread中的ThreadLocalMap中删除。防止出现内存泄漏问题。 实际上，在上面也强调了ThreadLocalMap中使用的key为ThreadLocal弱引用，弱引用的特点就是如果在这个对象只存在弱引用，那么在下一次GC的时候就必然会被清除掉 所以如果ThreadLocal没有被外部强引用的情况下，在GC的时候是会被清理掉的，这样一来，ThreadLocalMap中使用的ThreadLocal的key也会被清理。但是如果value是强引用，那就不会被清理，就会出现key为null的value
ThreadLocal其实是与线程绑定的一个变量，如此就会出现一个问题：如果没有将ThreadLocal的内部变量删除（remove）或者替换，它的生命周期将会与线程共存。通常线程池中对线程管理都是采用线程复用的方式，在线程池中很难结束，甚至永远不会结束，这就意味着线程持续的时间将不可预测，甚至与JVM的生命周期一致。
举个🌰：如果ThreadLocal中直接或间接包装了集合类或复杂对象，每次在同一个ThreadLocal中取出对象后，在对内容做出操作，那么内部的集合类和复杂对象所占用的空间可能会开始膨胀
ThreadLocal常见场景
ThreadLocal适用于如下两种场景：
- 每个线程都需要有自己的实例
- 实例需要在多个方法中共享，但不希望被多线程共享
存储用户Session
private static final ThreadLocal threadSession = new ThreadLocal();
public static Session getSession() throws InfrastructureException {
Session s = (Session) threadSession.get();
try {
if (s == null) {
s = getSessionFactory().openSession();
threadSession.set(s);
}
} catch (HibernateException ex) {
throw new InfrastructureException(ex);
}
return s;
}
数据库链接，处理数据库事务
数据跨层传递
每个线程内保存类似于全局变量的信息（例如在拦截其中获取的用户信息），可以让不同方法直接使用，避免参数传递的麻烦，并且不想被其他线程共享（因为不同线程获取到的用户信息不一样）
例如，用ThreadLocal保存一些业务内容（用户权限信息，从用户系统获取到的用户名，用户ID等），这些信息在同一个线程内相同，但是不同的线程使用的业务内容是不同的。在线程的生命周期内，都通过ThreadLocal的get（）方法取得自己set进去的对象，避免了将这个对象（如User对象）作为参数传递的麻烦。
举个例子：在一个用户系统中，当一个请求过来时，一个线程就会负责执行这个请求，这个请求依次调用 service1（），service2（），service3（）等，这些方法可能在不同类中，但是可以在同一个ThreadLocal中获取同一个内容
package com.kong.threadlocal;
public class ThreadLocalDemo05 {
public static void main(String[] args) {
User user = new User("jack");
new Service1().service1(user);
}
}
class Service1 {
public void service1(User user){
//给ThreadLocal赋值，后续的服务直接通过ThreadLocal获取就行了。
UserContextHolder.holder.set(user);
new Service2().service2();
}
}
class Service2 {
public void service2(){
User user = UserContextHolder.holder.get();
System.out.println("service2拿到的用户:"+user.name);
new Service3().service3();
}
}
class Service3 {
public void service3(){
User user = UserContextHolder.holder.get();
System.out.println("service3拿到的用户:"+user.name);
//在整个流程执行完毕后，一定要执行remove
UserContextHolder.holder.remove();
}
}
class UserContextHolder {
//创建ThreadLocal保存User对象
public static ThreadLocal<User> holder = new ThreadLocal<>();
}
class User {
String name;
public User(String name){
this.name = name;
}
}
执行的结果：
service2拿到的用户:jack
service3拿到的用户:jack
ThreadLocal内存泄漏
Entry将ThreadLocal作为key，值作为value，它继承自WeakReference
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
主要有两个原因：
- 没有手动删除这个Entry
- CurrentThread当前线程依然在运行
第一点容易理解，只要使用完ThreadLocal，调用其remove方法，删除对应的Entry，就能避免内存泄漏
第二点稍微复杂，由于ThreadLocalMap是Thread的一个属性，被当前线程所引用，所以ThreadLocalMap的生命周期和Thread一样。如果ThreadLocal变量被回收，那当前线程的ThreadLocal变量副本指向的key = null，那这个Entry中value将访问不到。
在实际情况中，ThreadLocal场景都是采用线程池，而线程池中的线程都是复用的，就会导致非常多的Entry（null，value）出现，从而导致内存泄漏
