ThreadLocal 详解

 ThreadLocal-分析-总结

博客分类：
• Thread

多线程thread面试SpringHibernate

ThreadLocal<T>类在Spring，Hibernate等框架中起到了很大的作用，对于其工作原理，很多网上的文章分析的不够彻底，甚至有些误解。

首先，为了解释ThreadLocal类的工作原理，必须同时介绍与其工作甚密的其他几个类（内部类）

1.ThreadLocalMap

2.Thread

可能有人会觉得Thread与ThreadLocal有什么关系，其实真正的奥秘就在Thread类中的一行：

Java代码

1. ThreadLocal.ThreadLocalMap threadLocals = null; 

ThreadLocal.ThreadLocalMap threadLocals = null;

其中ThreadLocalMap的定义是在ThreadLocal类中，真正的引用却是在Thread类中

那么ThreadLocalMap究竟是什么呢？

可以看到这个类应该是一个Map,JDK的解释是

写道

ThreadLocalMap is a customized hash map suitable only for maintaining thread local values

接下来的重点是ThreadLocalMap中用于存储数据的entry

Java代码

1. static class Entryextends WeakReference<ThreadLocal> { 
2.             /** The value associated with this ThreadLocal. */ 
3.             Object value; 
4.  
5.             Entry(ThreadLocal k, Object v) { 
6.                 super(k); 
7.                 value = v; 
8.             } 
9.         } 

static class Entry extends WeakReference<ThreadLocal> {            /** The value associated with this ThreadLocal. */            Object value;            Entry(ThreadLocal k, Object v) {                super(k);                value = v;            }        }

从中我们可以发现这个Map的key是ThreadLocal变量，value为用户的值，并不是网上大多数的列子key是线程的名字或者标识

到这里，我们就可以理解ThreadLocal究竟是如何工作的了

1.Thread类中有一个成员变量叫做ThreadLocalMap，它是一个Map，他的Key是ThreadLocal类

2.每个线程拥有自己的申明为ThreadLocal类型的变量,所以这个类的名字叫'ThreadLocal'：线程自己的（变量）

3.此变量生命周期是由该线程决定的，开始于第一次初始（get或者set方法）

4.由ThreadLocal的工作原理决定了：每个线程独自拥有一个变量，并非共享或者拷贝

Java代码

1. /**
2. * @author mxdba
3. *
4. */ 
5. public class ThreadLocalSample { 
6.  
7.     public staticvoid main(String[] args) { 
8.         ThreadTest test1 = new ThreadTest(10); 
9.         ThreadTest test2 = new ThreadTest(20); 
10.         test1.start(); 
11.         test2.start(); 
12.     } 
13.  
14. } 
15.  
16. /**
17. * 此线程有两个ThreadLocal变量，但是由于ThreadLocal是延迟初始的，
18. * 所以在debug时可以看到线程名为“线程20”的线程的ThreadLocalMap中没有thLcal2这个entry
19. * @author mxdba
20. *
21. */ 
22. class ThreadTest extends Thread { 
23.      
24.     public static ThreadLocal<Integer> thLocal =new ThreadLocal<Integer>(); 
25.     public static ThreadLocal<String> thLocal2 =new ThreadLocal<String>(); 
26.      
27.     public Integer num; 
28.      
29.      
30.      
31.     public ThreadTest(Integer num) { 
32.         super("线程" + num); 
33.         this.num = num; 
34.     } 
35.  
36.     @Override 
37.     public void run() { 
38.         Integer n = thLocal.get(); 
39.         if(num != 20) { 
40.             String s = thLocal2.get(); 
41.         } 
42.              
43.         if(n == null) { 
44.             thLocal.set(num); 
45.         } 
46.         System.out.println(thLocal.get()); 
47.     } 
48.      
49. } 

/** * @author mxdba * */public class ThreadLocalSample {public static void main(String[] args) {ThreadTest test1 = new ThreadTest(10);ThreadTest test2 = new ThreadTest(20);test1.start();test2.start();}}/** * 此线程有两个ThreadLocal变量，但是由于ThreadLocal是延迟初始的， * 所以在debug时可以看到线程名为“线程20”的线程的ThreadLocalMap中没有thLcal2这个entry * @author mxdba *  */class ThreadTest extends Thread {public static ThreadLocal<Integer> thLocal = new ThreadLocal<Integer>();public static ThreadLocal<String> thLocal2 = new ThreadLocal<String>();public Integer num;public ThreadTest(Integer num) {super("线程" + num);this.num = num;}@Overridepublic void run() {Integer n = thLocal.get();if(num != 20) {String s = thLocal2.get();}if(n == null) {thLocal.set(num);}System.out.println(thLocal.get());}}

接下来分析一下源码，就更加清楚了

关键方法代码

1. /** 
2. * 关键方法，返回当前Thread的ThreadLocalMap 
3. * [[[每个Thread返回各自的ThreadLocalMap，所以各个线程中的ThreadLocal均为独立的]]] 
4. */ 
5. ThreadLocalMap getMap(Thread t) { 
6.         return t.threadLocals; 
7.     } 

/** * 关键方法，返回当前Thread的ThreadLocalMap * [[[每个Thread返回各自的ThreadLocalMap，所以各个线程中的ThreadLocal均为独立的]]] */ThreadLocalMap getMap(Thread t) {        return t.threadLocals;    }

Threadlocal的get方法代码

1. public T get() { 
2.         Thread t = Thread.currentThread(); 
3.         /** 
4.          * 得到当前线程的ThreadLocalMap 
5.          */ 
6.         ThreadLocalMap map = getMap(t); 
7.         if (map != null) { 
8.             /** 
9.              * 在此线程的ThreadLocalMap中查找key为当前ThreadLocal对象的entry 
10.              */ 
11.             ThreadLocalMap.Entry e = map.getEntry(this); 
12.             if (e != null) 
13.                 return (T)e.value; 
14.         } 
15.         return setInitialValue(); 
16.     } 

public T get() {        Thread t = Thread.currentThread();        /**         * 得到当前线程的ThreadLocalMap         */        ThreadLocalMap map = getMap(t);        if (map != null) {            /**             * 在此线程的ThreadLocalMap中查找key为当前ThreadLocal对象的entry             */            ThreadLocalMap.Entry e = map.getEntry(this);            if (e != null)                return (T)e.value;        }        return setInitialValue();    }

初始化方法代码

1. private T setInitialValue() { 
2.         /** 
3.          * 默认返回null，这个方法为protected可以继承 
4.          */ 
5.         T value = initialValue(); 
6.         Thread t = Thread.currentThread(); 
7.         ThreadLocalMap map = getMap(t); 
8.         if (map != null) 
9.             map.set(this, value); 
10.         else 
11.             /** 
12.              * 初次创建 
13.              */ 
14.             createMap(t, value); 
15.         return value; 
16.     } 

private T setInitialValue() {        /**         * 默认返回null，这个方法为protected可以继承         */        T value = initialValue();        Thread t = Thread.currentThread();        ThreadLocalMap map = getMap(t);        if (map != null)            map.set(this, value);        else            /**             * 初次创建             */            createMap(t, value);        return value;    }

Java代码

1. /**
2. * 给当前thread初始ThreadlocalMap
3. */ 
4. void createMap(Thread t, T firstValue) { 
5.         t.threadLocals = new ThreadLocalMap(this, firstValue); 
6.     } 

/** * 给当前thread初始ThreadlocalMap */void createMap(Thread t, T firstValue) {        t.threadLocals = new ThreadLocalMap(this, firstValue);    }

通过上边的分析，我们发现，ThreadLocal类的使用虽然是用来解决多线程的问题的，但是还是有很明显的针对性

1.最明显的，ThreadLoacl变量的活动范围为某线程，并且我的理解是该线程“专有的，独自霸占”，对该变量的所有操作均有该线程完成！也就是说，ThreadLocal不是用来解决共享，竞争问题的。典型的应用莫过于Spring，Hibernate等框架中对于多线程的处理了

Java代码

1. private staticfinal ThreadLocal threadSession = new ThreadLocal();   
2.    
3. public static Session getSession()throws InfrastructureException {   
4.     Session s = (Session) threadSession.get();   
5.     try {   
6.         if (s == null) {   
7.             s = getSessionFactory().openSession();   
8.             threadSession.set(s);   
9.         }   
10.     } catch (HibernateException ex) {   
11.         throw new InfrastructureException(ex);   
12.     }   
13.     return s;   
14. }   

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

这段代码，每个线程有自己的ThreadLocalMap，每个ThreadLocalMap中根据需要初始加载threadSession,这样的好处就是介于singleton与prototype之间，应用singleton无法解决线程，应用prototype开销又太大，有了ThreadLocal之后就好了，对于需要线程“霸占”的变量用ThreadLocal，而该类实例的方法均可以共享。

2.关于内存泄漏：

虽然ThreadLocalMap已经使用了weakReference，但是还是建议能够显示的使用remove方法。

 

 

 

其中ThreadLocalMap的定义是在ThreadLocal类中，真正的引用却是在Thread类中

那么ThreadLocalMap究竟是什么呢？

可以看到这个类应该是一个Map,JDK的解释是

写道

ThreadLocalMap is a customized hash map suitable only for maintaining thread local values

接下来的重点是ThreadLocalMap中用于存储数据的entry

Java代码

1. static class Entryextends WeakReference<ThreadLocal> { 
2.             /** The value associated with this ThreadLocal. */ 
3.             Object value; 
4.  
5.             Entry(ThreadLocal k, Object v) { 
6.                 super(k); 
7.                 value = v; 
8.             } 
9.         } 

static class Entry extends WeakReference<ThreadLocal> {            /** The value associated with this ThreadLocal. */            Object value;            Entry(ThreadLocal k, Object v) {                super(k);                value = v;            }        }

从中我们可以发现这个Map的key是ThreadLocal变量，value为用户的值，并不是网上大多数的列子key是线程的名字或者标识

到这里，我们就可以理解ThreadLocal究竟是如何工作的了

1.Thread类中有一个成员变量叫做ThreadLocalMap，它是一个Map，他的Key是ThreadLocal类

2.每个线程拥有自己的申明为ThreadLocal类型的变量,所以这个类的名字叫'ThreadLocal'：线程自己的（变量）

3.此变量生命周期是由该线程决定的，开始于第一次初始（get或者set方法）

4.由ThreadLocal的工作原理决定了：每个线程独自拥有一个变量，并非共享或者拷贝

Java代码

1. /**
2. * @author mxdba
3. *
4. */ 
5. public class ThreadLocalSample { 
6.  
7.     public staticvoid main(String[] args) { 
8.         ThreadTest test1 = new ThreadTest(10); 
9.         ThreadTest test2 = new ThreadTest(20); 
10.         test1.start(); 
11.         test2.start(); 
12.     } 
13.  
14. } 
15.  
16. /**
17. * 此线程有两个ThreadLocal变量，但是由于ThreadLocal是延迟初始的，
18. * 所以在debug时可以看到线程名为“线程20”的线程的ThreadLocalMap中没有thLcal2这个entry
19. * @author mxdba
20. *
21. */ 
22. class ThreadTest extends Thread { 
23.      
24.     public static ThreadLocal<Integer> thLocal =new ThreadLocal<Integer>(); 
25.     public static ThreadLocal<String> thLocal2 =new ThreadLocal<String>(); 
26.      
27.     public Integer num; 
28.      
29.      
30.      
31.     public ThreadTest(Integer num) { 
32.         super("线程" + num); 
33.         this.num = num; 
34.     } 
35.  
36.     @Override 
37.     public void run() { 
38.         Integer n = thLocal.get(); 
39.         if(num != 20) { 
40.             String s = thLocal2.get(); 
41.         } 
42.              
43.         if(n == null) { 
44.             thLocal.set(num); 
45.         } 
46.         System.out.println(thLocal.get()); 
47.     } 
48.      
49. } 

/** * @author mxdba * */public class ThreadLocalSample {public static void main(String[] args) {ThreadTest test1 = new ThreadTest(10);ThreadTest test2 = new ThreadTest(20);test1.start();test2.start();}}/** * 此线程有两个ThreadLocal变量，但是由于ThreadLocal是延迟初始的， * 所以在debug时可以看到线程名为“线程20”的线程的ThreadLocalMap中没有thLcal2这个entry * @author mxdba *  */class ThreadTest extends Thread {public static ThreadLocal<Integer> thLocal = new ThreadLocal<Integer>();public static ThreadLocal<String> thLocal2 = new ThreadLocal<String>();public Integer num;public ThreadTest(Integer num) {super("线程" + num);this.num = num;}@Overridepublic void run() {Integer n = thLocal.get();if(num != 20) {String s = thLocal2.get();}if(n == null) {thLocal.set(num);}System.out.println(thLocal.get());}}

接下来分析一下源码，就更加清楚了

关键方法代码

1. /** 
2. * 关键方法，返回当前Thread的ThreadLocalMap 
3. * [[[每个Thread返回各自的ThreadLocalMap，所以各个线程中的ThreadLocal均为独立的]]] 
4. */ 
5. ThreadLocalMap getMap(Thread t) { 
6.         return t.threadLocals; 
7.     } 

/** * 关键方法，返回当前Thread的ThreadLocalMap * [[[每个Thread返回各自的ThreadLocalMap，所以各个线程中的ThreadLocal均为独立的]]] */ThreadLocalMap getMap(Thread t) {        return t.threadLocals;    }

Threadlocal的get方法代码

1. public T get() { 
2.         Thread t = Thread.currentThread(); 
3.         /** 
4.          * 得到当前线程的ThreadLocalMap 
5.          */ 
6.         ThreadLocalMap map = getMap(t); 
7.         if (map != null) { 
8.             /** 
9.              * 在此线程的ThreadLocalMap中查找key为当前ThreadLocal对象的entry 
10.              */ 
11.             ThreadLocalMap.Entry e = map.getEntry(this); 
12.             if (e != null) 
13.                 return (T)e.value; 
14.         } 
15.         return setInitialValue(); 
16.     } 

public T get() {        Thread t = Thread.currentThread();        /**         * 得到当前线程的ThreadLocalMap         */        ThreadLocalMap map = getMap(t);        if (map != null) {            /**             * 在此线程的ThreadLocalMap中查找key为当前ThreadLocal对象的entry             */            ThreadLocalMap.Entry e = map.getEntry(this);            if (e != null)                return (T)e.value;        }        return setInitialValue();    }

初始化方法代码

1. private T setInitialValue() { 
2.         /** 
3.          * 默认返回null，这个方法为protected可以继承 
4.          */ 
5.         T value = initialValue(); 
6.         Thread t = Thread.currentThread(); 
7.         ThreadLocalMap map = getMap(t); 
8.         if (map != null) 
9.             map.set(this, value); 
10.         else 
11.             /** 
12.              * 初次创建 
13.              */ 
14.             createMap(t, value); 
15.         return value; 
16.     } 

private T setInitialValue() {        /**         * 默认返回null，这个方法为protected可以继承         */        T value = initialValue();        Thread t = Thread.currentThread();        ThreadLocalMap map = getMap(t);        if (map != null)            map.set(this, value);        else            /**             * 初次创建             */            createMap(t, value);        return value;    }

Java代码

1. /**
2. * 给当前thread初始ThreadlocalMap
3. */ 
4. void createMap(Thread t, T firstValue) { 
5.         t.threadLocals = new ThreadLocalMap(this, firstValue); 
6.     } 

/** * 给当前thread初始ThreadlocalMap */void createMap(Thread t, T firstValue) {        t.threadLocals = new ThreadLocalMap(this, firstValue);    }

通过上边的分析，我们发现，ThreadLocal类的使用虽然是用来解决多线程的问题的，但是还是有很明显的针对性

1.最明显的，ThreadLoacl变量的活动范围为某线程，并且我的理解是该线程“专有的，独自霸占”，对该变量的所有操作均有该线程完成！也就是说，ThreadLocal不是用来解决共享，竞争问题的。典型的应用莫过于Spring，Hibernate等框架中对于多线程的处理了

Java代码

1. private staticfinal ThreadLocal threadSession = new ThreadLocal();   
2.    
3. public static Session getSession()throws InfrastructureException {   
4.     Session s = (Session) threadSession.get();   
5.     try {   
6.         if (s == null) {   
7.             s = getSessionFactory().openSession();   
8.             threadSession.set(s);   
9.         }   
10.     } catch (HibernateException ex) {   
11.         throw new InfrastructureException(ex);   
12.     }   
13.     return s;   
14. }   

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

这段代码，每个线程有自己的ThreadLocalMap，每个ThreadLocalMap中根据需要初始加载threadSession,这样的好处就是介于singleton与prototype之间，应用singleton无法解决线程，应用prototype开销又太大，有了ThreadLocal之后就好了，对于需要线程“霸占”的变量用ThreadLocal，而该类实例的方法均可以共享。

2.关于内存泄漏：

虽然ThreadLocalMap已经使用了weakReference，但是还是建议能够显示的使用remove方法。

 

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

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

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

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

Java代码

1. private staticfinal ThreadLocal threadSession = new ThreadLocal(); 
2.  
3. public static Session getSession()throws InfrastructureException { 
4.     Session s = (Session) threadSession.get(); 
5.     try { 
6.         if (s == null) { 
7.             s = getSessionFactory().openSession(); 
8.             threadSession.set(s); 
9.         } 
10.     } catch (HibernateException ex) { 
11.         throw new InfrastructureException(ex); 
12.     } 
13.     return s; 
14. } 

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

可以看到在getSession()方法中，首先判断当前线程中有没有放进去session，如果还没有，那么通过sessionFactory().openSession()来创建一个session，再将session set到线程中，实际是放到当前线程的ThreadLocalMap这个map中，这时，对于这个session的唯一引用就是当前线程中的那个ThreadLocalMap（下面会讲到），而threadSession作为这个值的key，要取得这个session可以通过threadSession.get()来得到，里面执行的操作实际是先取得当前线程中的ThreadLocalMap，然后将threadSession作为key将对应的值取出。这个session相当于线程的私有变量，而不是public的。
显然，其他线程中是取不到这个session的，他们也只能取到自己的ThreadLocalMap中的东西。要是session是多个线程共享使用的，那还不乱套了。
试想如果不用ThreadLocal怎么来实现呢？可能就要在action中创建session，然后把session一个个传到service和dao中，这可够麻烦的。或者可以自己定义一个静态的map，将当前thread作为key，创建的session作为值，put到map中，应该也行，这也是一般人的想法，但事实上，ThreadLocal的实现刚好相反，它是在每个线程中有一个map，而将ThreadLocal实例作为key，这样每个map中的项数很少，而且当线程销毁时相应的东西也一起销毁了，不知道除了这些还有什么其他的好处。

总之，ThreadLocal不是用来解决对象共享访问问题的，而主要是提供了保持对象的方法和避免参数传递的方便的对象访问方式。归纳了两点：
1。每个线程中都有一个自己的ThreadLocalMap类对象，可以将线程自己的对象保持到其中，各管各的，线程可以正确的访问到自己的对象。
2。将一个共用的ThreadLocal静态实例作为key，将不同对象的引用保存到不同线程的ThreadLocalMap中，然后在线程执行的各处通过这个静态ThreadLocal实例的get()方法取得自己线程保存的那个对象，避免了将这个对象作为参数传递的麻烦。

当然如果要把本来线程共享的对象通过ThreadLocal.set()放到线程中也可以，可以实现避免参数传递的访问方式，但是要注意get()到的是那同一个共享对象，并发访问问题要靠其他手段来解决。但一般来说线程共享的对象通过设置为某类的静态变量就可以实现方便的访问了，似乎没必要放到线程中。

ThreadLocal的应用场合，我觉得最适合的是按线程多实例（每个线程对应一个实例）的对象的访问，并且这个对象很多地方都要用到。

下面来看看ThreadLocal的实现原理（jdk1.5源码）

Java代码

1. public class ThreadLocal<T> { 
2.     /**
3.      * ThreadLocals rely on per-thread hash maps attached to each thread
4.      * (Thread.threadLocals and inheritableThreadLocals).  The ThreadLocal
5.      * objects act as keys, searched via threadLocalHashCode.  This is a
6.      * custom hash code (useful only within ThreadLocalMaps) that eliminates
7.      * collisions in the common case where consecutively constructed
8.      * ThreadLocals are used by the same threads, while remaining well-behaved
9.      * in less common cases.
10.      */ 
11.     private finalint threadLocalHashCode = nextHashCode(); 
12.  
13.     /**
14.      * The next hash code to be given out. Accessed only by like-named method.
15.      */ 
16.     private staticint nextHashCode = 0; 
17.  
18.     /**
19.      * The difference between successively generated hash codes - turns
20.      * implicit sequential thread-local IDs into near-optimally spread
21.      * multiplicative hash values for power-of-two-sized tables.
22.      */ 
23.     private staticfinal int HASH_INCREMENT =0x61c88647; 
24.  
25.     /**
26.      * Compute the next hash code. The static synchronization used here
27.      * should not be a performance bottleneck. When ThreadLocals are
28.      * generated in different threads at a fast enough rate to regularly
29.      * contend on this lock, memory contention is by far a more serious
30.      * problem than lock contention.
31.      */ 
32.     private staticsynchronized int nextHashCode() { 
33.         int h = nextHashCode; 
34.         nextHashCode = h + HASH_INCREMENT; 
35.         return h; 
36.     } 
37.  
38.     /**
39.      * Creates a thread local variable.
40.      */ 
41.     public ThreadLocal() { 
42.     } 
43.  
44.     /**
45.      * Returns the value in the current thread's copy of this thread-local
46.      * variable.  Creates and initializes the copy if this is the first time
47.      * the thread has called this method.
48.      *
49.      * @return the current thread's value of this thread-local
50.      */ 
51.     public T get() { 
52.         Thread t = Thread.currentThread(); 
53.         ThreadLocalMap map = getMap(t); 
54.         if (map != null) 
55.             return (T)map.get(this); 
56.  
57.         // Maps are constructed lazily.  if the map for this thread 
58.         // doesn't exist, create it, with this ThreadLocal and its 
59.         // initial value as its only entry. 
60.         T value = initialValue(); 
61.         createMap(t, value); 
62.         return value; 
63.     } 
64.  
65.     /**
66.      * Sets the current thread's copy of this thread-local variable
67.      * to the specified value.  Many applications will have no need for
68.      * this functionality, relying solely on the {@link #initialValue}
69.      * method to set the values of thread-locals.
70.      *
71.      * @param value the value to be stored in the current threads' copy of
72.      *        this thread-local.
73.      */ 
74.     public void set(T value) { 
75.         Thread t = Thread.currentThread(); 
76.         ThreadLocalMap map = getMap(t); 
77.         if (map != null) 
78.             map.set(this, value); 
79.         else 
80.             createMap(t, value); 
81.     } 
82.  
83.     /**
84.      * Get the map associated with a ThreadLocal. Overridden in
85.      * InheritableThreadLocal.
86.      *
87.      * @param  t the current thread
88.      * @return the map
89.      */ 
90.     ThreadLocalMap getMap(Thread t) { 
91.         return t.threadLocals; 
92.     } 
93.  
94.     /**
95.      * Create the map associated with a ThreadLocal. Overridden in
96.      * InheritableThreadLocal.
97.      *
98.      * @param t the current thread
99.      * @param firstValue value for the initial entry of the map
100.      * @param map the map to store.
101.      */ 
102.     void createMap(Thread t, T firstValue) { 
103.         t.threadLocals = new ThreadLocalMap(this, firstValue); 
104.     } 
105.  
106.     ....... 
107.  
108.     /**
109.      * ThreadLocalMap is a customized hash map suitable only for
110.      * maintaining thread local values. No operations are exported
111.      * outside of the ThreadLocal class. The class is package private to
112.      * allow declaration of fields in class Thread.  To help deal with
113.      * very large and long-lived usages, the hash table entries use
114.      * WeakReferences for keys. However, since reference queues are not
115.      * used, stale entries are guaranteed to be removed only when
116.      * the table starts running out of space.
117.      */ 
118.     static class ThreadLocalMap { 
119.  
120.     ........ 
121.  
122.     } 
123.  
124. } 

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 {    ........    }}

可以看到ThreadLocal类中的变量只有这3个int型：

Java代码

1. private finalint threadLocalHashCode = nextHashCode(); 
2. private staticint nextHashCode = 0; 
3. private staticfinal int HASH_INCREMENT =0x61c88647; 

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

而作为ThreadLocal实例的变量只有 threadLocalHashCode 这一个，nextHashCode 和HASH_INCREMENT 是ThreadLocal类的静态变量，实际上HASH_INCREMENT是一个常量，表示了连续分配的两个ThreadLocal实例的threadLocalHashCode值的增量，而nextHashCode 的表示了即将分配的下一个ThreadLocal实例的threadLocalHashCode 的值。

可以来看一下创建一个ThreadLocal实例即new ThreadLocal()时做了哪些操作，从上面看到构造函数ThreadLocal()里什么操作都没有，唯一的操作是这句：

Java代码

1. private finalint threadLocalHashCode = nextHashCode(); 

    private final int threadLocalHashCode = nextHashCode();

那么nextHashCode()做了什么呢：

Java代码

1. private staticsynchronized int nextHashCode() { 
2.     int h = nextHashCode; 
3.     nextHashCode = h + HASH_INCREMENT; 
4.     return h; 
5. } 

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

就是将ThreadLocal类的下一个hashCode值即nextHashCode的值赋给实例的threadLocalHashCode，然后nextHashCode的值增加HASH_INCREMENT这个值。

因此ThreadLocal实例的变量只有这个threadLocalHashCode，而且是final的，用来区分不同的ThreadLocal实例，ThreadLocal类主要是作为工具类来使用，那么ThreadLocal.set()进去的对象是放在哪儿的呢？

看一下上面的set()方法，两句合并一下成为

Java代码

1. ThreadLocalMap map = Thread.currentThread().threadLocals; 

        ThreadLocalMap map = Thread.currentThread().threadLocals;

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

Java代码

1. public class Threadimplements Runnable { 
2.     ...... 
3.  
4.     /* ThreadLocal values pertaining to this thread. This map is maintained
5.      * by the ThreadLocal class. */ 
6.     ThreadLocal.ThreadLocalMap threadLocals = null;   
7.     ...... 
8. } 

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

再看这句：

Java代码

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

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

也就是将该ThreadLocal实例作为key，要保持的对象作为值，设置到当前线程的ThreadLocalMap 中，get()方法同样大家看了代码也就明白了，ThreadLocalMap 类的代码太多了，我就不帖了，自己去看源码吧。

写了这么多，也不知讲明白了没有，有什么不当的地方还请大家指出来。