JAVA里ThreadLocal的使用与分析

最近看了很多ThreadLocal的文章，各种观点都有，最后在开源中国看到一篇自认为讲得不错的。链接如下http://my.oschina.net/lichhao/blog/111362?p=4#comments，在评论区里讲到TLS(Thread Local Storage)，这是Linux系统里使用的概念，JAVA的ThreadLocal就是借鉴了这个想法，其意是保存在各自线程里的上下文/环境，能够在当前线程中“全局”使用，又和其他线程独立开，因为这种功能是局部变量（只能在函数中使用），全局变量（各线程中都能共享使用）都做不到的，所以这就出现了TLS的概念。从名字也可以看出，这里的Thread Local，目的就是在当前线程中使用，而不是为了什么线程安全和并发错误。这就是说，我们在ThreadLocal里保存的对象，必须是线程局部的，而如果是各线程间共享的，这就没了意义，因为通过源码分析我们可以清楚的看到，线程间隔离是通过ThreadLocalMap来隔离的，而Map里存的明显是对象的引用，如果是线程间共享的资源放到里面，无论我们放不放到ThreadLocal里面，都会产生并发问题，这就需要同步机制Synchronized来解决。而对于ThreadLocal，有一个非常常见的应用就是在Spring里Connection的管理

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
 
public class ConnectionManager {
 
    private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>() {
        @Override
        protected Connection initialValue() {
            Connection conn = null;
            try {
                conn = DriverManager.getConnection(
                        "jdbc:mysql://localhost:3306/test", "username",
                        "password");
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return conn;
        }
    };
 
    public static Connection getConnection() {
        return connectionHolder.get();
    }
 
    public static void setConnection(Connection conn) {
        connectionHolder.set(conn);
    }
}

通过调用ConnectionManager.getConnection()方法，每个线程获取到的，都是和当前线程绑定的那个Connection对象，第一次获取时，是通过initialValue()方法的返回值来设置值的。通过ConnectionManager.setConnection(Connection conn)方法设置的Connection对象，也只会和当前线程绑定。这样就实现了Connection对象在多个线程中的完全隔离。在Spring容器中管理多线程环境下的Connection对象时，采用的思路和以上代码非常相似。

这里之所以能实现隔离，是因为我们可以在每个线程新建一个connection并放入ConnectionManager，ConnectionHolder虽然是static的，但是我们每个线程的ThreadLocalMap是不同的（Thread在创建在之初会将该变量设为null），各个Map里放入的Connection也是不同的，所以我们能从各个线程里通过共享的ConnectionHolder来得到不同的Connection，这才是隔离的本质。对于全局共享一个变量的并发问题，ThreadLocal并不能处理。

下面放上ThreadLocal的实现代码：

public class ThreadLocal<T> {
    /**
     * ThreadLocals rely on per-thread 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.
     */
    private final int threadLocalHashCode = nextHashCode();

    /**
     * The next hash code to be given out. Accessed only by like-named method.
     */
    private static int nextHashCode = 0;

    /**
     * The difference between successively generated hash codes - turns
     * implicit sequential thread-local IDs into near-optimally spread
     * multiplicative hash values for power-of-two-sized tables.
     */
    private static final int HASH_INCREMENT = 0x61c88647;

    /**
     * Compute the next hash code. The static synchronization used here
     * should not be a performance bottleneck. When ThreadLocals are
     * generated in different threads at a fast enough rate to regularly
     * contend on this lock, memory contention is by far a more serious
     * problem than lock contention.
     */
    private static synchronized int nextHashCode() {
        int h = nextHashCode;
        nextHashCode = h + HASH_INCREMENT;
        return h;
    }

    /**
     * Creates a thread local variable.
     */
    public ThreadLocal() {
    }

    /**
     * Returns the value in the current thread's copy of this thread-local
     * variable.  Creates and initializes the copy if this is the first time
     * the thread has called this 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)
            return (T)map.get(this);

        // Maps are constructed lazily.  if the map for this thread
        // doesn't exist, create it, with this ThreadLocal and its
        // initial value as its only entry.
        T value = initialValue();
        createMap(t, value);
        return value;
    }

    /**
     * Sets the current thread's copy of this thread-local variable
     * to the specified value.  Many applications will have no need for
     * this functionality, relying solely on the {@link #initialValue}
     * method to set the values of thread-locals.
     *
     * @param value the value to be stored in the current threads' 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);
    }

    /**
     * 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;
    }

    /**
     * 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
     * @param map the map to store.
     */
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

    .......

    /**
     * ThreadLocalMap is a customized hash map suitable only for
     * maintaining thread local values. No operations are exported
     * outside of the ThreadLocal class. The class is package private to
     * allow declaration of fields in class Thread.  To help deal with
     * very large and long-lived usages, the hash table entries use
     * WeakReferences for keys. However, since reference queues are not
     * used, stale entries are guaranteed to be removed only when
     * the table starts running out of space.
     */
    static class ThreadLocalMap {

    ........

    }

}