声明：原创文章，转载请注明出处。https://www.jianshu.com/p/6341cfa5c3cd
一、概述
ThreadLocal： 通常被称作线程本地变量或者线程本地存储。其含义是ThreadLocal为变量在每个线程中都创建一个副本，则每个线程可以访问自身内部的副本变量。
概念总是抽象而且晦涩的，我们从两个例子说起。
1、对象间/方法间跨层传递
如下图，有个多层调用的情况，如果我们需要传递某个中间结果在这几层调用关系之间，应该怎么处理呢？
- 一种简单的思路是，把每个函数新增一个参数，然后依次传递下去。但是，如果参数过多，或者某一个函数为公共函数，不允许我们随意添加参数的话，那该怎么处理呢？
- 另一种思路，设置一个单例类，实时保存该数据。实存实取。也能保证其在各个函数之间的传递。但是，如果是多线程操作怎么保证单例数据不被污染？
假设，我们在A.fun1()之中将数据保存在单例类中，然后在之后的其他函数中操作该数据。如果是多线程的环境，如果同时有多个线程同时操作入口函数A.fun1()，则单例保存的数据则会被污染。 - 还有一种思路，就是使用
ThreadLocal为该数据在每个线程中都创建一个副本，则线程之间则不会互相影响。如下代码，通过ThreadLocal，我们可以使数据在对象间/方法间进行传递。
public class ThreadLocalDemo {
private ThreadLocal<Long> threadLocal = new ThreadLocal<>();
private void fun1() {
threadLocal.set(System.nanoTime());
System.out.println("fun1:" + threadLocal.get());
fun2();
}
private void fun2() {
System.out.println("fun2:" + threadLocal.get());
fun3();
}
private void fun3() {
System.out.println("fun3:" + threadLocal.get());
threadLocal.remove();
}
public static void main(String[] args) {
ThreadLocalDemo demo = new ThreadLocalDemo();
demo.fun1();
}
}
2、线程间的数据隔离
如果需要将一个单线程的应用移植到到多线程的环境下，就需要将共享的一些全局变量转换为ThreadLocal对象；这相当于ThreadLocal为每个线程都创建了一个该全局变量的副本。保证了其线程安全性。
但是，TheadLocal并不是解决高并发下共享资源的方式。大多数情况下，ThreadLocal存储的是一个new的新对象。但是如果其存储一个对象的引用，也会面临资源竞争的情况。
- 例子1：ThreadLocal与Synchronized区别
好多人都说ThreadLocal和Synchroized一样，实现了线程同步。那我们看个例子。
假设有一个static int a = 0;，共有5个线程对其进行++操作，保险起见，我们对++进行加锁（Sync）。这样在执行完之后，a == 5，毫无疑问。
同样的，我们起初使用ThreadLocal保存a = 0，同样地，共有5个线程从ThreadLocal取出，并执行++操作。最后输出a的值。
public class ThreadLocalDemo {
private static int a = 0;
private static ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> a);
public static void main(String[] args) {
ExecutorService pool = Executors.newCachedThreadPool();
for (int i = 0; i < 5; i++) {
pool.execute(() -> {
a = threadLocal.get() + 1;
threadLocal.set(a);
});
}
pool.shutdownNow();
System.out.println(a);
}
}
最终输出a的值完全不固定。这是因为static a 为共享变量，每个线程（包括Main线程）都保存了一个a的引用的副本。ThreadLocal并不能替代Synchronized的作用。
- 例子2：ThreadLocal存储的是共享变量的引用
public class ThreadLocalDemo {
private static ThreadLocal<Student> threadLocal = new ThreadLocal<>();
private static Student student = new Student("a");
public static void main(String[] args) throws Exception {
new Thread(() -> {
threadLocal.set(student);
while (true) {
System.out.println(threadLocal.get());
try {
TimeUnit.SECONDS.sleep(1);
} catch (Exception e) {}
}
}).start();
TimeUnit.SECONDS.sleep(2);
student.name = "b"; // 修改共享变量
}
private static class Student {
public String name;
public Student(String name) {
this.name = name;
}
public String toString() {
return this.name;
}
}
}
运行2秒后，线程1的ThreadLocal会被Main线程修改。则对共享变量的操作，同样存在多线程的竞争情况。
结论：ThreadLocal的使用通常由private static修饰，适用于对象/方法间跨层传递，或实现变量在多线程之间的隔离，并非解决多线程同步问题。常用于保存Session、DB连接等。
二、ThreadLocal详解
我们还是从下面的一个例子说起，从运行结果看，每个线程均保存了一个线程副本，且相互之间互不影响。这是因为每个线程的副本中都存放的是一个new变量，而并非共享变量。每个线程各自维护。
public class ThreadLocalExample {
private static ThreadLocal<Integer> local = new ThreadLocal<>();
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
for (int i = 0; i < 5; i++) {
service.execute(() -> {
int key = (int) (Math.random() * 10);
local.set(key);
System.out.println(Thread.currentThread().getName() + ":" + key);
try {
TimeUnit.SECONDS.sleep(1);
} catch (Exception e) {}
System.out.println(Thread.currentThread().getName() + ":" + local.get());
});
}
}
}
使用ThreadLocal，最常用的几个方法，分别为initialValue()、set(T value)、get()和remove()。
2.1 initialValue()
返回线程副本变量的初始值。该方法为protected可以通过子类覆盖实现初始值设置。该方法为延迟调用方法，只在线程第一次调用get()时才执行一次。
protected T initialValue() {
return null;
}
2.2 set(T value)
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
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);
}
首先通过getMap(Thread t)获取当前线程所属的ThreadLocalMap，然后将Value设置到这个Map中；如果当前线程没有这个Map，则新建一个。
2.3 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();
}
2.4 ThreadLocalMap
上面所看到的ThreadLocalMap是一个和HashMap差不多的结构，用来存储线程放在ThreadLocal中的数据备份，其所有方法都为private。但实际上存储数据的为下面的Entry。
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
Entry为一个弱引用类型，主要是使JVM能够自动回收。
三、ThreadLocal内存泄漏分析
同样，我们首先看一个例子。
public class ThreadLocalMemory {
private static ThreadLocal<byte[]> threadLocal = new ThreadLocal<>();
public static void main(String[] args) throws Exception {
threadLocal.set(new byte[100 * 1024 * 1024]);
threadLocal = null;
Thread.sleep(10 * 1000);
// Full GC
System.gc();
}
}
通过Jprofile查看下内存和GC情况，发现在进行GC之后，内存并没有减小：
我们可以分析下ThreadLocal 的Set情况：
执行threadLocal = null;后，
虽然ThreadLocalMap中的Enry为弱引用，为的就是当没有强引用指向 ThreadLocal 变量时，它可被回收，从而避免ThreadLocal 不能被回收而造成的内存泄漏的问题。
但是，Entry中Value为一个对值的强引用。当 ThreadLocal 变量被回收后，该Entry的Key变为 null，该 Entry 无法被移除致使内存泄漏。
那我们应该怎么避免这种情况呢？答案就是在回收ThreadLocal之前，先把其中的数据清理。如下：
public class ThreadLocalMemory {
private static ThreadLocal<byte[]> threadLocal = new ThreadLocal<>();
public static void main(String[] args) throws Exception {
threadLocal.set(new byte[100 * 1024 * 1024]);
threadLocal.remove(); // 清除数据
threadLocal = null;
Thread.sleep(10 * 1000);
// Full GC
System.gc();
}
}
