ThreadLocal类分析
首先试想一个场景：
多个线程都要访问数据库，先要获得一个Connection，然后执行一些操作。为了线程安全，如果用synchronized锁定一个Connection对象，那么任何时候，都只有一个线程能通过Connection对象操作数据库。这样的话，程序的效率太低。反过来，如果每次需要Connection对象就去new一个的话，就会同时存在数量庞大的数据库连接，你受得了，数据库受不了。于是就有人提出折中方案：为每个线程只生成一个Connection对象，这样别的线程访问不到这个对象，线程安全问题解决；而且无论线程有多少地方需要数据库连接，都是在复用这个Connection对象，数据库的压力会小很多。
其实不仅仅是数据库，其它的场景比如说，SimpleDateFormat。我们处理日期的时候，经常要用到这个类，但是这个类不是线程安全的，在多线程下是会出问题的。这时候，采用上述折中方案是比较合理的。
那么如何实现这种折中方案呢？我们先动手试一试呗！！！
要确保某类型的变量，每个线程只有一份。因为每个线程的ID是唯一的，这是JVM保证的，所有我们可以定义一个Map：线程ID作为key，我们要用的变量作为value。
稍微对这个Map进行简单的封装，当做一个类来用：
package threadlocal; import java.util.HashMap; import java.util.Map; public class ThreadLocalVar<T> { Map<Long, T> threadVarMap = new HashMap<Long, T>(); public T get() { return threadVarMap.get(Thread.currentThread().getId()); } public void set(T value) { threadVarMap.put(Thread.currentThread().getId(), value); } }
接下来，就把这个类扔到多线程环境里面练一练
package threadlocal; public class MyTest { ThreadLocalVar<Long> longLocal = new ThreadLocalVar<Long>(); ThreadLocalVar<String> stringLocal = new ThreadLocalVar<String>(); public void set() { longLocal.set(Thread.currentThread().getId()); stringLocal.set(Thread.currentThread().getName()); } public long getLong() { return longLocal.get(); } public String getString() { return stringLocal.get(); } public static void main(String[] args) throws InterruptedException { final MyTest test = new MyTest(); test.set(); System.out.println(test.getLong()); System.out.println(test.getString()); for (int i=0; i<3; i++) { Thread thread1 = new Thread(){ public void run() { test.set(); System.out.println(test.getLong()); System.out.println(test.getString()); }; }; thread1.start(); thread1.join(); } System.out.println(test.getLong()); System.out.println(test.getString()); } }
这个程序很简单，看一遍就能明白具体逻辑。虽然都是调用的同一个对象test的getLong和getString方法，但是不同的线程获取到的值不一样。
运行结果：
1 main 9 Thread-0 10 Thread-1 11 Thread-2 1 main
哈哈，我们就是使用了奇淫巧技，把一个对象简单的get和set操作，转到了对Map的get和set操作。如果光看MyTest这个类，再看结果，还是挺迷惑的吧。
这个时候就有人说了，Java的ThreadLocal机制，不是这么实现的。对，也不对。JDK之前的老版本其实就是这么实现来着，不过后来改了。为什么改，且听我慢慢道来。
先上一个真正的ThreadLocal版本的test程序：
package threadlocal; public class Test { ThreadLocal<Long> longLocal = new ThreadLocal<Long>(); ThreadLocal<String> stringLocal = new ThreadLocal<String>(); public void set() { longLocal.set(Thread.currentThread().getId()); stringLocal.set(Thread.currentThread().getName()); } public long getLong() { return longLocal.get(); } public String getString() { return stringLocal.get(); } public static void main(String[] args) throws InterruptedException { final Test test = new Test(); test.set(); System.out.println(test.getLong()); System.out.println(test.getString()); for (int i=0; i<3; i++) { Thread thread1 = new Thread(){ public void run() { test.set(); System.out.println(test.getLong()); System.out.println(test.getString()); }; }; thread1.start(); thread1.join(); } System.out.println(test.getLong()); System.out.println(test.getString()); } }
和我们之前的test程序唯一的区别，就是使用了Java自带的ThreadLocal类，那就进去看一看。
/** * 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(); // 其实还是通过Map的数据结构 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(); }
这是ThreadLocal的get方法，最终还是Map操作，但是这个Map以及Map里面的Entry都是为ThreadLocal专门定制的，后面再说。看看getMap方法的逻辑
/** * 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; }
/* ThreadLocal values pertaining to this thread. This map is maintained * by the ThreadLocal class. */ // 定义在Thread类里面 ThreadLocal.ThreadLocalMap threadLocals = null;
从这里能看出2点：
1、ThreadLocalMap这个Map是ThreadLocal的内部类
2、这个Map的持有者是Thread类，就是说每个线程都直接持有自己的Map
第2点跟我们之前的实现思路截然不同，我们定义的ThreadLocalVar类不被任何线程直接持有，只是独立的第三方，保持各个线程的数据。
后面再详细分析这里为什么要这么实现。
先来看看ThreadLocal的内部类ThreadLocalMap的内部类Entry（别绕晕了）
static class Entry extends WeakReference<ThreadLocal<?>> { /** The value associated with this ThreadLocal. */ Object value; Entry(ThreadLocal<?> k, Object v) { super(k); value = v; } }
Entry继承自弱引用，说明持有key的弱引用，而且key是ThreadLocal类型（跟之前的实现方式也截然不同）。
为了说明ThreadLocal的实现机制和类直接的关系，从网上盗一张图，图中实线是强引用，虚线是弱引用。
每个线程持有Map有什么好处？
1、线程消失，Map跟着消失，释放了内存
2、保存数据的Map数量变多了，但是每个Map里面Entry数量变少了。之前的实现里面，每个Map里面的Entry数量是线程的个数，现在是ThreadLocal的个数。熟悉Map数据结构的人都知道，这样对Map的操作性能会提升。
至于为什么要用弱引用，先来看看Entry类的注释
/** * The entries in this hash map extend WeakReference, using * its main ref field as the key (which is always a * ThreadLocal object). Note that null keys (i.e. entry.get() * == null) mean that the key is no longer referenced, so the * entry can be expunged from table. Such entries are referred to * as "stale entries" in the code that follows. */
简单来说，就是当ThreadLocal类型的key不再被引用时（值为null），对应的Entry能够被删除。
具体的实现就是，get操作会调用expungeStaleEntry，set操作会调用replaceStaleEntry，它们的效果就是遇到的key为null的Entry都会被删除，那么Entry内的value也就没有强引用链，自然会被回收，防止内存泄露。这部分，请读者仔细阅读源码。
经这么一分析，是不是豁然开朗。
下面在看看ThreadLocal在一些框架里面的应用：
1、Hibernate处理session，看看一个类ThreadLocalSessionContext
private static final ThreadLocal<Map> CONTEXT_TL = new ThreadLocal<Map>(); protected static Map sessionMap() { return CONTEXT_TL.get(); } @SuppressWarnings({"unchecked"}) private static void doBind(org.hibernate.Session session, SessionFactory factory) { Map sessionMap = sessionMap(); if ( sessionMap == null ) { sessionMap = new HashMap(); CONTEXT_TL.set( sessionMap ); } sessionMap.put( factory, session ); }
2、Spring处理事务，看看一个类TransactionSynchronizationManager
private static final ThreadLocal<Map<Object, Object>> resources = new NamedThreadLocal<Map<Object, Object>>("Transactional resources"); private static final ThreadLocal<Set<TransactionSynchronization>> synchronizations = new NamedThreadLocal<Set<TransactionSynchronization>>("Transaction synchronizations"); private static final ThreadLocal<String> currentTransactionName = new NamedThreadLocal<String>("Current transaction name"); private static final ThreadLocal<Boolean> currentTransactionReadOnly = new NamedThreadLocal<Boolean>("Current transaction read-only status"); private static final ThreadLocal<Integer> currentTransactionIsolationLevel = new NamedThreadLocal<Integer>("Current transaction isolation level"); private static final ThreadLocal<Boolean> actualTransactionActive = new NamedThreadLocal<Boolean>("Actual transaction active"); public static void bindResource(Object key, Object value) throws IllegalStateException { Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key); Assert.notNull(value, "Value must not be null"); // 处理ThreadLocal Map<Object, Object> map = resources.get(); // set ThreadLocal Map if none found if (map == null) { map = new HashMap<Object, Object>(); // 处理ThreadLocal resources.set(map); } Object oldValue = map.put(actualKey, value); // Transparently suppress a ResourceHolder that was marked as void... if (oldValue instanceof ResourceHolder && ((ResourceHolder) oldValue).isVoid()) { oldValue = null; } if (oldValue != null) { throw new IllegalStateException("Already value [" + oldValue + "] for key [" + actualKey + "] bound to thread [" + Thread.currentThread().getName() + "]"); } if (logger.isTraceEnabled()) { logger.trace("Bound value [" + value + "] for key [" + actualKey + "] to thread [" + Thread.currentThread().getName() + "]"); } }
