彻底理解Java中的ThreadLocal

package com.test; 
public class TestNum { 
 // ①通过匿名内部类覆盖ThreadLocal的initialValue()方法，指定初始值 
 private static ThreadLocal seqNum = new ThreadLocal() { 
  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(); 
  // ③ 3个线程共享sn，各自产生序列号 
  TestClient t1 = new TestClient(sn); 
  TestClient t2 = new TestClient(sn); 
  TestClient t3 = new TestClient(sn); 
  t1.start(); 
  t2.start(); 
  t3.start(); 
 } 
 private static class TestClient extends Thread { 
  private TestNum sn; 
  public TestClient(TestNum sn) { 
   this.sn = sn; 
  } 
  public void run() { 
   for (int i = 0; i < 3; i++) { 
    // ④每个线程打出3个序列值 
    System.out.println("thread[" + Thread.currentThread().getName() + "] --> sn[" 
       + sn.getNextNum() + "]"); 
   } 
  } 
 } 
} 

package com.test; 
import java.sql.Connection; 
import java.sql.SQLException; 
import java.sql.Statement; 
public class TestDao { 
 private Connection conn;// ①一个非线程安全的变量 
 public void addTopic() throws SQLException { 
  Statement stat = conn.createStatement();// ②引用非线程安全变量 
  // … 
 } 
} 

package com.test; 
import java.sql.Connection; 
import java.sql.SQLException; 
import java.sql.Statement; 
public class TestDaoNew { 
 // ①使用ThreadLocal保存Connection变量 
 private static ThreadLocal connThreadLocal = new ThreadLocal(); 
 public static Connection getConnection() { 
  // ②如果connThreadLocal没有本线程对应的Connection创建一个新的Connection， 
  // 并将其保存到线程本地变量中。 
  if (connThreadLocal.get() == null) { 
   Connection conn = getConnection(); 
   connThreadLocal.set(conn); 
   return conn; 
  } else { 
   return connThreadLocal.get();// ③直接返回线程本地变量 
  } 
 } 
 public void addTopic() throws SQLException { 
  // ④从ThreadLocal中获取线程对应的Connection 
  Statement stat = getConnection().createStatement(); 
 } 
} 

package com.test; 
import java.sql.Connection; 
import java.sql.DriverManager; 
import java.sql.SQLException; 
public class ConnectionManager { 
 private static ThreadLocal connectionHolder = new ThreadLocal() { 
  @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); 
 } 
} 

/** 
 * 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); 
 } 

/** 
 * 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); 
} 

/** 
 * 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(); 
} 

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

package com.test; 
import java.sql.Connection; 
import java.sql.DriverManager; 
import java.sql.SQLException; 
public class ConnectionManager { 
 private static ThreadLocal connectionHolder = new ThreadLocal() { 
  @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); 
 } 
} 

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