Java源码：ThreadLocal

一、个人见解

通俗来说，实例变量就是在每个具体实例对象级别的变量，类变量（静态变量）就是在类级别的变量，类似的，线程本地变量就是在线程级别存放的变量，而ThreadLocal就是用来提供线程本地变量存取的工具。在网上各种搜，结合自己的理解，觉得ThreadLocal适合用户以下场景（纯属个人见解，有不对地方或有更好的使用场景请赐教哈）：

1. 访问线程不安全对象。比如下面SimpleDateFormat的使用，这是个线程不安全的类，不想每次都new一个对象用完即弃？把它放进ThreadLocal里吧，这样每个线程就只拥有一个实例了。
2. 存放线程级别的状态对象。例如上下文对象、用户会话这种对象，不想在各个方法调用中层层传递？把它放进ThreadLocal里面把，这样在同一个线程任何一个地方都可以获取。

 二、示例

ThreadLocal的使用比较简单，创建一个ThreadLocal对象，重写initialValue方法，返回需要存储的变量，并且把这个ThreadLocal对象声明为静态的（因为后续读取线程本地变量的时候需要用这个ThreadLocal对象），需要使用的时候只要调用ThreadLocal对象的get方法就行了：

public class ThreadLocalTest {

    public static void main(String[] args) throws InterruptedException {
        new MyThread().start();
        Thread.sleep(2000);
        new MyThread().start();
    }

}

class MyThread extends Thread {
    //SimpleDateFormat为线程不安全的，因此使用ThreadLocal在每个线程保存一个实例
    public static final ThreadLocal<SimpleDateFormat> DATE_FORMATER = new ThreadLocal<SimpleDateFormat>() {
        @Override
        protected SimpleDateFormat initialValue() {
            return new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        }
    };

    //模拟放入一个上下文对象，可以在当前线程内进行读写
    public static final ThreadLocal<Map<String, String>> CONTEXT = new ThreadLocal<Map<String, String>>() {
        @Override
        protected Map<String, String> initialValue() {
            return new HashMap<String, String>();
        }
    };

    @Override
    public void run() {
        CONTEXT.get().put("id", "Thread_" + System.currentTimeMillis());
        try {
            while (true) {
                String id = CONTEXT.get().get("id");
                System.out.println(id + ": " + DATE_FORMATER.get().format(new Date()));
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

 

  三、源码

1. 首先看Thread类，每个Thread都有一个变量threadLocals，存放所有对应这个线程的ThreadLocal。他的类型是ThreadLocal.ThreadLocalMap，其实就相当与一个特殊的Map，Key是ThreadLocal对象，value就是我们需要存放的线程本地变量，这里就不对这个对象深入研究了。

   public class Thread implements Runnable {
   
       /* ThreadLocal values pertaining to this thread. This map is maintained
        * by the ThreadLocal class. */
       ThreadLocal.ThreadLocalMap threadLocals = null;
       
       /* ...... */
   }

    
2. 回到ThreadLocal，看看用来获取保存的线程本地变量的get方法，其实操作的是当前线程的threadLocals：

       public T get() {
           //获取当前线程
           Thread t = Thread.currentThread();
           //把线程的threadLocals变量拿出来
           ThreadLocalMap map = getMap(t);
           if (map != null) {
               //通过ThreadLocal对象自身作为key去拿出Entry
               ThreadLocalMap.Entry e = map.getEntry(this);
               if (e != null)
                   //找到了，就把值返回
                   return (T)e.value;
           }
           //如果threadLocals变量为空，则需要初始化
           return setInitialValue();

    
3. 在get方法的最后，调用了setInitialValue()，继续看看源码：

   private T setInitialValue() {
       //调用initialValue方法获取初始值，这就是为什么我们创建ThreadLocal
       //对象的时候需要重写这个方法来提供我们需要保存的值
       T value = initialValue();
       //获取当前线程
       Thread t = Thread.currentThread();
       //获取线程里面的threadLocals对象
       ThreadLocalMap map = getMap(t);
       if (map != null)
           //把当前ThreadLocal对象作为key，初始值作为value，放进去
           map.set(this, value);
       else
           //如果这个属性为空，则初始化并把相应的值放进去
           createMap(t, value);
       return value;
   }

    
4. 有get就要有set，理解了setInitialValue，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);

 四、InheritableThreadLocal

看完了ThreadLocal，其实Java还提供了一个能实现类似功能的类：InheritableThreadLocal。两者的区别是：使用InheritableThreadLocal保存线程本地变量的话，能被子线程共享。打开Thread类的构造方法，在它调用的init方法里面有下面一段代码：

if (parent.inheritableThreadLocals != null)
    this.inheritableThreadLocals =
            ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);

 恩，没错，其实就是在父线程创建子线程的时候，把inheritableThreadLocals变量的值全部复制给子线程。