探究ThreadLocal原理(基于JAVA8源码分析)线程封闭ThreadLocal是什么ThreadLoalMaphash冲突内存泄露避免内存泄露题外小话ThreadLocal的应用场合
探究ThreadLocal原理(基于JAVA8源码分析)线程封闭ThreadLocal是什么ThreadLoalMaphash冲突内存泄露避免内存泄露题外小话ThreadLocal的应用场合
线程封闭
实现好的并发是一件困难的事情，所以很多时候我们都想躲避并发。避免并发最简单的方法就是线程封闭。什么是线程封闭呢？ 就是把对象封装到一个线程里，只有这一个线程能看到此对象。那么这个对象就算不是线程安全的也不会出现任何安全问题。 使用ThreadLocal是实现线程封闭的最好方法。ThreadLocal内部维护了一个Map，Map的key是每个线程的名称，而Map的值就是我们要封闭的对象。每个线程中的对象都对应着Map中一个值，也就是ThreadLocal利用Map实现了对象的线程封闭。
ThreadLocal是什么
该类提供了线程局部 (thread-local) 变量。这些变量不同于它们的普通对应物，因为访问某个变量（通过其 get 或 set 方法）的每个线程都有自己的局部变量，它独立于变量的初始化副本。 ThreadLocal 实例通常是类中的 private static 字段，它们希望将状态与某一个线程（例如，用户 ID 或事务 ID）相关联。
一个以ThreadLocal对象为键、任意对象为值的存储结构。 是一个数据结构，有点像HashMap，可以保存"key : value"键值对，但是一个ThreadLocal只能保存一个，并且各个线程的数据互不干扰。 该结构被附带在线程上，也就是说一个线程可以根据一个ThreadLocal对象查询到绑定在这个线程上的一个值。
ThreadLocal<String> localName = new ThreadLocal();
localName.set("sss");
String name = localName.get();在线程A中初始化了一个ThreadLocal对象localName，并set了一个值sss，同时在线程A中通过get可拿到之前设置的值，但是如果在线程B中，拿到的将是一个null
这是如何实现的呢？之前说过，ThreadLocal保证了各个线程的数据互不干扰 看看set(T value)和get()方法的源码
// 返回当前线程该线程局部变量副本中的值
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 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;
}可以发现，每个线程中都有一个ThreadLocalMap数据结构 执行set时，其值是保存在当前线程的threadLocals变量中，执行get时，从当前线程的threadLocals变量获取
所以在线程A中set的值，对线程B来说是摸不到的，而且在线程B中重新set的话，也不会影响到线程A中的值，保证了线程之间不会相互干扰
那每个线程中的ThreadLoalMap究竟是什么？
ThreadLoalMap
从名字上看，可以猜到它也是一个类似HashMap的数据结构，但是在ThreadLocal中，并没实现Map接口
在ThreadLoalMap中，也是初始化一个大小为16的Entry数组table，Entry节点对象用来保存每一个key-value键值对，这里的key永远都是ThreadLocal对象,通过ThreadLocal对象的set方法，结果把ThreadLocal对象自己当做key，放进了ThreadLoalMap中(神奇吧!)
注意，ThreadLoalMap的Entry是继承WeakReference，和HashMap很大的区别是，Entry中没有next字段，所以不存在链表的情况
hash冲突
没有链表结构，那发生hash冲突了怎么办？ 先看看ThreadLoalMap中插入一个key-value的实现
private void set(ThreadLocal<?> key, Object value) {
// We don't use a fast path as with get() because it is at
// least as common to use set() to create new entries as
// it is to replace existing ones, in which case, a fast
// path would fail more often than not.
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1);
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
if (k == key) {
e.value = value;
return;
}
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}每个ThreadLocal对象都有一个hash值threadLocalHashCode 每初始化一个ThreadLocal对象，hash值就增加一个固定的HASH_INCREMENT(0x61c88647)大小
在插入过程中，根据ThreadLocal对象的hash值，定位到table中的位置i，过程如下 1、如果当前位置是空的，那么正好，就初始化一个Entry对象放在位置i上 2、位置i已有对象，如果这个Entry对象的key正好是即将设置的key，那么覆盖value 3、位置i的对象，和即将设置的key没关系，那么只能找下一个空位置
这样的话，在get时，也会根据ThreadLocal对象的hash值，定位到table中的位置，然后判断该位置Entry对象中的key是否和get的key一致，如果不一致，就判断下一个位置
可以发现，set和get如果冲突严重的话，效率很低，因为ThreadLoalMap是Thread的一个属性，所以即使在自己的代码中控制了设置的元素个数，但还是不能控制其它代码的行为
内存泄露
ThreadLocal可能导致内存泄漏，为什么？ 先看看Entry的实现：
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}通过之前的分析已经知道，当使用ThreadLocal保存一个value时，会在ThreadLocalMap中的数组插入一个Entry对象，按理说key-value都应该以强引用保存在Entry对象中，但在ThreadLocalMap的实现中，key被保存到了WeakReference对象中这就导致了一个问题，ThreadLocal在没有外部强引用时，发生GC时会被回收，如果创建ThreadLocal的线程一直持续运行，那么这个Entry对象中的value就有可能一直得不到回收，发生内存泄露。
避免内存泄露
既然发现有内存泄露的隐患，自然有应对策略，在调用ThreadLocal的get()、set()可能会清除ThreadLocalMap中key为null的Entry对象，这样对应的value就没有GC Roots可达了，下次GC的时候就可以被回收，当然如果调用remove方法，肯定会删除对应的Entry对象。
如果使用ThreadLocal的set方法之后，没有显示的调用remove方法，就有可能发生内存泄露，所以养成良好的编程习惯十分重要，使用完ThreadLocal之后，记得调用remove方法。
ThreadLocal<String> localName = new ThreadLocal();
try {
localName.set("sss");
// 其它业务逻辑
} finally {
localName.remove();
}题外小话
首先，ThreadLocal 不是用来解决共享对象的多线程访问问题的，一般情况下，通过set() 到线程中的对象是该线程自己使用的对象，其他线程是不需要访问的，也访问不到的。各个线程中访问的是不同的对象。
另外，说ThreadLocal使得各线程能够保持各自独立的一个对象，并不是通过set()来实现的，而是通过每个线程中的new 对象 的操作来创建的对象，每个线程创建一个，不是什么对象的拷贝或副本。 通过set()将这个新创建的对象的引用保存到各线程的自己的一个map中，每个线程都有这样一个map，执行get()时，各线程从自己的map中取出放进去的对象，因此取出来的是各自自己线程中的对象，ThreadLocal实例是作为map的key来使用的。
如果set()进去的东西本来就是多个线程共享的同一个对象，那么多个线程的get()取得的还是这个共享对象本身，还是有并发访问问题。
下面来看一个hibernate中典型的ThreadLocal的应用
private static final ThreadLocal threadSession = new ThreadLocal();
public static Session getSession() throws InfrastructureException {
Session s = (Session) threadSession.get();
try {
if (s == null) {
s = getSessionFactory().openSession();
threadSession.set(s);
}
} catch (HibernateException ex) {
throw new InfrastructureException(ex);
}
return s;
} 可以看到在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不是用来解决对象共享访问问题的，而主要是提供了保持对象的方法和避免参数传递的方便的对象访问方式。归纳了两点：
- 每个线程中都有一个自己的ThreadLocalMap类对象，可以将线程自己的对象保持到其中，各管各的，线程可以正确的访问到自己的对象
- 将一个共用的ThreadLocal静态实例作为key，将不同对象的引用保存到不同线程的ThreadLocalMap中，然后在线程执行的各处通过这个静态ThreadLocal实例的get()方法取得自己线程保存的那个对象，避免了将这个对象作为参数传递的麻烦。
当然如果要把本来线程共享的对象通过set()放到线程中也可以，可以实现避免参数传递的访问方式，但是要注意get()到的是那同一个共享对象，并发访问问题要靠其他手段来解决。但一般来说线程共享的对象通过设置为某类的静态变量就可以实现方便的访问了，似乎没必要放到线程中
ThreadLocal的应用场合
我觉得最适合的是按线程多实例（每个线程对应一个实例）的对象的访问，并且这个对象很多地方都要用到。
可以看到ThreadLocal类中的变量只有这3个int型：
private final int threadLocalHashCode = nextHashCode();
private static AtomicInteger nextHashCode =
new AtomicInteger();
private static final int HASH_INCREMENT = 0x61c88647; 而作为ThreadLocal实例的变量只有 threadLocalHashCode nextHashCode 和HASH_INCREMENT 是ThreadLocal类的静态变量 实际上HASH_INCREMENT是一个常量，表示了连续分配的两个ThreadLocal实例的threadLocalHashCode值的增量，而nextHashCode 表示了即将分配的下一个ThreadLocal实例的threadLocalHashCode 的值。
可以来看一下创建一个ThreadLocal实例即new ThreadLocal()时做了哪些操作，构造函数ThreadLocal()里什么操作都没有，唯一的操作是这句
private final int threadLocalHashCode = nextHashCode(); 那么nextHashCode()做了什么呢
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}就是将ThreadLocal类的下一个hashCode值即nextHashCode的值赋给实例的threadLocalHashCode，然后nextHashCode的值增加HASH_INCREMENT这个值。
因此ThreadLocal实例的变量只有这个threadLocalHashCode，而且是final的，用来区分不同的ThreadLocal实例，ThreadLocal类主要是作为工具类来使用，那么set()进去的对象是放在哪儿的呢？
看一下上面的set()方法，两句合并一下成为
ThreadLocalMap map = Thread.currentThread().threadLocals; 这个ThreadLocalMap 类是ThreadLocal中定义的内部类，但是它的实例却用在Thread类中：
public class Thread implements Runnable {
......
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
......
} 再看这句：
if (map != null)
map.set(this, value); 也就是将该ThreadLocal实例作为key，要保持的对象作为值，设置到当前线程的ThreadLocalMap 中，get()方法同样大家看了代码也就明白了，ThreadLocalMap 类的代码太多了，我就不帖了，自己去看源码吧。