理解ThreadLocal

發表於2012-05-27
thread

ThreadLocal是什麼

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

可以看到在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 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. }  


可以看到ThreadLocal類中的變數只有這3個int型： 
Java程式碼  收藏程式碼
  1. private final int threadLocalHashCode = nextHashCode();  
  2. private static int nextHashCode = 0;  
  3. 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 final int threadLocalHashCode = nextHashCode();  

那麼nextHashCode()做了什麼呢： 
Java程式碼  收藏程式碼
  1. private static synchronized int nextHashCode() {  
  2.     int h = nextHashCode;  
  3.     nextHashCode = h + HASH_INCREMENT;  
  4.     return h;  
  5. }  
就是將ThreadLocal類的下一個hashCode值即nextHashCode的值賦給例項的threadLocalHashCode，然後nextHashCode的值增加HASH_INCREMENT這個值。 

因此ThreadLocal例項的變數只有這個threadLocalHashCode，而且是final的，用來區分不同的ThreadLocal例項，ThreadLocal類主要是作為工具類來使用，那麼ThreadLocal.set()進去的物件是放在哪兒的呢？ 

看一下上面的set()方法，兩句合併一下成為 
Java程式碼  收藏程式碼
  1. ThreadLocalMap map = Thread.currentThread().threadLocals;  

這個ThreadLocalMap 類是ThreadLocal中定義的內部類，但是它的例項卻用在Thread類中： 
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);  

也就是將該ThreadLocal例項作為key，要保持的物件作為值，設定到當前執行緒的ThreadLocalMap 中，get()方法同樣大家看了程式碼也就明白了，ThreadLocalMap 類的程式碼太多了，我就不帖了，自己去看原始碼吧。

相關文章