再次重复一遍，并发问题出现的根源是多个线程同时读写同一共享变量。通过 的方式可以只读不写，还有另一种方式就是：避免共享。
比如局部变量是线程安全的，因为每个线程都有自己的一份，没有共享，即线程封闭。Java 提供 ThreadLocal 也能做到避免共享，即每个线程都有自己的副本。
使用方法
我们知道 SimpleDateFormat 不是线程安全的，如果要在并发场景下使用它，有一个办法就是通过 ThreadLocal。
如果是同一个线程调用 get 方法，则会返回相同的实例，若是不同的线程调用 get 方法，则会返回不同的实例。
// java.lang.Thread.java
public class SafeDateFormat {
private static final ThreadLocal<SimpleDateFormat> th =
ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
public static DateFormat get() {
return th.get();
}
}
原理实现
需要实现 ThreadLocal 的逻辑，我们有两个思路：
在 ThreadLocal 中持有一个 Map，key 是线程 ID，value 是我们需要的值。
在 Thread 中持有一个 Map，key 是 ThreadLocal，value 是我们需要的值。
Java 使用的是第二种思路，理由是：
数据亲缘性：ThreadLocal 只是一个工具类，内部不应该存储与线程相关的数据，与线程相关的数据应该放在 Thread 里面。
不容易产生内存泄漏：ThreadLocal 的生命周期往往比线程长，若数据放在 ThreadLocal中，就算 Thread 已经销毁了，相关的数据也不会被回收；若数据放在 Thread 中，Thread 对象可以被回收，那么 ThreadLocalMap 也可以被回收了。
下面是 Java 1.11 精简后的代码：
public class Thread implements Runnable {
ThreadLocal.ThreadLocalMap threadLocals = null;
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
public Thread() {
// inheritableThreadLocals 的逻辑
// 若创建线程的线程存在 inheritableThreadLocals，则通过复制继承
Thread parent = currentThread();
if (parent.inheritableThreadLocals != null)
this.inheritableThreadLocals =
ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
}
}
// java.lang.ThreadLocal.java
public class ThreadLocal<T> {
static class ThreadLocalMap {
static class Entry extends WeakReference<ThreadLocal<?>> {
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
private Entry[] table;
private Entry getEntry(ThreadLocal<?> key) {}
private void set(ThreadLocal<?> key, Object value) {}
}
public T get() {
ThreadLocalMap map = getMap(Thread.currentThread());
...
}
public void set(T value) {
ThreadLocalMap map = getMap(Thread.currentThread());
...
}
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null) {
m.remove(this);
}
}
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
}
注意事项
内存泄漏
上文提到 Java 设计成 Thread 持有 ThreadLocal 数据的原因之一是不容易产生内存泄漏，但是在某些情况下还是会有内存泄漏的问题。
比如在线程池中使用 ThreadLocal。线程池中的线程存活时间很长，往往与程序的生命周期一致，所以 Thread 持有的 ThreadLocalMap 一直不会被回收。尽管 ThreadLocalMap 中的 Entry 对 ThreadLocal 是弱引用的，只要 ThreadLocal 自己的生命周期结束就可以被回收，但是 Entry 中的 Value 是强引用，所以尽管 Value 的生命周期结束了，也不会被回收，导致内存泄漏。
解决方案：手动释放，比如通过 try-finally。
ThreadLocal tl;
tl.set(obj);
try {
...
} finally {
tl.remove();
}
InheritableThreadLocal
ThreadLocal 创建的线程变量，子线程是无法继承的，也就是说你在线程 A 中创建了 ThreadLocal V，然后又在线程 A 中创建了线程 B，但是在线程 B 中无法访问到 V。
Java 提供了 InheritableThreadLocal 来支持这种需求。
public class InheritableThreadLocal<T> extends ThreadLocal<T> {
protected T childValue(T parentValue) {
return parentValue;
}
ThreadLocalMap getMap(Thread t) {
return t.inheritableThreadLocals;
}
void createMap(Thread t, T firstValue) {
t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
}
}
