本文共 7741 字，大约阅读时间需要 25 分钟。

转：http://www.iteye.com/topic/103804

首先，ThreadLocal 不是用来解决共享对象的多线程访问问题的，一般情况下，通过ThreadLocal.set() 到线程中的对象是该线程自己使用的对象，其他线程是不需要访问的，也访问不到的。各个线程中访问的是不同的对象。 

另外，说ThreadLocal使得各线程能够保持各自独立的一个对象，并不是通过ThreadLocal.set()来实现的，而是通过每个线程中的new 对象 的操作来创建的对象，每个线程创建一个，不是什么对象的拷贝或副本。通过ThreadLocal.set()将这个新创建的对象的引用保存到各线程的自己的一个map中，每个线程都有这样一个map，执行ThreadLocal.get()时，各线程从自己的map中取出放进去的对象，因此取出来的是各自自己线程中的对象，ThreadLocal实例是作为map的key来使用的。 

如果ThreadLocal.set()进去的东西本来就是多个线程共享的同一个对象，那么多个线程的ThreadLocal.get()取得的还是这个共享对象本身，还是有并发访问问题。 

下面来看一个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;    }

public class ThreadLocal
   
     {    /**     * 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 {    ........    }}
   

private final int threadLocalHashCode = nextHashCode();    private static int nextHashCode = 0;    private static final int HASH_INCREMENT = 0x61c88647;

private final int threadLocalHashCode = nextHashCode();

private static synchronized int nextHashCode() {        int h = nextHashCode;        nextHashCode = h + HASH_INCREMENT;        return h;    }

ThreadLocalMap map = Thread.currentThread().threadLocals;

这个ThreadLocalMap 类是ThreadLocal中定义的内部类，但是它的实例却用在Thread类中： 

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

if (map != null)            map.set(this, value);

转载地址：https://blog.csdn.net/wxwzy738/article/details/42194285 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！