一、ThreadLocal是什么
从名称来看ThreadLocal的直接翻译就是线程本地，可以粗糙的理解成当前现成的本地数据，是不和其他线程共享的数据。但是这么理解是不是太片面呢，这里我们看一下JDK源码对ThreadLocal的注释是什么吧。
1. JDK源码说明
*
* 这个类提供线程局部变量。这些变量与普通的变量不同，因为每个访问的线程(通过其get或set方法)都有
* 自己的独立初始化的变量副本。ThreadLocal实例通常是希望将状态与线程关联的类中的私有静态
* (private static)字段(例如:一个用户ID或事务ID)。
*
* 只要线程存活并且ThreadLocal实例可以访问，每个线程都保存对其线程局部变量副本的隐含引用;
* 线程结束之后，线程本地实例的所有副本都将被垃圾回收（除非存在对这些副本的其他引用）。
* @author Josh Bloch and Doug Lea
* @since 1.2
*/
2. 个人理解
根据Jdk源码注释，我们可以得到以下理解：
每一个线程都在Threadlocal中单独存储，将ThreadLocal对象作为key，将存储的类型作为Value直接存储到ThreadLocalMap中；
由于是按照线程进行区分的，各个线程之间的变量不会互相影响；
因为ThreadLocal是和线程绑定的，如果是使用线程池的话，如果之前的线程没有在使用结束的时候执行remove操作，等到线程池再轮循到这个线程的时候，可能会读取到脏数据；
一个ThreadLocal在同一个线程中只能存储一个对象，如果多次执行set操作，后面存储的对象会覆盖前面存储的对象
由于这种kv的数据结构，我们可以粗略的将ThreadLocal理解成一个HashMap，只不过key是Threadlocal本身而已，有趣的时候，ThreadLocal在执行set的时候，也会执行自己的Hash寻址算法，这点和Hashmap很像。
3. 使用场景
如果你希望构造这样一个对象，将这个对象设置为共享变量，并统一设置初始值。但是你还希望每个线程对这个值的修改都是互相的独立的。那么这个对象就是ThreadLocal
4. ThreadLocal和Thread的关系
ThreadLocal有一个静态内部类叫ThreadLocalMap，它还有一个静态内部类Entry，在Thread中的ThreadLocalMap属性的赋值是在ThreadLocal类中的createMap中进行的。ThreadLocal和ThreadLocalMap有三组对应的方法：get、set和remove，在ThreadLocal中对它们只做校验和判断，最终的实现会落在ThreadLocalMap上。Entry继承自WeakReference，没有方法，只有一个value成员变量，它的key是threadLocal对象。
static class Entry extends WeakReference<ThreadLocal<?>> {
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
简单梳理一下他们的关系：
1个Thread有且仅有一个ThreadLocalMap对象；
1一个Entry对象的Key弱引用指向1个ThreadLocal对象；
1个ThreadLocalMap对象可以存储多个Entry
1个ThreadLocal对象可以被多个线程所共享
ThreadLocal对象不持有value，value由线程的entry对象持有
所有Entry对象都被ThreadLocalMap类实例化对象threadLocals持有。当线程对象执行完毕时，线程对象内的实例属性均会被垃圾回收。但是，ThreadLocal对象经常被设置为私有静态变量使用，那么其生命周期至少不会随着线程结束而结束。
二、ThreadLocal怎么用
1. API
返回值 方法名 备注
void set 存储
void remove 删除
T get 获取
2. 在多线程情况下的Demo
启动类
public class ThreadDemo {
public static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>();
public static void main(String[] args) throws InterruptedException {
Executor executor = Executors.newFixedThreadPool(1);
for (int i = 0; i < 4; i++) {
executor.execute(new RunnableDemo());
}
while (true) {
}
}
}
线程类
public class RunnableDemo implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " get num : " + ThreadDemo.threadLocal.get());
Integer num = new Random().nextInt();
System.out.println(Thread.currentThread().getName() + " out num : " + num);
ThreadDemo.threadLocal.set(num);
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
输出结果：
pool-1-thread-1 get num : null
pool-1-thread-1 out num : 162662825
pool-1-thread-1 get num : 162662825
pool-1-thread-1 out num : -168394526
pool-1-thread-1 get num : -168394526
pool-1-thread-1 out num : 842018131
pool-1-thread-1 get num : 842018131
pool-1-thread-1 out num : 1188266731
结论：
由于我们的线程对象中没有对ThreadLocal执行remove方法，当线程池第二次轮询到这个线程的时候，直接执行threadLocal.get()方法获取到的还是上一次执行的结果。这种情况是要尽量避免，因为有可能因为没有执行remove操作，而导致第二次获取到的数据是错误的。
3. ThreadLocal无法解决共享对象的更新问题
如例子所示：
public class ThreadLocalDemo {
private static final StringBuilder INIT_VALUE = new StringBuilder("init");
private static final ThreadLocal<StringBuilder> builder = new ThreadLocal<StringBuilder>() {
@Override
protected StringBuilder initialValue() {
return INIT_VALUE;
}
};
private static class AppendStringThread extends Thread {
@Override
public void run() {
StringBuilder inThread = builder.get();
for (int i = 0; i < 10; i++) {
inThread.append("-").append(i);
}
System.out.println(Thread.currentThread().getName() + inThread.toString());
}
}
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 10; i++) {
new AppendStringThread().start();
}
TimeUnit.SECONDS.sleep(10);
}
}
输出结果：
Thread-1init-0-1-2-3-4-5-6-7-8-9
Thread-3init-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9
Thread-0init-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9
Thread-2init-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9
可以看到输出的结构是乱序不可控的，所以使用讴歌引用来操作共享对象时，依然需要进行线程同步。
现在我们将AppendStringThread类中的intThread计算来做上锁来保证线程之间的同步机制，其他方法不边。AppendStringThread具体代码如下：
private static class AppendStringThread extends Thread {
@Override
public void run() {
StringBuilder inThread = builder.get();
ReentrantLock lock = new ReentrantLock(true);
lock.lock();
try {
for (int i = 0; i < 10; i++) {
inThread.append("-").append(i);
}
} catch (Exception e) {
e.printStackTrace();
}finally {
lock.unlock();
}
System.out.println(Thread.currentThread().getName() + inThread.toString());
}
}
输出结果：
Thread-0init-0-1-2-3-4-5-6-7-8-9
Thread-1init-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9
Thread-2init-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9
Thread-4init-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9
Thread-6init-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9
Thread-7init-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9
Thread-8init-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9
Thread-9init-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9
Thread-3init-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9
Thread-5init-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9
三、ThreadLocal 源码分析
1. 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);
}
源码解析
set方法内的东西看起来比较少，甚至我们不用看具体实现就能大概知道他想做什么。执行逻辑：
获取当前线程；
获取当前线程的ThreadLocalMap内部类对象；
判断ThreadLocalMap内部类是否为空；
如果不为空则执行set操作，将当前ThreadLocal作为key，value作为值存储到ThreadLocalMap中；
如果ThreadMap是null，则执行新建操作，并且将给定的ThreadLocal作为key，传入的对象作为value写入ThreadLocal中；
具体是不是这样的呢，我们可以看一下代码。Thread t = Thread.currentThread();这段代码就不用解析了，因为不涉及到其他方法。我们直接来看第二行ThreadLocalMap map = getMap(t);
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
可以看到返回的当前线程的threadLocals，那我们追过去看一下threadLocals是个什么东西呢？
ThreadLocal.ThreadLocalMap threadLocals = null;
从这里我们可以看到所谓t.threadLocals本质上是指向了ThreadLocal类的一个内部类ThreadLocalMap，我们可以看一下ThreadLocalMap内部类中的属性
* The initial capacity -- MUST be a power of two.
*/
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;
是不是看起来似曾相识，是不是有点像HashMap。我们这边先暂时按下对ThreadLocalMap这个内部类的好奇之心，继续往下看。ThreadLocal.set方法后面发生了什么，它开始判断这个ThreadLocalMap是不是null，刚才我们看源码得到ThreadLocal.ThreadLocalMap threadLocals = null;可以得知，第一次访问的时候这个值一定是null，那么它就会触发createMap(t, value);方法。
createMap(t, value);方法显然是一个初始化方法，我们看一下它做了什么：
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
将当前线程的threadLocals的成员变量指向了一个新的ThreadMap对象，将当前ThreadLocal对象作为key，存储的对象作为value对ThreadLocalMap进行初始化
接下来我们看一下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);
}
private void setThreshold(int len) {
threshold = len * 2 / 3;
}
到现在为止，第一次初始化ThreadLocalMap的代码逻辑就已经全部梳理完了，现在我们看一下，第二次乃至第N次存储数据的时候，ThreadLocal是如何处理的
if (map != null)
map.set(this, value);
private void set(ThreadLocal<?> key, Object value) {
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)]) {
ThreadLocal<?> k = e.get();
if (k == key) {
e.value = value;
return;
}
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
注1.2
private boolean cleanSomeSlots(int i, int n) {
boolean removed = false;
Entry[] tab = table;
int len = tab.length;
do {
i = nextIndex(i, len);
Entry e = tab[i];
if (e != null && e.get() == null) {
n = len;
removed = true;
i = expungeStaleEntry(i);
}
} while ( (n >>>= 1) != 0);
return removed;
}
2. 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();
}
threadLocal的方法非常简单，寥寥几行。大概的意思就是判断一下当前线程的threadLocalMap是否为null，如果不是null，再判断当前这个threadlocal对象是否存储过数据，如果存储过就直接返回存储的数据，如果没有存储过。再执行初始化操作setInitialValue。
每个线程都有自己的ThreadLocalMap，如果map==null，则直接执行setInitialValue。如果map已经创建，则就表示Thread类的threadLocalMap属性已经初始化，如果e==null，依然会执行到setInitialValue。接下来我们看一下这个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;
}
注1
protected T initialValue() {
return null;
}
这个方法默认是返回的null，如果大家希望再初始化value的时候，给定一个不同的值，那么就需要继承ThreadLocal并重写此方法。通常用于匿名内部类中，例如：
private static final ThreadLocal<Integer> INIT_DEMO = new ThreadLocal<Integer>(){
@Override
protected Integer initialValue() {
return 1000;
}
};
public static void main(String[] args) throws InterruptedException {
System.out.println(INIT_DEMO.get());
}
上面代码中，就没有通过set方法给INIT_DEMO对象赋值，而是通过重写了initialValue方法，在INIT_DEMO对象调用get方法的时候给对象进行赋值的。
3. remove方法
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
remove方法应该是ThreadLocal中最简单的一个方法了，因为他不涉及到大量的方法调用，他就是获取到了当前线程的ThreadLocalMap对象，然后判断一下这个map是否为null，如果不是null，就尝试删除这个map中key为当前threadLocal的entry。下面是remove方法的源码
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;
}
}
}
四、ThreadLocal的副作用
1. 脏数据
线程复用会产生咱数据。由于线程池会重用Thread对象，那么与Thread绑定的静态属性ThreadLocal变量也会被宠用。如果在实现的线程的run方法中不显示地调用remove方法清理与线程相关的threadLocal信息，那么倘若下一个线程不调用set设置初始值，就可能get到重用的线程信息，包括threadlocal所关联的线程对象的value值。
我们在【2.在多线程情况下的Demo】中就复现了这个问题，我们创建了一个线程池大小固定为1的线程池。然后将四个线程放入线程池执行。
第一个线程执行完之后将162662825作为value存入threadLocal中，但是在线程的run方法中，并没有显示地调用remove方法。第一个线程执行完毕后，第二个线程开始执行。
第二个线程在执行set之前，先执行了get方法，然后就获取到了上一个线程执行过程中set到threadlocal中的值，于是就出现了如下的结果：
pool-1-thread-1 get num : null
pool-1-thread-1 out num : 162662825
pool-1-thread-1 get num : 162662825
pool-1-thread-1 out num : -168394526
2. 内存泄漏
在源码注释中提示使用static关键字来修饰ThreadLocal。在这个场景下， 寄希望于ThreadLocal对象失去引用后，触发弱引用机制来回收Entry的value就不现实了。在上例中，如果不进行remove操作，那么这个线程回收完之后，通过ThreadLocal对象持有的String对象是不会被释放的。
3. 解决方案
其实以上两个问题解决方法很简单，就是在每次用完ThreadLocal时，必须要及时调用remove方法显示的清理。
五、参考资料
《Java并发编程实战》
《码出高效 Java开发手册》
《JDK1.8源码》
评论