ThreadLocal详解(AtomicInteger相关)
- 注意, 本文是以熟悉HashMap源码为前提下开讲, 如果不熟悉HashMap的数据结构, 可以先行了解HashMap再来理解本文.
- 本文以JDK1.7进行讲解.
在学习Handler机制的过程中, 了解到Looper的成员属性消息队列MessageQueue是通过ThreadLocal实现了每个线程只有一个Looper对象, 每个Looper对象只有一个MessageQueue对象.
实际上, 通常我们把ThreadLocal作为线程隔离的工具使用.
没接触过Android的Handler机制的朋友, 下面讲述的内容不会影响你理解ThreadLocal源码.
分析源码要有的放矢, 带着问题去分析ThreadLocal源码:
首先提出问题: 为什么ThreadLocal可以作为线程隔离的工具?
问题提出后, 开始分析ThreadLocal, 列出常用的两个成员方法:
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
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();
}
分析以上两个方法:
1. ThreadLocal#set(T value):
- Thread t = Thread.currentThread(); 获取当前线程
- ThreadLocalMap map = getMap(t);获取当前线程的对应的ThreadLocalMap对象, getMap(t)方法实现为:
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
- 当map !=null; 或map == null;分别执行map.set(this, value); 和 createMap(t, value);方法, 第一次执行set(T value)方法时本地变量map肯定为null, 所以会执行createMap(t, value);
/**
* 此方法其实就是浓缩了HashMap精髓的方法
*/
private void set(ThreadLocal key, Object value) {
Entry[] tab = table;
int len = tab.length;
//这里出现了threadLocalHashCode
int i = key.threadLocalHashCode & (len-1);//计算数组下标
//如果在数组table中以下标为i的元素的链表中能找到(方法传进来的)以key为成员属性的Entry对象, 则把该Entry对象的value成员属性修改为(方法传进来的)value, 并return返回本方法
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;
}
}
//如果for循环中没有找以key为成员属性的Entry对象, 则新创建一个Entry对象, 并放到table数组中
tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
table = new Entry[INITIAL_CAPACITY];
//threadLocalHashCode又出现了
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
//ThreadLocal对象作为key, firstValue作为value保存在Entry中
table[i] = new Entry(firstKey, firstValue);
size = 1;
setThreshold(INITIAL_CAPACITY);
}
可以看出执行了createMap(Thread t, T firstValue)后, 当前Thread对应的ThreadLocalMap对象threadLocals不再为null.
在这个方法中也可以清楚的看出, ThreadLocalMap是以ThreadLocal对象作为key保存传进来的值.
值得注意的是, 此方法如果在同一个线程中调用多次, 后面的对象会替换前面设置的对象.
2. 分析ThreadLocal#get()方法:
本方法很简单:- List item当在get()方法执行前如果先执行了set(T value)方法后, 本地变量map不再为null, 所以, 会获取到set(T value)方法传进来的value值.
- 如果没有先执行set()方法, 那么get()方法最终会执行setInitialValue()方法, 最终返回一个null值.
为什么ThreadLocal可以作为线程隔离的工具:
- 每次set的时候, 都获取所在线程的对象Thread. - 每个Thread只对应唯一一个ThreadLocalMap对象. - 通过这个ThreadLocalMap对象保存set(T value)传递进来的值. - 通过这个ThreadLocalMap对象获取对应的value值. - 以上只保证了一个线程对应的一个ThreadLocalMap对象, 保证一个线程中某个类只有一个实例, 但不保证一个线程中该类一直是同一个实例. - 所以如果我们需要某个线程只有唯一一个不变的实例, 需要在设计上做做文章. 例如我们定义一个类,一个线程中只有一个该类的对象:/**
* 自定义Looper
*/
public class Looper {
/**
* 静态
*/
final static ThreadLocal<Looper> testThreadLocal = new ThreadLocal<>();
/**
* 不允许new
*/
private Looper() {
}
/**
* 通过此方法创建本类实例
*/
public static void prepare() {
//在set之前先get
if (testThreadLocal.get() != null) {
throw new RuntimeException("每个线程只能调用一次prepare()方法");
}
testThreadLocal.set(new Looper());
}
/**
* 通过此方法获取本类实例
*
* @return
*/
public static Looper myLooper() {
return testThreadLocal.get();
}
}
以上设计可以保证一个Thread对应一个ThreadLocal, 也保证了一个Thread只对应某个类的实例.
PS:
前面提到ThreadLocal吸收了HashMap的精髓, 是一种特殊的HashMap, 而HashMap中, 存在计算hash问题, 那么ThreadLocal的hash值呢? 这就要分析ThreadLocal的一个普通成员threadLocalHashCode及相关三个static成员:private final int threadLocalHashCode = nextHashCode();
private static AtomicInteger nextHashCode = new AtomicInteger();
private static final int HASH_INCREMENT = 0x61c88647;
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
- 要记住一点: static成员属于类, 不属于对象, 所以, 他们是唯一的, 只加载(初始化)一次.
- nextHashCode 这个AtomicInteger实例, 它有一个成员属性value, 如果使用无参构造函数创建, 所以这里它的初始默认值是0.
- threadLocalHashCode 相当于ThreadLocal的hashCode, ThreadLocal就靠这个值实现线程隔离的.
- 每次new ThreadLocal 对象出来后, threadLocalHashCode 都会重新赋值.
- 追踪代码可以看到其调用了AtomicInteger类的方法:
public final int getAndAdd(int delta) {
for (;;) {
//获取原来的值, 最初默认值为0(重点)
int current = get();//获取AtomicInteger#value
//设置期望值
int next = current + delta;
//如果current == AtomicInteger#value, 则赋值AtomicInteger#value = next
if (compareAndSet(current, next))
return current;//返回原AtoomicInteger#value值
}
}
方法分析:
- getAndAdd(int delta)方法作用就是死循环获取一个值赋值给ThreadLocal#threadLocalHashCode.
- 因为ThreadLocal的成员属性nextHashCode是static, 所以所有ThreadLocal对象都共享同一个AtomicInteger对象, 这个AtomicInteger对象的value初始默认值为0, for循环中:
- 首先获取value的值, 赋值current保存起来;
- 然后设置一个期望 next = current + delta;
- 然后通过调用compareAndSet方法进行比较和交换.
- 如果这个过程中, value没有被改变, 当执行compareAndSet(current, next)时current等于value;
- 那么赋值value, value = next;返回current并赋值给ThreadLocal#threadLocalHashCode;
- 此时, 该ThreadLocal对象的成员属性threadLocalHashCode值为0;
- 如果重新创建ThreadLocal对象, 因为所有ThreadLocal对象共用一个AtomicInteger对象, 那么这个新创建的ThreadLocal对象的threadLocalHashCode成员属性又会继续执行上述方法. 而唯一不一样的地方在于: 该AtomicInteger对象的value的值为上一次交换后的值(重点), 以此类推!
- 上述过程, 保证了不管有多少个ThreadLocal对象, 他们的threadLocalHashCode都是不一样!
getAndAdd(int delta)最后会调用compareAndset()方法:
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
最终会调用Unsafe类的compareAndSwapInt()方法, 通过原子操作实现了CAS(Compare And Swap)操作，compareAndSwapInt()方法跟踪到最后, 最底层基于汇编语言实现。 跟系统(CPU指令集)挂钩, 这里就不深究了.
编程中, 设定"原子"代表最小的单位，所以原子操作可以看做最小的执行单位，该操作在执行完毕前不会被任何其他任务或事件打断。
AtomicInteger类相关测试:
/**
* Created by tgvincent on 2019/7/8.
* 并发编程, 测试{@link java.util.concurrent.atomic.AtomicInteger}
*/
public class AtomicIntegerTest {
//volatile让num对线程可见(即变化可被线程感知)
private volatile int num = 10;
public static void main(String[] args) {
AtomicIntegerTest test = new AtomicIntegerTest();
int temp = test.num;
System.out.println("test.num: " + test.num);
System.out.println("temp: " + temp);
AtomicInteger atomicInteger = new AtomicInteger(test.num);
new Thread(() -> {
for (int i = 0; i < 1000; i++) {
test.num++;
}
}).start();
try {
Thread.sleep(3000);//休眠3秒确保上述线程执行完毕
System.out.println("=================After thread execution=================");
System.out.println("test.num: " + test.num);
System.out.println("temp: " + temp);
boolean cas = atomicInteger.compareAndSet(test.num, 999);
int result = atomicInteger.get();
/**
* test.num 已经变为1010, != 10, 所以, {@link AtomicInteger#compareAndSet(int, int)}
* 不会发生交换, 所以{@link AtomicInteger#get()} 还是原来的值10
*/
System.out.println("is swap?: " + cas +", result: "+ result);
/**
* temp为10, == 10, 所以, {@link AtomicInteger#compareAndSet(int, int)}
* 发生交换, 交换之后, {@link AtomicInteger#value}为999,
* 所以{@link AtomicInteger#get()} 获取的值为999
*/
cas = atomicInteger.compareAndSet(temp, 999);
result = atomicInteger.get();
System.out.println("is swap?: " + cas +", result: "+ result);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
测试结果:
test.num: 10
temp: 10
=================After thread execution=================
test.num: 1010
temp: 10
is swap?: false, result: 10
is swap?: true, result: 999
补充问题: 为什么是0x61c88647? 以下为网上搜索的资料:
- 生成hash code间隙为这个魔数，可以让生成出来的值或者说ThreadLocal的ID较为均匀地分布在2的幂大小的数组中。
- 可以看出，它是在上一个被构造出的ThreadLocal的ID/threadLocalHashCode的基础上加上一个魔数0x61c88647的。
- 这个魔数的选取与斐波那契散列有关，0x61c88647对应的十进制为1640531527。
- 斐波那契散列的乘数可以用(long) ((1L << 31) * (Math.sqrt(5) - 1))可以得到2654435769，如果把这个值给转为带符号的int，则会得到-1640531527。换句话说(1L << 32) - (long) ((1L << 31) * (Math.sqrt(5) - 1))得到的结果就是1640531527也就是0x61c88647。
- 通过理论与实践，当我们用0x61c88647作为魔数累加为每个ThreadLocal分配各自的ID也就是threadLocalHashCode再与2的幂取模，得到的结果分布很均匀。
- ThreadLocalMap使用的是线性探测法，均匀分布的好处在于很快就能探测到下一个临近的可用slot，从而保证效率。为了优化效率。