ThreadLocal原理及使用场合

ThreadLocal<T>类在Spring，Hibernate等框架中起到了很大的作用，所以对它的原理分析是非常重要的。

      先贴一下源码（JDK1.7）

public class ThreadLocal<T> {

    /* Thanks to Josh Bloch and Doug Lea for code reviews and impl advice. */

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

    /**
     * Returns the value of this variable for the current thread. If an entry
     * doesn't yet exist for this variable on this thread, this method will
     * create an entry, populating the value with the result of
     * {@link #initialValue()}.
     *
     * @return the current value of the variable for the calling thread.
     */
    @SuppressWarnings("unchecked")
    public T get() {
        // Optimized for the fast path.
        Thread currentThread = Thread.currentThread();
        Values values = values(currentThread);
        if (values != null) {
            Object[] table = values.table;
            int index = hash & values.mask;
            if (this.reference == table[index]) {
                return (T) table[index + 1];
            }
        } else {
            values = initializeValues(currentThread);
        }

        return (T) values.getAfterMiss(this);
    }

    /**
     * Provides the initial value of this variable for the current thread.
     * The default implementation returns {@code null}.
     *
     * @return the initial value of the variable.
     */
    protected T initialValue() {
        return null;
    }

    /**
     * Sets the value of this variable for the current thread. If set to
     * {@code null}, the value will be set to null and the underlying entry will
     * still be present.
     *
     * @param value the new value of the variable for the caller thread.
     */
    public void set(T value) {
        Thread currentThread = Thread.currentThread();
        Values values = values(currentThread);
        if (values == null) {
            values = initializeValues(currentThread);
        }
        values.put(this, value);
    }

    /**
     * Removes the entry for this variable in the current thread. If this call
     * is followed by a {@link #get()} before a {@link #set},
     * {@code #get()} will call {@link #initialValue()} and create a new
     * entry with the resulting value.
     *
     * @since 1.5
     */
    public void remove() {
        Thread currentThread = Thread.currentThread();
        Values values = values(currentThread);
        if (values != null) {
            values.remove(this);
        }
    }

    /**
     * Creates Values instance for this thread and variable type.
     */
    Values initializeValues(Thread current) {
        return current.localValues = new Values();
    }

    /**
     * Gets Values instance for this thread and variable type.
     */
    Values values(Thread current) {
        return current.localValues;
    }
   ……
}

          可以看到ThreadLocal类中没有任何实例变量，那么它的get()和set()方法所操作的数据是哪里来的呢？

        其实它的get()以及set()方法都调用到了下面这方法

 Values values(Thread current) {
        return current.localValues;
    }

           也就是说它的get()和set()方法所操作的对象是当前线程的局部变量，这显然是不会产生任何线程不安全的问题。所以ThreadLocal最适合的应用场合应该是按线程多实例（每个线程对应一个实例）的对象的访问。

下面来看一个hibernate中典型的ThreadLocal的应用：

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