深入研究java.lang.ThreadLocal類

3、在ThreadDemo類的run()方法中，通過getXxx()方法獲取要操作的資料，這樣可以保證每個執行緒對應一個資料物件，在任何時刻都操作的是這個物件。

首先，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 static final 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. }  

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 final int threadLocalHashCode = nextHashCode();  
12.   
13.     /** 
14.      * The next hash code to be given out. Accessed only by like-named method. 
15.      */  
16.     private static int 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 static final 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 static synchronized 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. }  

Java程式碼  

1. private final int threadLocalHashCode = nextHashCode();  
2. private static int nextHashCode = 0;  
3. private static final int HASH_INCREMENT = 0x61c88647;  

Java程式碼  

1. private final int threadLocalHashCode = nextHashCode();  

Java程式碼  

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

Java程式碼  

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

Java程式碼  

1. public class Thread implements 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. }  

Java程式碼  

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