ThreadLocal类详解：原理、源码、用法

以下是本文目录：

　　1、从数据库连接探究 ThreadLocal

　　2、剖析 ThreadLocal 源码

　　3、 ThreadLocal 应用场景

　　4、 通过面试题理解 ThreadLocal

---

1、从数据库连接探究 ThreadLocal

先看一个数据库连接的例子：

class ConnectionManager{
    private static Connection conn = null;
 
    public static Connection openConnection(){
        if(conn == null){
            conn = DriverManager.getConnection();
        }
        return conn;
    }
 
    public static void closeConnection(){
        if(conn != null) conn.close();
    }
}

在多线程环境下，上述代码有如下两个线程安全问题：1. 两个方法没有同步，可能会多次创建 conn。2. conn 是共享变量，可能一个线程用 conn 进行数据库操作的同时，另一个线程，关闭 conn。

关于解决上述问题，首先想到的可能是进行同步处理：对两个方法进行同步，并且在调用 conn 的地方进行同步。这样会大大影响程序执行效率，因为一个线程在使用connect进行数据库操作的时候，其他线程只有等待。

那么大家来仔细分析一下这个问题，这地方到底需不需要将connect变量进行共享？事实上，是不需要的。假如每个线程中都有一个connect变量，各个线程之间对connect变量的访问实际上是没有依赖关系的，即一个线程不需要关心其他线程是否对这个connect进行了修改的。

到这里，可能会有朋友想到，既然不需要在线程之间共享这个变量，可以直接这样处理，在每个需要使用数据库连接的方法中具体使用时才创建数据库链接，然后在方法调用完毕再释放这个连接。比如下面这样：

class ConnectionManager {
     
    private  Connection connect = null;
     
    public Connection openConnection() {
        if(connect == null){
            connect = DriverManager.getConnection();
        }
        return connect;
    }
     
    public void closeConnection() {
        if(connect!=null)
            connect.close();
    }
}
 
 
class Dao{
    public void insert() {
        ConnectionManager connectionManager = new ConnectionManager();
        Connection connection = connectionManager.openConnection();
         
        //使用connection进行操作
         
        connectionManager.closeConnection();
    }
}

这样处理确实也没有任何问题，由于每次都是在方法内部创建的连接，那么线程之间自然不存在线程安全问题，这里使用了栈封闭。但是这样会有一个致命的影响：导致服务器压力非常大，并且严重影响程序执行性能。由于在方法中需要频繁地开启和关闭数据库连接，这样不仅严重影响程序执行效率，还可能导致服务器压力巨大。

那么这种情况下使用ThreadLocal是再适合不过的了，因为ThreadLocal在每个线程中对该变量会创建一个副本，即每个线程内部都会有一个该变量，且在线程内部任何地方都可以使用，线程之间互不影响，这样一来就不存在线程安全问题，也不会严重影响程序执行性能。

但是要注意，虽然ThreadLocal能够解决上面说的问题，但是由于在每个线程中都创建了副本，所以要考虑它对资源的消耗，比如内存的占用会比不使用ThreadLocal要大。

---

2、剖析 ThreadLocal 源码

剖析源码前，先关注几个方法：

public T get(){}    //获取当前线程中保存的变量副本
public void set(T value){}    // 设置变量副本
protected T initialValue(){}    // 在 ThreadLocal 中返回值为空，此处用来被重写
public void remove(){}    // 移除当前线程中的变量副本

在不重写 initialVale() 方法的情况下，进行 get() 之前，必须先 set()，否则返回空值。这里先看一下 set() 方法的实现：

  /**
      * Sets the current thread's copy of this thread-local variable
      * to the specified value.  Most subclasses will have no need to
      * override this method, relying solely on the {@link #initialValue}
      * method to set the values of thread-locals.
      *
      * @param value the value to be stored in the current thread's copy of
      *        this thread-local.
      */
     public void set(T value) {
         Thread t = Thread.currentThread();
         ThreadLocalMap map = getMap(t);
         if (map != null)
             map.set(this, value);
         else
             createMap(t, value);
     }

第一句是取得当前线程的对象，然后通过 getMap(t) 方法获取到一个 map，该 map 为 ThreadLocalMap(ThreadLocal内部类) 类型。然后判断 map 是否为空，如果不为空则将 value值 set 进 map , 注意这里传进去的是 this 而不是当前线程对象 t；如果 map 为空，则创建一个 map， 注意这里用的是 t .下面仔细分析

从第11行，首先调用  Thread.currentThread() 获取当前正在执行线程对象的引用。下面是 Thread.currentThread() 的实现：

/**
     * Returns a reference to the currently executing thread object.
     *
     * @return  the currently executing thread.
     */
    public static native Thread currentThread();

这里 native 代表本地代码，用其它语言写的编译成对应平台机器码的代码。该调用返回一个当前执行线程对象的引用。"t" 是当前执行线程的对象。

然后通过 getMap(t) 获取 map,让我们看一下 getMap() 中做了什么:

 /**
     * Get the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param  t the current thread
     * @return the map
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

在 getMap() 方法中返回当前线程 t 中的一个成员变量，"threadLocals"。那么我们继续取Thread类中取看一下成员变量threadLocals是什么：

/* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;

实际上就是一个ThreadLocalMap，这个类型是ThreadLocal类的一个内部类。

当 map 不为空时就将 当前线程对象的引用,value值 作为键值对set进map，保证了每一个线程对象对应一个 value。

当 map 为空时调用 createMap(), 让我们看一下它是如何实现的：

  /**
     * Create the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param t the current thread
     * @param firstValue value for the initial entry of the map
     */
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

将 当前线程t和传入的值firstValue 作为参数创建 ThreadLocalMap 的对象，赋值给 threadLocals 变量。

至此，可能大部分朋友已经明白了ThreadLocal是如何为每个线程创建变量的副本的：

首先，在每个线程Thread内部有一个ThreadLocal.ThreadLocalMap类型的成员变量threadLocals，这个threadLocals就是用来存储实际的变量副本的，键值为当前ThreadLocal变量，value为变量副本（即T类型的变量）。

初始时，在Thread里面，threadLocals为空，当通过ThreadLocal变量调用set()方法，就会对Thread类中的threadLocals进行初始化，并且以当前ThreadLocal变量为键值，以ThreadLocal要保存的副本变量为value，存到threadLocals。

然后在当前线程里面，如果要使用副本变量，就可以通过get()方法在threadLocals里面查找。

下面介绍 get() 方法：

     /**
      * Returns the value in the current thread's copy of this
      * thread-local variable.  If the variable has no value for the
      * current thread, it is first initialized to the value returned
      * by an invocation of the {@link #initialValue} method.
      *
      * @return the current thread's value of this thread-local
      */
     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();
     }

前两行和set()方法一样，获取到一个 map 对象, 判断该对象是否为空。当该对象为空时调用 setInitialValue() 方法，该方法返回一个 value 值。下面是 setInitialValue() 方法的具体实现：

 /**
     * Variant of set() to establish initialValue. Used instead
     * of set() in case user has overridden the set() method.
     *
     * @return the initial value
     */
    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;
    }

考虑到set() 方法由可能被重写，这里用了 set() 方法的变体。方法中首先调用 initialValue() 方法初始化一个 value。下面看一下 initialValue() 方法的实现：

 /**
     * Returns the current thread's "initial value" for this
     * thread-local variable.  This method will be invoked the first
     * time a thread accesses the variable with the {@link #get}
     * method, unless the thread previously invoked the {@link #set}
     * method, in which case the {@code initialValue} method will not
     * be invoked for the thread.  Normally, this method is invoked at
     * most once per thread, but it may be invoked again in case of
     * subsequent invocations of {@link #remove} followed by {@link #get}.
     *
     * <p>This implementation simply returns {@code null}; if the
     * programmer desires thread-local variables to have an initial
     * value other than {@code null}, {@code ThreadLocal} must be
     * subclassed, and this method overridden.  Typically, an
     * anonymous inner class will be used.
     *
     * @return the initial value for this thread-local
     */
    protected T initialValue() {
        return null;
    }

这里 initialValue() 方法为 protected 权限，当子类继承该类时，可以重写该方法。在该类中，该方法返回值为 null。回到  setInitialValue() 方法.在setInitialValue() 方法中，接下来仍是获取一个 map 并判断是否为空，传入的 value 值均为 initialVale() 方法中获取的值，然后 返回 value。

当 get() 方法中的 map 值不为空时返回一个 Entry 下面是 Entry 的具体实现：

  static class ThreadLocalMap {
 
        /**
         * The entries in this hash map extend WeakReference, using
         * its main ref field as the key (which is always a
         * ThreadLocal object).  Note that null keys (i.e. entry.get()
         * == null) mean that the key is no longer referenced, so the
         * entry can be expunged from table.  Such entries are referred to
         * as "stale entries" in the code that follows.
         */
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;
 
            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }

可以看到ThreadLocalMap的Entry继承了WeakReference，并且使用ThreadLocal作为键值。

下面是 remove() 方法的源码：

  /**
     * Removes the current thread's value for this thread-local
     * variable.  If this thread-local variable is subsequently
     * {@linkplain #get read} by the current thread, its value will be
     * reinitialized by invoking its {@link #initialValue} method,
     * unless its value is {@linkplain #set set} by the current thread
     * in the interim.  This may result in multiple invocations of the
     * {@code initialValue} method in the current thread.
     *
     * @since 1.5
     */
     public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

可以看到就是在获取当前线程的对象作为键值，然后 remove。

---

3.ThreadLocal的应用场景

最常见的ThreadLocal使用场景为 用来解决 数据库连接、Session管理等。

如：

private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>() {
public Connection initialValue() {
    return DriverManager.getConnection(DB_URL);
}
};
 
public static Connection getConnection() {
return connectionHolder.get();
}

及

private static final ThreadLocal threadSession = new ThreadLocal();
 
public static Session getSession() throws InfrastructureException {
    Session s = (Session) threadSession.get();
    try {
        if (s == null) {
            s = getSessionFactory().openSession();
            threadSession.set(s);
        }
    } catch (HibernateException ex) {
        throw new InfrastructureException(ex);
    }
    return s;
}

---

4. 相关面试题

1、每个线程的变量副本是存储在哪里的？

最关键的问题是：ThreadLocal是怎么实现了多个线程之间每个线程一个变量副本的？它是如何实现共享变量的。

ThreadLocal提供了set和get访问器用来访问与当前线程相关联的线程局部变量。

可以从ThreadLocal的get函数中看出来，其中getmap函数是用t作为参数，这里t就是当前执行的线程。

从而得知，get函数就是从当前线程的threadlocalmap中取出当前线程对应的变量的副本【注意，变量是保存在线程中的，而不是保存在ThreadLocal变量中】。当前线程中，有一个变量引用名字是threadLocals，这个引用是在ThreadLocal类中createmap函数内初始化的。每个线程都有一个这样的threadLocals引用的ThreadLocalMap，以ThreadLocal和ThreadLocal对象声明的变量类型作为参数。这样，我们所使用的ThreadLocal变量的实际数据，通过get函数取值的时候，就是通过取出Thread中threadLocals引用的map，然后从这个map中根据当前threadLocal作为参数，取出数据。现在，变量的副本从哪里取出来的（本文章提出的第一个问题）已经确认解决了。

【ThreadLocal整体上给我的感觉就是，一个包装类。声明了这个类的对象之后，每个线程的数据其实还是在自己线程内部通过threadLocals引用到的自己的数据。只是通过ThreadLocal访问这个数据而已】

2、变量副本是怎么从共享的那个变量赋值出来的？源码中的threadlocal的初始值是什么时机设置的？

这里“复制”两个字用的很不专业。准确的说，应该是，变量副本【每个线程中保存的那个map中的变量】是怎么声明和初始化的？

看下面set函数的源码：

当线程中的threadlocalmap是null的时候，会调用createmap创建一个map。同时根据函数参数设置上初始值。也就是说，当前线程的threadlocalmap是在第一次调用set的时候创建map并且设置上相应的值的。

对于这篇文章中的例子，每个线程打印的东西都是相互独立的，是因为SequenceNumber的getNextNum()函数中先set了一个值，再get。写到这里，终于清楚了ThreadLocal的运作方法了。

解释如下：

1）在代码中声明的ThreadLocal对象，实际上只有一个。

2）在每个线程中，都维护了一个threadlocals对象，在没有ThreadLocal变量的时候是null的。一旦在ThreadLocal的createMap函数中初始化之后，这个threadlocals就初始化了。以后每次那个ThreadLocal对象想要访问变量的时候，比如set函数和get函数，都是先通过getMap(t)函数，先将线程的map取出，然后再从这个在线程（Thread）中维护的map中取出数据【以当前threadlocal作为参数】。

到此，第二个问题也解决了。

3、不同的线程局部变量，比如说声明了n个(n>=2)这样的线程局部变量threadlocal，那么在Thread中的threadlocals中是怎么存储的呢？threadlocalmap中是怎么操作的？

在ThreadLocal的set函数中，可以看到，其中的map.set(this, value);把当前的threadlocal传入到map中作为键，也就是说，在不同的线程的threadlocals变量中，都会有一个以你所声明的那个线程局部变量threadlocal作为键的key-value。假设说声明了N个这样的线程局部变量变量，那么在线程的ThreadLocalMap中就会有n个分别以你的线程局部变量作为key的键值对。

参考：深入剖析ThreadLocal  ThreadLocal工作原理