深入理解ThreadLocal
1、ThreadLocal是什么
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程对应的副本
2、ThreadLocal类提供的4个方法
- public void set(T value)
设置当前线程的线程局部变量的值
/** * 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); }
- public T 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) { @SuppressWarnings("unchecked") T result = (T)e.value; return result; } } return setInitialValue(); }
- public void remove()
将当前线程的局部变量的值删除
public void remove() { ThreadLocalMap m = getMap(Thread.currentThread()); if (m != null) m.remove(this); }
- protected T initialValue()
返回该线程局部变量的初始值,该方法是一个protected方法，显然是为了让子类覆盖而设计的，ThreadLocal中的缺省实现直接返回一个null
protected T initialValue() { return null; }
3、每个线程的变量副本存储在哪里
ThreadLocal有一个静态内部类ThreadLocalMap，该内部类保存了当前线程所对应的变量的副本（需要注意的是，变量是保存在线程中的，而不是保存在ThreadLocal变量中）
Thread类表示的当前线程中，有一个变量引用名是threadLocals，这个引用是在ThreadLocal类中createMap函数内初始化的
/* ThreadLocal values pertaining to this thread. This map is maintained * by the ThreadLocal class. */ ThreadLocal.ThreadLocalMap threadLocals = null;
我们所使用的ThreadLocal变量的实际数据，通过get函数实际取值的时候，就是通过取出Thread类中threadLocals引用的map，然后从这个map中根据当前threadLocal作为参数，取出数据
4、变量副本是怎么从共享的那个变量复制出来的，ThreadLocal的初始值什么时候设置的？
准确的说，应该是，变量副本【每个线程中保存的那个map中的变量】是怎么声明和初始化的
从set函数可以看出，当前线程的ThreadLocalMap是在第一次调用set的时候创建map并设置相应的值的
5、一个线程声明了n（n>=2）个这样的局部变量threadLocal，那么在Thread类中的threadLocals是怎么存储的？
在ThreadLocal的set函数中可以看到，其中的map.set(this, value)把当前的ThreadLocal传入到map中作为键，也就是说，在不同线程的threadLocals变量中，都会有一个以你所声明的那个线程局部变量threadLocal作为键的key-value。假设你声明了n个这样的线程局部变量，那么在线程的ThreadLocalMap中就会有n个分别以你的线程局部变量作为key的键值对
6、应用场景
当很多线程需要多次使用同一个对象，并且需要该对象具有相同初始化值的时候最适合使用ThreadLocal
7、典型应用
ThreadLocal在Hibernate中的应用
private static final ThreadLocal threadSession = new ThreadLocal(); public static Session getSession() throws InfrastructureException { //首先判断当前线程中有没有放进去session Session s = (Session) threadSession.get(); try { //如果还没有，通过sessionFactory.openSession()来创建一个session，再将session放到线程中 //实际上是放到当前线程的ThreadLocalMap中，对于这个session的唯一引用就是当前线程中的那个ThreadLocalMap if (s == null) { s = getSessionFactory().openSession(); threadSession.set(s); } } catch (HibernateException ex) { throw new InfrastructureException(ex); } return s; }
试想如果不用ThreadLocal怎么来实现呢？可能就要在action中创建session，然后把session一个个传到service和dao中
或者自己定义一个静态的map，将当前thread作为key，创建的session作为值，put到map中
8、代码示例
8.1 例1
public class ThreadLocalTest { //创建一个Integer型的线程本地变量 public static final ThreadLocal<Integer> local = new ThreadLocal<Integer>() { @Override protected Integer initialValue() { return 0; } }; public static void main(String[] args) { Thread[] threads = new Thread[5]; for (int i = 0; i < 5; i++) { new Thread(new Runnable() { @Override public void run() { //获取当前线程的本地变量，然后累加5次 int num = local.get(); for (int j = 0; j < 5; j++) { num++; } //重新设置累加后的本地变量 local.set(num); System.out.println(Thread.currentThread().getName() + ":" + local.get()); } }, "Thread-" + i).start(); } } }
运行后结果：
Thread-0:5
Thread-3:5
Thread-2:5
Thread-1:5
Thread-4:5
可以看到，每个线程累加后的结果都是5，各个线程处理自己的本地变量值，县城之间互不影响。
8.2 例2
public class ThreadLocalTest { private static Index num = new Index(); //创建一个Integer型的线程本地变量 public static final ThreadLocal<Index> local = new ThreadLocal<Index>() { @Override protected Index initialValue() { return num; } }; public static void main(String[] args) { Thread[] threads = new Thread[5]; for (int i = 0; i < 5; i++) { new Thread(new Runnable() { @Override public void run() { //获取当前线程的本地变量，然后累加5次 Index index = local.get(); for (int j = 0; j < 5; j++) { index.increase(); } //重新设置累加后的本地变量 local.set(index); System.out.println(Thread.currentThread().getName() + ":" + local.get().num); } }, "Thread-" + i).start(); } } static class Index { int num; public void increase() { num++; } } }
执行结果（每次运行结果都不一样）：
Thread-0:5
Thread-1:20
Thread-3:25
Thread-4:15
Thread-2:10
原因：
ThreadLocal可以给一个初始值，而每个线程获得的是这个初始值的副本，而不是要创建对象引用的副本
public static final ThreadLocal<Index> local = new ThreadLocal<Index>() { @Override protected Index initialValue() { return new Index(); //注意这里 } };
改为以上方法后，正确输出结果：
Thread-0:5
Thread-2:5
Thread-4:5
Thread-3:5
Thread-1:5
