一、序言
这里会分析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.上面仅限于自己理解,如果有异议的地方请指出,还有不懂,或者其他想法的朋友,希望多沟通讨论。