类ThreadLocal的使用与源码分析
变量值的共享可以使用public static的形式，所有的线程都使用同一个变量。如果每个线程都有自己的共享变量，就可以使用ThreadLocal。比如Hibernat的session问题就是存在ThreadLoca中。
类ThreadLocal主要解决的就是每个线程绑定自己的值，可以将ThreadLocal比喻成存放数据的盒子，盒子中可以存储每个线程的私有数据。
而且ThreadLocal一般用作静态成员变量封装在工具类中实现线程隔离数据。在JavaEE结构中就是从Action层到Dao层可以使用threadLocal实现共享数据，并且线程之间相互隔离。(对于ThreadLocal，每个线程存进去的东西与取出来的是一致的，不会出现相互覆盖的现象。)
ThreadLocal就是，把一个数据复制N份，每个线程认领一份，各玩各的，互不影响。
1. 方法 get()与null
ThreadLocal的基本使用方法。
package cn.qlq.thread.ten; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * ThreadLocal的基本使用 * * @author QiaoLiQiang * @time 2018年12月15日下午9:00:19 */ public class Demo1 { public static ThreadLocal<String> t1 = new ThreadLocal<String>(); private static final Logger LOGGER = LoggerFactory.getLogger(Demo1.class); public static void main(String[] args) { if (t1.get() == null) { LOGGER.info("从未放过值"); t1.set("存放的值"); } LOGGER.info("{}", t1.get()); LOGGER.info("{}", t1.get()); } }
结果:
21:02:38 [cn.qlq.thread.ten.Demo1]-[INFO] 从未放过值
21:02:38 [cn.qlq.thread.ten.Demo1]-[INFO] 存放的值
21:02:38 [cn.qlq.thread.ten.Demo1]-[INFO] 存放的值
从第一个的返回结果看，第一次调用t1对象的get()方法时返回的值是null，通过set()赋值之后可以取出值。类ThreadLocal解决的是变量在不同线程间的隔离性，也就是每个线程拥有自己的值，不同线程中的值是可以放入ThreadLocal类中进行保存的。
2.验证变量间的隔离性
验证其隔离性，每个线程在变量间存放的值不同。
package cn.qlq.thread.ten; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * ThreadLocal的基本使用 * * @author QiaoLiQiang * @time 2018年12月15日下午9:00:19 */ public class Demo2 { public static ThreadLocal<String> t1 = new ThreadLocal<String>(); private static final Logger LOGGER = LoggerFactory.getLogger(Demo2.class); public static void main(String[] args) { new Thread(new Runnable() { @Override public void run() { if (t1.get() == null) { LOGGER.info("从未放过值,threadName->{}", Thread.currentThread().getName()); t1.set("存放的值" + Thread.currentThread().getName()); } LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get()); } }, "thread1").start(); new Thread(new Runnable() { @Override public void run() { if (t1.get() == null) { LOGGER.info("从未放过值,threadName->{}", Thread.currentThread().getName()); t1.set("存放的值" + Thread.currentThread().getName()); } LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get()); } }, "thread2").start(); } }
结果: (由结果可以看出每个线程存放了不同的值，但是在获取值的时候，每个线程又获取到了不同的值。)
21:11:08 [cn.qlq.thread.ten.Demo2]-[INFO] 从未放过值,threadName->thread2
21:11:08 [cn.qlq.thread.ten.Demo2]-[INFO] 从未放过值,threadName->thread1
21:11:08 [cn.qlq.thread.ten.Demo2]-[INFO] threadName - >thread2,值->存放的值thread2
21:11:08 [cn.qlq.thread.ten.Demo2]-[INFO] threadName - >thread1,值->存放的值thread1
3.解决get()返回null问题
为了解决返回为null的问题，也就是在get()的时候直接就返回默认值，采用继承ThreadLocal并且重写initialValue的方式实现。(初始值的时候也可以实现线程的隔离线)
package cn.qlq.thread.ten; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * 解决get()返回null的问题 * * @author QiaoLiQiang * @time 2018年12月15日下午9:16:17 */ public class Demo3<T> extends ThreadLocal<String> { public static Demo3<String> t1 = new Demo3<String>(); private static final Logger LOGGER = LoggerFactory.getLogger(Demo3.class); public static void main(String[] args) { new Thread(new Runnable() { @Override public void run() { if (t1.get() == null) { LOGGER.info("从未放过值,threadName->{}", Thread.currentThread().getName()); t1.set("存放的值" + Thread.currentThread().getName()); } LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get()); } }, "thread1").start(); new Thread(new Runnable() { @Override public void run() { if (t1.get() == null) { LOGGER.info("从未放过值,threadName->{}", Thread.currentThread().getName()); t1.set("存放的值" + Thread.currentThread().getName()); } LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get()); } }, "thread2").start(); } @Override protected String initialValue() { return "这是初始值" + Thread.currentThread().getName(); } }
结果:
21:23:54 [cn.qlq.thread.ten.Demo3]-[INFO] threadName - >thread2,值->这是初始值thread2
21:23:54 [cn.qlq.thread.ten.Demo3]-[INFO] threadName - >thread1,值->这是初始值thread1
4. ThreadLocal中存入多个对象
有时候我们在ThreadLocal 中希望共享多个变量。
最简单的一种办法创建一个ThreadLocal就是将所有共享的数据存入一个Map，将Map存入ThreadLocal，另一种办法就是所有共享数据放入一个bean中将bean存入ThreadLocal。
另一种办法就是每个创建多个ThreadLocal分别存放多种共享的数据。
如下一个ThreadLocal存入Map中实现共享多个数据
package cn.qlq.thread.ten; import java.util.HashMap; import java.util.Map; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @SuppressWarnings("all") public class Demo7 { public static ThreadLocal t1 = new ThreadLocal(); private static final Logger LOGGER = LoggerFactory.getLogger(Demo7.class); public static void main(String[] args) throws InterruptedException { Map data = new HashMap(); data.put("str", "111222"); data.put("int", 11122); data.put("obj", new Object()); t1.set(data); Object object = t1.get(); System.out.println(object); } }
结果:
{str=111222, int=11122, obj=java.lang.Object@77700f3d}
或者多个ThreadLocal共享多个数据
package cn.qlq.thread.ten; import java.util.HashMap; import java.util.Map; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @SuppressWarnings("all") public class Demo7 { public static ThreadLocal t1 = new ThreadLocal(); public static ThreadLocal<String> t2 = new ThreadLocal<String>(); private static final Logger LOGGER = LoggerFactory.getLogger(Demo7.class); public static void main(String[] args) throws InterruptedException { Map data = new HashMap(); data.put("str", "111222"); data.put("int", 11122); data.put("obj", new Object()); t1.set(data); t2.set("t2"); System.out.println(t1.get()); System.out.println(t2.get()); } }
结果:
{str=111222, int=11122, obj=java.lang.Object@271455a2}
t2
5. 类InheritableThreadLocal的使用
5.1值继承
使用InheritableThreadLocal可以在子线程从父线程中继承值。主线程存入值，在子线程中获取。
package cn.qlq.thread.ten; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * 主线程中设置值，子线程中获取值 * * @author QiaoLiQiang * @time 2018年12月15日下午9:29:40 * @param <T> */ public class Demo4<T> extends InheritableThreadLocal<String> { public static Demo4<String> t1 = new Demo4<String>(); private static final Logger LOGGER = LoggerFactory.getLogger(Demo4.class); public static void main(String[] args) { // 主线程中存入值 t1.set("存放的值" + Thread.currentThread().getName()); new Thread(new Runnable() { @Override public void run() { if (t1.get() == null) { LOGGER.info("从未放过值,threadName->{}", Thread.currentThread().getName()); t1.set("存放的值" + Thread.currentThread().getName()); } LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get()); } }, "thread1").start(); new Thread(new Runnable() { @Override public void run() { if (t1.get() == null) { LOGGER.info("从未放过值,threadName->{}", Thread.currentThread().getName()); t1.set("存放的值" + Thread.currentThread().getName()); } LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get()); } }, "thread2").start(); } }
结果:
21:29:02 [cn.qlq.thread.ten.Demo4]-[INFO] threadName - >thread2,值->存放的值main
21:29:02 [cn.qlq.thread.ten.Demo4]-[INFO] threadName - >thread1,值->存放的值main
测试在子线程中再次创建子线程。（值会一直继承下去，对自己的子线程创建的子线程也有效）
package cn.qlq.thread.ten; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * 主线程中设置值，子线程中获取值 * * @author QiaoLiQiang * @time 2018年12月15日下午9:29:40 * @param <T> */ public class Demo5<T> extends InheritableThreadLocal<String> { public static Demo5<String> t1 = new Demo5<String>(); private static final Logger LOGGER = LoggerFactory.getLogger(Demo5.class); public static void main(String[] args) { // 主线程中存入值 t1.set("存放的值" + Thread.currentThread().getName()); // 创建子线程获取值 new Thread(new Runnable() { @Override public void run() { LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get()); // 创建子子线程获取值 new Thread(new Runnable() { @Override public void run() { LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get()); } }, "thread2").start(); } }, "thread1").start(); } }
结果:
21:32:34 [cn.qlq.thread.ten.Demo5]-[INFO] threadName - >thread1,值->存放的值main
21:32:34 [cn.qlq.thread.ten.Demo5]-[INFO] threadName - >thread2,值->存放的值main
5.2 值继承再修改
值也可以被继承再修改。
package cn.qlq.thread.ten; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * 继承再修改值 * * @author QiaoLiQiang * @time 2018年12月15日下午9:34:41 * @param <T> */ public class Demo6<T> extends InheritableThreadLocal<String> { public static Demo6<String> t1 = new Demo6<String>(); private static final Logger LOGGER = LoggerFactory.getLogger(Demo6.class); public static void main(String[] args) throws InterruptedException { // 主线程中存入值 t1.set("存放的值" + Thread.currentThread().getName()); LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get()); // 创建子线程获取值 new Thread(new Runnable() { @Override public void run() { LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get()); // 主线程中存入值 t1.set("存放的值" + Thread.currentThread().getName()); LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get()); // 创建子子线程获取值 new Thread(new Runnable() { @Override public void run() { LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get()); } }, "thread2").start(); } }, "thread1").start(); Thread.sleep(2 * 1000); LOGGER.info("threadName - >{},值->{}", Thread.currentThread().getName(), t1.get()); } }
结果:(主线程中存入值，在子线程修改了值，main线程取到的值还是main中存入的值，子线程以及子子线程获得的值是子线程修改的值。)
21:36:26 [cn.qlq.thread.ten.Demo6]-[INFO] threadName - >main,值->存放的值main
21:36:26 [cn.qlq.thread.ten.Demo6]-[INFO] threadName - >thread1,值->存放的值main
21:36:26 [cn.qlq.thread.ten.Demo6]-[INFO] threadName - >thread1,值->存放的值thread1
21:36:26 [cn.qlq.thread.ten.Demo6]-[INFO] threadName - >thread2,值->存放的值thread1
21:36:28 [cn.qlq.thread.ten.Demo6]-[INFO] threadName - >main,值->存放的值main
6.ThreadLocal 源码解析
ThreadLocal其实比较简单，因为类里就三个public方法：set(T value)、get()、remove()。
三个理论基础:
1、每个线程都有一个自己的ThreadLocal.ThreadLocalMap对象 (ThreadLocalMap 是ThreadLocal的静态内部类,一个类似于Map结构的普通类，没有实现Map接口，也是内部维护一个静态内部类Entry存放数据,而且其内部的Entry继承 WeakReference弱引用(被若引用关联的对象只能生存到下一次垃圾回收之前。其内部的key是Threadlocal，value就是存入的值)。)
Thread.class中的一个成员属性:
ThreadLocal.ThreadLocalMap threadLocals = null;
2、每一个ThreadLocal对象都有一个循环计数器
3、ThreadLocal.get()取值，就是根据当前的线程，获取线程中自己的ThreadLocal.ThreadLocalMap，然后在这个Map中根据第二点中循环计数器取得一个特定value值
6.1 set(T value)源码解读
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不为空的话就直接set值，否则走 createMap方法创建map。
(1)getmap(t)从线程中获取 ThreadLocalMap (上面说过了每个Thread都有都有一个自己的ThreadLocal.ThreadLocalMap对象)
ThreadLocalMap getMap(Thread t) { return t.threadLocals; }
(2)map.set(this,value)设置值
/** * Set the value associated with key. * * @param key the thread local object * @param value the value to be set */ 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(); }
/** * Returns the next hash code. */ private static int nextHashCode() { return nextHashCode.getAndAdd(HASH_INCREMENT); }
private final int threadLocalHashCode = nextHashCode(); /** * The next hash code to be given out. Updated atomically. Starts at * zero. */ private static AtomicInteger nextHashCode = new AtomicInteger();
这个Map存储的方式不是链表法而是开地址法。看到设置table中的位置的时候，都把一个static的nextHashCode累加一下，这意味着，set的同一个value，可能在每个ThreadLocal.ThreadLocalMap中的table中的位置都不一样。
- 先对ThreadLocal里面的threadLocalHashCode取模获取到一个table中的位置
- 这个位置上如果有数据，获取这个位置上的ThreadLocal
（1）判断一下位置上的ThreadLocal和我本身这个ThreadLocal是不是一个ThreadLocal，是的话数据就覆盖，返回
（2）不是同一个ThreadLocal，再判断一下位置上的ThreadLocal是是不是空的，这个解释一下。Entry是ThreadLocalMap的一个静态内部类，并且是弱引用，"static class Entry extends WeakReference<ThreadLocal>"，有可能这个 Entry 被垃圾回收了，这时候把新设置的value替换到当前位置上，返回
（3）上面都没有返回，给模加1，看看模加1后的table位置上是不是空的，是空的再加1，判断位置上是不是空的...一直到找到一个table上的位置不是空的为止，往这里面塞一个value。换句话说，当table的位置上有数据的时候，ThreadLocal采取的是办法是找最近的一个空的位置设置数据。
3.这个位置上如果没有数据，就创建一个Entry到这个位置。
(3) createMap(thread,value)方法查看:
void createMap(Thread t, T firstValue) { t.threadLocals = new ThreadLocalMap(this, firstValue); }
ThreadLocalMap(ThreadLocal firstKey, Object firstValue) { table = new Entry[INITIAL_CAPACITY]; int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1); table[i] = new Entry(firstKey, firstValue); size = 1; setThreshold(INITIAL_CAPACITY); }
创建一个ThreadLocalMap并且将引用传递给线程对象的 threadLocals 。
ThreadLocalMap创建的时候做了一些初始化工作，并且将值设置进去。
6.2 get()源码解读
get()方法的源码如下:
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(); }
获取到当前线程-》获取到当前线程里面的ThreadLocalMap -》如果ThreadLocalMap 为不为null，获取其内部的Entry对象-》获取entry的value(根据ThreadLocal 获取一个下标，然后获取对应下标的entry的信息)
private Entry getEntry(ThreadLocal key) { int i = key.threadLocalHashCode & (table.length - 1); Entry e = table[i]; if (e != null && e.get() == key) return e; else return getEntryAfterMiss(key, i, e); }
如果ThreadLocalMap 为null，做默认设置并且返回默认值(这也是我们在上面的例子中继承ThreadLocal重写initialValue方法可以设置默认值的原因)
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; }
protected T initialValue() { return null; }
6.3 remove()源码解读
remove()源码如下:
public void remove() { ThreadLocalMap m = getMap(Thread.currentThread()); if (m != null) m.remove(this); }
private void remove(ThreadLocal key) { 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)]) { if (e.get() == key) { e.clear(); expungeStaleEntry(i); return; } } }
根据当前线程获取到ThreadLocalMap-》如果获取的ThreadLocalMap不为null，调用其remove(key)方法
remove(ThreadLocal)根据ThreadLocal 对象获取一个下标i，如果tab[i]不为null，即存在对应的entry，调用entry的clear方法
补充:clear方法是Reference类型一个方法:--其作用就是将referent置为null，垃圾回收就可以回收此对象。
public void clear() { this.referent = null; }
补充： 每个线程都维护了一个ThreadLocal.ThreadLocalMap类型的对象，而set操作其实就是以ThreadLocal变量为key，以我们指定的值为value，最后将这个键值对封装成Entry对象放到该线程的ThreadLocal.ThreadLocalMap对象中。每个ThreadLocal变量在该线程中都是ThreadLocal.ThreadLocalMap对象中的一个Entry。既然每个ThreadLocal变量都对应ThreadLocal.ThreadLocalMap中的一个元素，那么就可以对这些元素进行读写删除操作。
补充：ThreadLocal内存泄露
内存泄露为程序在申请内存后，无法释放已申请的内存空间。通俗的说，就是：不再会被使用的对象或者变量占用的内存不能被回收，就是内存泄露。
前面了解了java.lang.ThreadLocal.ThreadLocalMap.Entry是一个虚引用，且只针对Key是弱引用：(可以看出来只是将Key虚引用，内部只存了value属性)
static class Entry extends WeakReference<ThreadLocal<?>> { /** The value associated with this ThreadLocal. */ Object value; Entry(ThreadLocal<?> k, Object v) { super(k); value = v; } }
super方法如下： java.lang.ref.Reference#Reference(T)
Reference(T referent) { this(referent, null); }
ThreadLocal 内部各种引用关系如下：(虚线代表虚引用)
ThreadLocal自身并不储存值，而是作为一个key来让线程从ThreadLocal获取value。Entry是中的key是弱引用，所以jvm在垃圾回收时如果外部没有强引用来引用它，ThreadLocal必然会被回收。但是，作为ThreadLocalMap的key，ThreadLocal被回收后，ThreadLocalMap就会存在null，但value不为null的Entry。若当前线程一直不结束，可能是作为线程池中的一员，线程结束后不被销毁，或者分配（当前线程又创建了ThreadLocal对象）使用了又不再调用get/set方法，就可能引发内存泄漏。其次，就算线程结束了，操作系统在回收线程或进程的时候不是一定杀死线程或进程的，在繁忙的时候，只会清除线程或进程数据的操作，重复使用线程或进程（线程id可能不变导致内存泄漏）。因此，key弱引用并不是导致内存泄漏的原因，而是因为ThreadLocalMap的生命周期与当前线程一样长，并且没有手动删除对应key。也就是线程池中使用的时候会有内存泄漏的问题。
为了避免内存泄露，正确的使用方法是：在使用完ThreadLocal时，及时调用它的的remove方法清除数据。
