前言
ThreadLocal是开发中常会使用的一个工具，从类的名字就可以看出，它为线程提供本地变量。即：每个线程私有的数据。提供的实际上就是一种线程隔离，不同的线程的变量归属不同的线程，线程之间不能想问访问各自的变量，当线程生命周期结束的时候，线程会被销毁。之前只知道它的作用，大概还了解一点原理知道内部用的是Map，今天又遇见了，于是有了这篇源码分析。
使用方法
Entity 存放线程要保存的信息
ThreadLocal<Entity> threadLocal = new ThreadLocal<Entity>();
//为线程设置私有数据
threadLocal.set(new Entity());
//拿出线程私有数据
threadLocal.get();
Thread成员变量
public class Thread implements Runnable {
//每一个线程会有唯一的一个ThreadLocalMap类型变量，用来保存该线程所有的私有数据
ThreadLocal.ThreadLocalMap threadLocals = null;
}
成员变量
线程hashcode值来标识线程，nextHashCode()是获得下一次的值
private final int threadLocalHashCode = nextHashCode();
AtomicInteger类型的hashcode，从0开始
private static AtomicInteger nextHashCode = new AtomicInteger();
每次hash增长的值
private static final int HASH_INCREMENT = 0x61c88647;
AtomicInteger是通过自选式的CAS操作来维护原子性的，读取，计算。
构造函数
public ThreadLocal() {}
构造函数很简单，啥也没有。
set方法
ThreadLocalMap的set()方法，从上面知道每一个线程有个ThreadLocalMap的实例，用来保存该线程的私有数据(一个线程可能会存很多不同类型的私有数据)。
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
//该线程的threadLocals已经初始化过，则调用ThreadLocalMap的set()方法，
将数据push进来，否则调用createMap()函数初始化该变量
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
关键的是getMap这个方法，它把Thread传进getMap去获得ThreadLocalMap。ThreadLocal.ThreadLocalMap threadLocals = null；虽然写在了Thread中，但是用的确实ThreadLocal中的map。初次使用map一定为空，这个时候就会创建map。
getMap方法
ThreadLocalMap getMap(Thread t) {
//返回该线程的threadLocals变量
return t.threadLocals;
}
createMap方法
void createMap(Thread t,T firstValue){
t.threadLocals = new ThreadLocalMap(this,firstValue);
}
ThreadLocalMap
抛砖引玉，我们进入ThreadLocalMap中，ThreadLocalMap 构造方法：
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
//数据是保存在一个数组里面的，初始长度为16
table = new Entry[INITIAL_CAPACITY];
//计算数据放在数组的哪个位置，根据ThreadLocal 的threadLocalHashCode值来计算的
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
//以ThreadLocal实例为key，放入实际的数据
table[i] = new Entry(firstKey, firstValue);
size = 1;
setThreshold(INITIAL_CAPACITY);
}
由这个构造函数，我们可以画出ThreadLocal所用的map结构。
图中，黄线代表弱引用。我们挑出这两个重要的引用，别的不用特别看。需要注意的是，当弱引用作为不可达对象的时候，会在下一次GC的时候会被回收。Entry是继承了弱引用的。脑子里先有这个大体架构。
Entry
Entry类实际存储着数据，继承 WeakReference
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
//保存放进来的线程私有数据
value = v;
}
}
set方法
ThreadLocalMap set方法
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
//计算数据放入的位置
int i = key.threadLocalHashCode & (len-1);
//检测hash冲突，如果该位置已经放入了一个数据(e!=null)，则线性地向后查找第一个合适的位置
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
//Entry 继承自WeakReference，所以用get()方法，可以直接拿到需要的key(ThreadLocal的实例)
ThreadLocal<?> k = e.get();
//找到一个位置，k和当前要插入的key值相同，更新该位置的数据
if (k == key) {
e.value = value;
return;
}
//找到一个位置已经有数据，但是key为null，则替换掉废弃的key
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
//将key-value存储到Entry中，放在数组的i位置
tab[i] = new Entry(key, value);
int sz = ++size;
//判断是否需要扩展数组，这里是长度大于数组长度的2/3时扩展数组
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
代码逻辑比hashMap简单多了，hashMap是拉链法，它这边直接使用的table数组，如果那个位置已经有了对象，就nextIndex，探测下一个位置，就是标准的线性探测法解决冲突，HashMap是链地址法。就是如果冲突了就向后再挂一个对象。由此我们引入内存泄露的问题。
以上就将某个数据保存到线程私有数据中了，总结一下：Thread中有个ThreadLocalMap实例，ThreadLocalMap中有个数组：Entry[] table；，Entry中实际保存了数据value。也就是说一个线程可以有n多个私有数据，存放在ThreadLocalMap中，每一个私有数据对应一个ThreadLocal实例和一个Entry实例。
取出数据
ThreadLocal的get()方法：
public T get() {
Thread t = Thread.currentThread();
//还是首先要拿到ThreadLocalMap实例
ThreadLocalMap map = getMap(t);
if (map != null) {
//以自己为key，从map中取出实际保存的数据，上面说过：数据是以ThreadLocal为key，实际数据为value
// 保存到Entry对象中的
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T) e.value;
return result;
}
}
return setInitialValue();
}
ThreadLocalMap的getEntry()方法：
private Entry getEntry(ThreadLocal<?> key) {
//计算数组下标，和放入数据时一样
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
//当前位置有数据，且key和要需要的一致，说明该位置保存了要的数据
if (e != null && e.get() == key)
return e;
else
//散列冲突，根据需要的key线性向后查找
return getEntryAfterMiss(key, i, e);
}
getEntryAfterMiss
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
while (e != null) {
ThreadLocal<?> k = e.get();
if (k == key)
return e;
if (k == null)
expungeStaleEntry(i);
else
i = nextIndex(i, len);
e = tab[i];
}
return null;
}
不难看出在最后expungeStaleEntry(i)，也执行了一次清理。
remove方法
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;
}
}
}
remove方法是最正宗的手动清除了
get和set、remove的分析
由上面的分析不难发现，在进行set方法的时候是清除some，get和remove的时候是大清除，如果是同一个线程执行代码的话，那么还可以通过多次的get，set进行清楚，如果是多线程的环境下，你用了不remove，极有可能会造成内存泄漏，不完全清理的问题也可能存在。
内存泄露
cleanSomeSlots
这里面的细节小逻辑，新手也看不懂，但是需要挑出来的是这里的cleanSomeSlots，清除引用，因为key ThreadLocal是弱引用，当外面没有强引用引用它的时候，即成为无法到达的key将会被GC掉，但是这个时候会存在键为null的value还没有被清除，所以就要通过这个方法去清除。这个清除方法就不贴出来了，只要知道它是一次遍历看看有哪些key为null的，然后将值设置为null来帮助GC。
总结
总结下来就是，set方法会触发一次清除弱引用残留下来的value值。同样get和remove也会进行清理。线程不结束，那么这个Thread引用链将会永远存在。所以用完了remove掉是个好习惯。也是必须这样用的。
此次就ThreadLocal这个类的实现进行了分析，从get、set、remove这三个方法把内存泄漏的问题搞清楚了，它的内部是Thread维护的一个Map属性，键是ThreadLocal变量key，值是set进去的值，冲突处理是线性探测法。
经典一句:
同步机制以时间换空间，多个线程排队等待资源释放。ThreadLocal空间换时间每个线程单独一份资源，互不相干。妙哉妙哉。
参考链接
https://www.sczyh30.com/posts/Java/java-concurrent-threadlocal/
http://blog.xiaohansong.com/2016/08/06/ThreadLocal-memory-leak/
为什么ThreadLocal内部用的是弱引用？大概是因为内部ThreadLocalMap不是人new出来的，它不归人管，而是在内部使用的，倘若new出来的ThreadLocal变量被gc了，那么ThreadLocalMap中引用ThreadLocal的Entry也应该被gc，这就是所说的弱引用一旦没有了别处的引用就会被gc这个道理，Entry继承的是WeakReference，它应该被回收，毕竟key是ThreadLocal
实际案例
public class HelloWorldExample extends HttpServlet {
private static final long serialVersionUID = 1L;
static class LocalVariable {
private Long[] a = new Long[1024 * 1024 * 100];
}
final static ThreadLocal<LocalVariable> localVariable = new ThreadLocal<LocalVariable>();
@Override
public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException,
ServletException {
//(2)
localVariable.set(new LocalVariable());
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println("<html>");
out.println("<head>");
out.println("<title>" + "title" + "</title>");
out.println("</head>");
out.println("<body bgcolor=\"white\">");
//(3)
out.println(this.toString());
//(4)
out.println(Thread.currentThread().toString());
out.println("</body>");
out.println("</html>");
}
}
在Servlet中，有一个类为ThreadLocal的静态变量，打个比方，如果说有5个线程访问这个Servlet实例，Servlet 为5个线程都创建了map，但是没有进行remove久而久之内存自然会蹭蹭往上，用完了线程没有被销毁而是回到了线程池里面，当Thread被销毁了还好，强引用链断了，自然就会被销毁了。官方tomcat在7.0+的时候会解决这个问题，上面的from连接最后给出了答案，重新启动的时候线程会被renew。
不得不注意的问题: 试想一下，当Thread被销毁的时候，静态变量是在类加载的时候就初始化了的，所以说内存中除非JVM停掉，那么这个静态变量永远会存在，即使Thread线程被回收了，那么这个ThreadLocal引用还是存在的，所以remove方法对ThreadLocalMap中的引用清除是清除了就是说map里面的Entry被清掉了，但是这个强引用new 出来的实例依旧是存在的。
总结一下: 用完了就remove掉，静态变量会一直存在。
