源码分析--ThreadLocal
一、序言
这里会分析ThreadLocal 源码以及原理，和它的正确使用原则，还有我们应用过的地方，帮助大家更深刻的理解这个类的使用。
ThreadLocal 在JDK1.2的版本的就提供的一个类，它提供了一种新的思路去解决多线程问题，同时ThreadLocal 不是线程类，仅仅是一个线程的变量副本，他是如何来实现这个功能的呢，我们从源码进行分析。
二、源码分析
// 仅仅是一个单独的类，没有除Object外的其他父类
public class ThreadLocal<T> {...}
我们还是从基本的API 方法分析，其中包括get()，initialValue()，remove()，set(T value) 方法：
2.1 get() : 返回此线程局部变量的当前线程副本中的值
public T get() {
// 回先获得当前线程
Thread t = Thread.currentThread();
// 然后获得线程t 里面的变量threadLocals，看下面的方法getMap()
// 这里变量其实是个map,具体实现，我们先分析几本原理，再分析实现
ThreadLocalMap map = getMap(t);
if (map != null) {
// 然后获得当前里面的值，这里可以参考hashMap 的实现原理
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null)
return (T)e.value;
}
// 如果没有获得值，表示还没set 值，就会返回初始值
// 这里是初始化ThreadLocal 的方法。
return setInitialValue();
}
// 注意：这里是从Thread 获得的变量
// 关于ThreadLocalMap是个什么东西，我们先介绍几本原理，在详细分析。
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
2.2 initialValue() 返回此线程局部变量的当前线程的“初始值”。
这是源码，我们可以这样使用
protected T initialValue() {
return null;
}
// 这是API 介绍的，我们可以按类似的方式给它赋初始值
// 可以看出这个是protected 的initialValue 准备让子类重写的
// 这个值仅仅作为初始化用，当第一次执行set 方法的时候，就会覆盖这个值，但是初始值始终存在。
// 让你remove 的之后，在次进行get 就会返回初始值
private static final ThreadLocal <Integer> uniqueNum =
new ThreadLocal<Integer> () {
@Override
protected Integer initialValue() {
return 1;
}
};
2.3 set(T value) 将此线程局部变量的当前线程副本中的值设置为指定值。
public void set(T value) {
// 同样是获得当线程，和里面的变量map.然后set 值
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
// 这里变量第一次为 null 的情况，会创建一个新对象。
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
// 可以看出这是ThreadLocal 的内部类
static class ThreadLocalMap {
// 内部类里面还构建了一个内部类，这个内部类
static class Entry extends WeakReference<ThreadLocal> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal k, Object v) {
super(k);
value = v;
}
}
}
2.4 remove() 移除此线程局部变量当前线程的值。
public void remove() {
// 这里也是传入当前线程，然后操作变量map
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
结论：从上面的基本方法可以看出，我们都是获得Thread.currentThread()，然后操作里面的一个ThreadLocalMap类型的变量完成了保存对象的任务，这也就完成了和线程之间的绑定，至于为什么是线程的一个变量呢，我这里再帖一下Thread的源码。
public class Thread implements Runnable {
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
// 可以看出Thread 类，对 ThreadLocalMap 的引用。
ThreadLocal.ThreadLocalMap threadLocals = null;
}
那么我们现在看看 ThreadLocalMap 到底是干嘛的呢？
三、ThreadLocalMap 源码分析
// 这是ThreadLocal的一个内部类
static class ThreadLocalMap {
// 这又是一个内部类，继承与弱引用，至于弱引用这里暂时不详细介绍
// 可以参考JVM 里面的的引用类型 和 GC回收机制
// 看过hashMap 源码的人，肯定比较熟悉这种写法
// 实现的是一种K,V 的内部类机制
static class Entry extends WeakReference<ThreadLocal> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal k, Object v) {
super(k);
value = v;
}
}
}
3.1 构造函数
// 这里参考hashMap 的方式设计，就不多多介绍了
// 一个放着entry 的数组table
ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
table = new Entry[INITIAL_CAPACITY];
// 这里hashCode 的取值比较特别，我们单独分析
// 根据hashCode 和长度取余运算
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
setThreshold(INITIAL_CAPACITY);
}
3.2 特殊的hashCode 值
// 这里看出，这个hashCode 值在创建ThreadLocal 对象的时候就创建了
private final int threadLocalHashCode = nextHashCode();
// 1640531527
// 这里为什么要用这个数字，我还真不清楚，但是能确定是为了更均匀的分布
// 这个和hashMap 的 hashCode 计算方式一样，应该都有进行专门的测试，以后再研究这个
private static final int HASH_INCREMENT = 0x61c88647;
private static AtomicInteger nextHashCode = new AtomicInteger();
// 这里我们可以看出hashCode 居然是不停的加上HASH_INCREMENT 进行
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
3.3 set 方法：这里是内部类如何存放值得
private void set(ThreadLocal key, Object value) {
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;
}
// 如果存放的k为null,可能被回收了,也就是过去了嘛
// 这里就把以前这个位置的信息覆盖，以前的就没了。
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
// 都没有的情况下，从新创建一个
tab[i] = new Entry(key, value);
int sz = ++size;
// 这里又会检测过期元素，并删除过期的，
// 如果没有过期的，超过限制范围，就会扩容
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
3.4 getEntry 方法：返回这个对象，就能获得值
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);
}
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;
}
3.5 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) {
// 这里删除仅仅是引用设置为null 就行了。
e.clear();
expungeStaleEntry(i);
return;
}
}
}
结论：我们可以看出内部类的实现，是对一个继承了弱应用的的K.V entry 的操作。我们看出每一次操作都会去检测一那些对象为空了，然后进行删除。同时也看出了它的操作虽然类似map,但是却不是操作的map.关于弱引用的作用我这里简答描述是：当某对象已经不使用了，为null的情况下，为了不让强引用占有这个空间，那么弱引用能加快GC的一种手段。
四、应用场景
4.1 描述：
ThreadLocal 提供一种新的思路去解决多线程问题，是解决什么问题呢？又是如何解决呢？
在多线程并发中，我们常常遇到的问题是共享资源的操作，常用的办法是加锁机制，但是这种机制负面影响比较多。然后ThreadLocal 提供一种保存带状态的共享变量的副本的方式，来隔绝各个线程中带来的影响，以空间换时间。
4.2 实例1：
比如：Spring 中，我们常用的单利模式，假设我一个Count 类，里面有个属性num,用来观察某一时刻的浏览数量。
public static class Count{
public static int num = 0;
}
在多线程中，不是使用加锁等手段，如果A 线程在A时刻先将num 变成100，然后准备访问之前，这时候B线程在B时刻将num 变成200.然后在由A线程去访问，返回200，明显是有错误的。当然创建多个Count也可以解决，那么我们在不创建的多个Count 对象的情况下，如何保证安全呢？
我们可以在A B线程创建一个ThreadLocal 变量，然后当A线程将num 变成100的时候，同时将这这个100的值，存放在ThreadLocal 里面，那么下次访问就从变量里面提取，就不会错误了，当然由于业务原因，这里例子不太好，但是道理类似。
实例 2：这里我copy 的网上hibernate 里面Session 的例子：
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;
}
可以看出，每个线程保存一份session,方便下次使用，同时各自有各自的状态，同时也会随着线程的退出而快速的清理这个副本。
实例3 ：这里简单的原理，我直接贴下代码，大家感受一下：
static class A {
public boolean flag = false;
}
public static void main(String[] args) throws InterruptedException {
ThreadLocal thread = new ThreadLocal();
A a = new A();
thread.set(a.flag);
a.flag = true;
// 虽然一个线程，但是变量值是可以做个隔离的
System.out.println(thread.get() +":"+a.flag);
}
五、Thread 和 ThreadLocal 关系和原理：
// 这里我们已经说过每个Thread 里面都有 引用，变量副本主要是通过
// 操作内部类进行实现的
ThreadLocal.ThreadLocalMap threadLocals = null;
// 这个变量作用是为可以子线程访问父线程的变量而准备的。
// 这里我们暂时不做详细介绍，原理都差不多
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
下面我再看看线程退出的时候，默认会调exit()方法：
private void exit() {
if (group != null) {
group.remove(this);
group = null;
}
// 这里看到， 线程退出，会将这个设置为空
// 由前的源码分析可以看出，当key 为空的时候会被清除
// 加快GC
threadLocals = null;
inheritableThreadLocals = null;
inheritedAccessControlContext = null;
blocker = null;
uncaughtExceptionHandler = null;
}
总结：
1.ThreadLocal我仅仅分析了大部分源码， 还有一部分没分析，感兴趣的朋友可以共同讨论
2.强调两点：
a.ThreadLocal不是线程，仅仅是存放变量的的一个副本，每个Thread都有引用
b.ThreadLocal实现不是map,虽然类似！它主要用来存放有变化的状态，用于隔离多线程的影响
3.JDK 建议创建以static final 为主，节约内存。
4.关于使用原则，只能大家对原理机制理解了，就知道什么地方该用了
5.上面仅限于自己理解，如果有异议的地方请指出，还有不懂，或者其他想法的朋友，希望多沟通讨论。
上一篇： 源码分析-ConcurrentLinkedQueue
下一篇： available 的理解和一些使用