ThreadLocal是线程私有变量，本身是解决多线程环境线程安全，可以说单线程实际上没必要使用。

既然多线程环境本身不使用static，那么又怎么会线程不安全。所以这个问题本身并不是问题，只是有人没有理解ThreadLocal的真正使用场景，所以有此疑问。

看看jdk源码推荐ThreadLocal使用static吧：

/**
* This class provides thread-local variables.  These variables differ from
* their normal counterparts in that each thread that accesses one (via its
* {@code get} or {@code set} method) has its own, independently initialized
* copy of the variable.  {@code ThreadLocal} instances are typically private
* static fields in classes that wish to associate state with a thread (e.g.,
* a user ID or Transaction ID).
*
* <p>For example, the class below generates unique identifiers local to each
* thread.
* A thread's id is assigned the first time it invokes {@code ThreadId.get()}
* and remains unchanged on subsequent calls.
* <pre>
* import java.util.concurrent.atomic.AtomicInteger;
*
* public class ThreadId {
*     // Atomic integer containing the next thread ID to be assigned
*     private static final AtomicInteger nextId = new AtomicInteger(0);
*
*     // Thread local variable containing each thread's ID
*     private static final ThreadLocal&lt;Integer&gt; threadId =
*         new ThreadLocal&lt;Integer&gt;() {
*             &#64;Override protected Integer initialValue() {
*                 return nextId.getAndIncrement();
*         }
*     };
*
*     // Returns the current thread's unique ID, assigning it if necessary
*     public static int get() {
*         return threadId.get();
*     }
* }
* </pre>
* <p>Each thread holds an implicit reference to its copy of a thread-local
* variable as long as the thread is alive and the {@code ThreadLocal}
* instance is accessible; after a thread goes away, all of its copies of
* thread-local instances are subject to garbage collection (unless other
* references to these copies exist).
*
* @author  Josh Bloch and Doug Lea
* @since   1.2
*/
public class ThreadLocal<T> {
/**
* ThreadLocals rely on per-thread linear-probe hash maps attached
* to each thread (Thread.threadLocals and
* inheritableThreadLocals).  The ThreadLocal objects act as keys,
* searched via threadLocalHashCode.  This is a custom hash code
* (useful only within ThreadLocalMaps) that eliminates collisions
* in the common case where consecutively constructed ThreadLocals
* are used by the same threads, while remaining well-behaved in
* less common cases.
*/

这个是Josh Bloch和Doug Lea写的，再看看他们的著作：《Java并发编程实战》

再看看jdk中的官方文档： 

已经说的很明白了，再看看其他答案吧：

按照ThreadLocal类的定义

此类提供线程局部变量。这些变量与普通变量不同，每个访问一个线程（通过其get或set方法）的线程都有其自己的，独立初始化的变量副本。ThreadLocal实例通常是希望将状态与线程关联的类中的私有静态字段（例如，用户ID或事务ID）。

这意味着说2个线程t1并t2执行someBMethod()，它们分别结束设置x1＆x2（的实例X）。现在，当t1come并执行时，someCMethod()它会获取x1（它是由它自己设置的）和gets 。t2x2

换句话说，只有一个静态实例是安全的ThreadLocal，因为在内部调用时它会执行类似的操作set

Java 源代码，

1. java.lang.Thread Class包含一个实例变量，如下所示。

   ThreadLocal.ThreadLocalMap threadLocals = null;

因为threadLocals变量是非静态的，所以应用程序中的每个线程（即Thread Class的每个实例）将拥有它自己的threadLocals映射副本。

1. 该映射的键是当前 ThreadLocal实例，而value是您作为参数传递给ThreadLocal.set（）的值。

2. 当您尝试在内部获取 as值时ThreadLocal.get()，它将从Current Thread的ThreadLocalMap获取。

简而言之，您是从当前线程对象获取＆设置值，而不是从ThreadLocal对象获取＆设置值。