另一篇博文：Hibernet中的ThreadLocal使用 http://www.cnblogs.com/gnivor/p/4440776.html
本文參考：
http://blog.csdn.net/lufeng20/article/details/24314381
http://www.cnblogs.com/chenying99/articles/3405161.html
??
ThreadLocal類接口很簡單，只有4個方法，我們先來了解一下：?
| void set(Object value) | 設置當前線程的線程局部變量的值。? |
| public Object get() | 該方法返回當前線程所對應的線程局部變量。? |
| public void remove() | 將當前線程局部變量的值刪除，目的是為了減少內存的占用，該方法是JDK 5.0新增的方法。 注意，當線程結束后，對應該線程的局部變量將自動被垃圾回收，所以顯式調用該方法清除線程的局部變量并不是必須的操作，但它可以加快內存回收的速度。? |
| protected Object initialValue() | 返回該線程局部變量的初始值，該方法是一個protected的方法，顯然是為了讓子類覆蓋而設計的。 這個方法是一個延遲調用方法，在線程第1次調用get()或set(Object)時才執行，并且僅執行1次。ThreadLocal中的缺省實現直接返回一個null。 |
?
一、知其然
synchronized這類線程同步的機制可以解決多線程并發問題，在這種解決方案下，多個線程訪問到的，都是同一份變量的內容。為了防止在多線程訪問的過程中，可能會出現的并發錯誤。不得不對多個線程的訪問進行同步，這樣也就意味著，多個線程必須先后對變量的值進行訪問或者修改，這是一種以延長訪問時間來換取線程安全性的策略。
而ThreadLocal類為每一個線程都維護了自己獨有的變量拷貝。每個線程都擁有了自己獨立的一個變量，競爭條件被徹底消除了，那就沒有任何必要對這些線程進行同步，它們也能最大限度的由CPU調度，并發執行。并且由于每個線程在訪問該變量時，讀取和修改的，都是自己獨有的那一份變量拷貝，變量被徹底封閉在每個訪問的線程中，并發錯誤出現的可能也完全消除了。對比前一種方案，這是一種以空間來換取線程安全性的策略。
來看一個運用ThreadLocal來實現數據庫連接Connection對象線程隔離的例子。
import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException;public class ConnectionManager { private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>() { @Override protected Connection initialValue() { Connection conn = null; try { conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "username", "password"); } catch (SQLException e) { e.printStackTrace(); } return conn; } }; public static Connection getConnection() { return connectionHolder.get(); } public static void setConnection(Connection conn) { connectionHolder.set(conn); } }
通過調用ConnectionManager.getConnection()方法，每個線程獲取到的，都是和當前線程綁定的那個Connection對象，第一次獲取時，是通過initialValue()方法的返回值來設置值的。通過ConnectionManager.setConnection(Connection conn)方法設置的Connection對象，也只會和當前線程綁定。這樣就實現了Connection對象在多個線程中的完全隔離。在Spring容器中管理多線程環境下的Connection對象時，采用的思路和以上代碼非常相似。
附:另一個例子?
public class TestNum { private static ThreadLocal<Integer> seqNum = new ThreadLocal<Integer>(){public Integer initialValue() { return 0;}};public int getNextNum(){seqNum.set(seqNum.get()+1);return seqNum.get();}public static void main(String[] args) { TestNum sn = new TestNum(); //三個線程共享SN 產生序列號ThreadClient t1 = new ThreadClient(sn);ThreadClient t2 = new ThreadClient(sn);ThreadClient t3 = new ThreadClient(sn);t1.start();t2.start();t3.start();} }class ThreadClient extends Thread{private TestNum sn ;public ThreadClient(TestNum sn){this.sn = sn;}public void run(){for(int i = 0 ; i < 3 ; i++){System.out.println("Thread: "+ Thread.currentThread().getName() + " sn: " + sn.getNextNum());}} }
??
二、知其所以然
那么到底ThreadLocal類是如何實現這種“為每個線程提供不同的變量拷貝”的呢？先來看一下ThreadLocal的set()方法的源碼是如何實現的：?
/** * Sets the current thread's copy of this thread-local variable * to the specified value. Most subclasses will have no need to * override this method, relying solely on the {@link #initialValue} * method to set the values of thread-locals. * * @param value the value to be stored in the current thread's 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); }
線程隔離的秘密，就在于ThreadLocalMap這個類。ThreadLocalMap是ThreadLocal類的一個靜態內部類，它實現了鍵值對的設置和獲取（對比Map對象來理解），每個線程中都有一個獨立的ThreadLocalMap副本，它所存儲的值，只能被當前線程讀取和修改。ThreadLocal類通過操作每一個線程特有的ThreadLocalMap副本，從而實現了變量訪問在不同線程中的隔離。因為每個線程的變量都是自己特有的，完全不會有并發錯誤。還有一點就是，ThreadLocalMap存儲的鍵值對中的鍵是this對象指向的ThreadLocal對象，而值就是你所設置的對象了。
為了加深理解，我們接著看上面代碼中出現的getMap和createMap方法的實現：?
/** * 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); }
?代碼已經說的非常直白，就是獲取和設置Thread內的一個叫threadLocals的變量，而這個變量的類型就是ThreadLocalMap，這樣進一步驗證了上文中的觀點：每個線程都有自己獨立的ThreadLocalMap對象。打開java.lang.Thread類的源代碼，我們能得到更直觀的證明：
/* ThreadLocal values pertaining to this thread. This map is maintained by the ThreadLocal class. */ ThreadLocal.ThreadLocalMap threadLocals = null;
?
那么接下來再看一下ThreadLocal類中的get()方法，代碼是這么說的：?
/** * Returns the value in the current thread's copy of this * thread-local variable. If the variable has no value for the * current thread, it is first initialized to the value returned * by an invocation of the {@link #initialValue} 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) { ThreadLocalMap.Entry e = map.getEntry(this); if (e != null) return (T)e.value; } return setInitialValue(); }
??
再來看setInitialValue()方法：?
/** * Variant of set() to establish initialValue. Used instead * of set() in case user has overridden the set() method. * * @return the initial value */ private T setInitialValue() { T value = initialValue(); Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null) map.set(this, value); else createMap(t, value); return value; } ?
?
這兩個方法的代碼告訴我們，在獲取和當前線程綁定的值時，ThreadLocalMap對象是以this指向的ThreadLocal對象為鍵進行查找的，這當然和前面set()方法的代碼是相呼應的。
進一步地，我們可以創建不同的ThreadLocal實例來實現多個變量在不同線程間的訪問隔離，為什么可以這么做？因為不同的ThreadLocal對象作為不同鍵，當然也可以在線程的ThreadLocalMap對象中設置不同的值了。通過ThreadLocal對象，在多線程中共享一個值和多個值的區別，就像你在一個HashMap對象中存儲一個鍵值對和多個鍵值對一樣，僅此而已。
設置到這些線程中的隔離變量，會不會導致內存泄漏呢？ThreadLocalMap對象保存在Thread對象中，當某個線程終止后，存儲在其中的線程隔離的變量，也將作為Thread實例的垃圾被回收掉，所以完全不用擔心內存泄漏的問題。在多個線程中隔離的變量，光榮的生，合理的死，真是圓滿，不是么？
最后再提一句，ThreadLocal變量的這種隔離策略，也不是任何情況下都能使用的。如果多個線程并發訪問的對象實例只允許，也只能創建一個，那就沒有別的辦法了，老老實實的使用同步機制（synchronized）來訪問吧。
http://my.oschina.net/lichhao/blog/111362
)
