ThreadLocal 作用
ThreadLocal的功能在Java多线程并发环境中非常实用，其作用是提供线程本地变量，例如用户ID、会话ID等与当前线程密切关联的信息。
这里提到的
线程本地变量指的是：当前线程自身拥有的变量值。其他线程中可能存在相同性质的变量值，但是彼此存在线程隔离，互不共享，所以在多线程环境中，对变量值的操作不需要添加同步控制。
声明示例：
public class Test {
private static ThreadLocal<Long> threadId = new ThreadLocal<>();
//...
}
这里声明的方式较为简单，后续会提供ThreadLocal类的使用函数说明。
ThreadLocal 产生背景
原始代码
以id的查询和修改操作为例，若多线程环境中类成员的声明、使用为如下方式，则使用过程中可能存在访问结果不确定的情况：
public class Test {
private Long id = 1L;
public void updateId() {
this.id = Thread.currentThread().getId();
}
public Long getId() {
return this.id;
}
}
当一个线程访问getId函数时，可能同时有另一个线程执行了updateId修改函数，所以查询到的id值存在不确定性。
这里对
id的赋值使用的是Thread.currentThread().getId()，也就是赋予了线程id，此处只是为了表示该变量值与当前线程有关而已。
synchronized 修饰
为了保证当一个线程执行查询id操作的同时，不会有其他线程执行修改操作，这里可以使用synchronized关键字对查询和修改操作进行同步控制：
public class Test {
private Long id = 1L;
public synchronized void updateId() {
this.id = Thread.currentThread().getId();
}
public synchronized Long getId() {
return this.id;
}
}
在方法声明中增加synchronized关键字修饰，则线程需要先获取对象锁，然后才能执行同步方法内容。虽然该方式可以达到同步访问的目的，但是串行访问的代价较大。
这里使用
Java内置的synchronized关键字来进行访问控制，只是为了举例说明同步的形式。由于该示例中的getId和updateId函数相当于读、写操作，所以也可以使用java.util.concurrent.locks包中提供的Lock、ReadWriteLock读写锁来实现读写控制。
ThreadLocal 线程本地变量
为了避免多线程场景下的串行访问现象，这里给每一个线程提供一个id对象，由于每个线程都有一个自己的id对象，所以查询、修改操作彼此不再相互影响：
public class Test {
private ThreadLocal<Long> idLocal = new ThreadLocal<Long>();
public void updateId() {
idLocal.set(Thread.currentThread().getId());
}
public Long getId() {
return idLocal.get();
}
}
在代码中声明了一个idLocal成员，给每个线程分配一个自己单独id对象的功能，就是由该成员实现的；每个线程对自己id对象的查询和修改操作，也都是由该对象完成的。
从代码中可以发现一个很明显的现象，一直讲的
id对象不见了，或者说它是被idLocal成员隐藏掉了。这是因为idLocal成员与id对象构成一个键值对，键为idLocal成员，值为id对象，所以代码中只需要保留一个idLocal键成员就可以了，对值的修改通过updateId函数中的idLocal.set()完成，对值的查询通过getId函数中的idLocal.get()完成。
因为idLocal成员与id对象构成了一个键值对，所以现在关注的重点不再是id对象，而是idLocal成员，因为得idLocal，即可通过idLocal.get()得id对象。因为idLocal是一个成员变量，用于指向一个ThreadLocal类型对象，下面分析该成员变量是怎么保存于每个线程中的。
ThreadLocal 实现原理
要实现每个线程中都保存一个自己的id对象，则需要实现每个线程中都保存一个<idLocal, id>键值对。首先看一下ThreadLocal的set函数是怎么在每个线程上保存<idLocal, id>键值对；然后看一下ThreadLocal的get函数是怎么从每个线程上获取<idLocal, id>键值对，继而获取键值id对象的。
后续引用的
Java源码版本为jdk1.8.0_121
set 函数
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;
}
由源码可知，set函数中，首先获取当前线程对象t，然后获取t对象的threadLocals属性，该属性的类型为ThreadLocalMap，维持的是一个键值对序列。当t对象的threadLocals属性不为空时，执行map.set(this, value)，键为this，即idLocal，键值为value，即id对象。
由ThreadLocal类中的set函数内容分析可知，每个线程对象通过自身的threadLocals成员，维持一个键值对序列，前面提到的<idLocal, id>键值对，则是保存在该threadLocals成员中的一个键值对。由此可知，在每个线程上保存<idLocal, id>键值对，是通过获取每个线程的threadLocals成员属性来实现的。
ThreadLocalMap 类型
线程对象的成员属性threadLocals，其声明方式为：
public class Thread implements Runnable {
ThreadLocal.ThreadLocalMap threadLocals = null;
//...
}
ThreadLocalMap是ThreadLocal类中的一个静态内部类，其键值对类型定义为：
public class ThreadLocal<T> {
//...
static class ThreadLocalMap {
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
private static final int INITIAL_CAPACITY = 16;
private Entry[] table;
//...
}
}
由ThreadLocalMap定义可知，其内部维持的是一个Entry数组，Entry是一个键值对类型，键的类型为ThreadLocal，键值的类型为Object。
由定义可知，
Entry对键类型ThreadLocal保持的是弱引用，当测试类对象test消除或者线程终止后，即除了Entry之外，不存在其他对ThreadLocal对象的引用，当执行垃圾回收时，会回收该ThreadLocal对象。
get 函数
ThreadLocal的get函数体如下：
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();
}
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;
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
protected T initialValue() {
return null;
}
要获得每个线程上保存的<idLocal, id>键值对，get方法内首先获得当前线程对象t，继而获得线程对象的threadLocals成员属性，即这里的ThreadLocalMap类型变量map，然后根据idLocal获得map上的<idLocal, id>键值对，最后获取键值id对象。
在get方法中有两种情况下可能会调用setInitialValue()方法设置初始值：
一是线程对象
t的threadLocals成员属性为空时，即当前线程对象上并没有保存任何键值对，此时会初始化threadLocals成员属性，并赋予初始键值对<idLocal, null>；另一种情况是线程对象
t的threadLocals成员属性不为空，但是并不存在idLocal对应的键值对，此时会赋予默认键值对<idLocal, null>。
由get方法的分析可知，在查询idLocal对应的键值之前，若没有执行set函数进行设置，则默认会创建并返回null值，所以推荐ThreadLocal的使用方式为重写initialValue函数，设定初始值：
public class Test {
private ThreadLocal<Long> idLocal_one = new ThreadLocal<Long>();
private ThreadLocal<Long> idLocal_two = new ThreadLocal<Long>() {
protected Long initialValue() {
return Thread.currentThread().getId();
}
};
public static void main(String[] args) {
Test test = new Test();
System.out.println("main thread idLocal_one get: " + test.idLocal_one.get());
System.out.println("main thread idLocal_two get: " + test.idLocal_two.get());
}
}
输出结果为：
main thread idLocal_one get: null
main thread idLocal_two get: 1
由示例可知，idLocal_one没有设置初始值，所以直接查询其对应的键值为null，idLocal_two设置了初始值，所以直接查询其对应的键值不为null。
ThreadLocal 使用注意
由前面的分析可知，要想在每个线程中保存仅供自身使用的对象id_1、id_2...，可以声明使用ThreadLocal类型对象idLocal_1、idLocal_2...，构成<idLocal, id>键值对，保存于每个线程对象的threadLocals成员中，通过idLocal对象的get方法即可查询对应的id对象。
对于如下的使用场景：
public class Test {
private ThreadLocal<Long> idLocal = new ThreadLocal<Long>() {
protected Long initialValue() {
return Thread.currentThread().getId();
}
};
public static void main(String[] args) throws InterruptedException {
Test test = new Test();
System.out.println("main thread idLocal: " + test.idLocal);
System.out.println("main thread idLocal get: " + test.idLocal.get());
new Thread() {
public void run() {
System.out.println("sub thread idLocal: " + test.idLocal);
System.out.println("sub thread idLocal get: " + test.idLocal.get());
}
}.start();
}
}
代码中存在两个线程，主线程和子线程，输出结果为：
main thread idLocal: Test$1@1540e19d
main thread idLocal get: 1
sub thread idLocal: Test$1@1540e19d
sub thread idLocal get: 11
由结果可知主线程和子线程引用的是同一个idLocal对象，因为Test类中声明的idLocal变量是可更改的，所以这里存在一个潜在的问题：如果多个线程中使用的是同一个idLocal变量，其中某一个线程更改了该变量的引用对象，则会导致其他所有线程查询不到之前设置的键值对。
情况一：
public class Test {
private ThreadLocal<Long> idLocal = new ThreadLocal<Long>() {
protected Long initialValue() {
return Thread.currentThread().getId();
}
};
public static void main(String[] args) throws InterruptedException {
Test test = new Test();
test.idLocal.set(123L);
System.out.println("main thread idLocal get: " + test.idLocal.get());
Thread subThread = new Thread() {
public void run() {
test.idLocal = new ThreadLocal<Long>() {
protected Long initialValue() {
return 456L;
}
};
}
};
subThread.start();
subThread.join();
System.out.println("main thread idLocal get: " + test.idLocal.get());
}
}
输出结果为：
main thread idLocal get: 123
main thread idLocal get: 456
主线程和子线程共用一个test对象，在子线程中更新了idLocal的引用对象，导致主线程丢失根据之前idLocal设置的键值。
情况二：
public class Test {
private static ThreadLocal<Long> idLocal = new ThreadLocal<Long>() {
protected Long initialValue() {
return Thread.currentThread().getId();
}
};
public static void main(String[] args) throws InterruptedException {
Test one = new Test();
one.idLocal.set(123L);
System.out.println("main thread idLocal get: " + one.idLocal.get());
Thread subThread = new Thread() {
public void run() {
Test two = new Test();
two.idLocal = new ThreadLocal<Long>() {
protected Long initialValue() {
return 456L;
}
};
}
};
subThread.start();
subThread.join();
System.out.println("main thread idLocal get: " + one.idLocal.get());
}
}
输出结果为：
main thread idLocal get: 123
main thread idLocal get: 456
因为idLocal声明为静态变量，所以多个Test实例对象共享该变量，一个线程中的实例更改了该变量引用的对象，则其他线程会丢失根据该变量设置的键值。
所以推荐以final修饰ThreadLocal类型成员，使用方式为：
public class Test {
private final static ThreadLocal<Long> idLocal = new ThreadLocal<Long>() {
protected Long initialValue() {
return Thread.currentThread().getId();
}
};
public void set(Long value) {
idLocal.set(value);
}
public Long get() {
return idLocal.get();
}
//...
}
参考
When and how to use a ThreadLocal
How is ThreadLocal implemented?
