【Java8源码分析】线程-ThreadLocal的全面剖析

一、背景

ThreadLocal类顾名思义就是，申明为ThreadLocal的变量，对于不同线程来说都是独立的。

下面是一个例子：

public class Test {

public static void main(String[] args) {
ThreadLocalTest threadLocalTest = new ThreadLocalTest();

for(int i = 0; i < 3; i++) {
TaskTest taskTest = new TaskTest(threadLocalTest);
Thread t = new Thread(taskTest);
t.start();
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

static class TaskTest implements Runnable{
ThreadLocalTest test;

public TaskTest(ThreadLocalTest test) {
this.test = test;
}

@Override
public void run() {
int tmp = test.localCnt.get();
test.localCnt.set(tmp + 1);
test.shareCnt += 1;
System.out.println(Thread.currentThread().getName());
System.out.println("LocalCnt:" + test.localCnt.get());
System.out.println("SharedCnt:" + test.shareCnt);
}
}

static class ThreadLocalTest
{
ThreadLocal<Integer> localCnt = new ThreadLocal<Integer>() {
public Integer initialValue() {
return 0;
}
};

int shareCnt = 0;

public ThreadLocalTest() {

}
}
}

输出结果:

Thread-0
LocalCnt:1
SharedCnt:1
Thread-1
LocalCnt:1
SharedCnt:2
Thread-2
LocalCnt:1
SharedCnt:3

基本原理：ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。因为每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的变量封装进ThreadLocal。

二、存储结构

在ThreadLocal类中定义了一个重要静态内部类，ThreadLocalMap，用来存储每个线程的局部变量，代码如下

static class ThreadLocalMap {

// Entry继承自WeakReference类，是存储线程私有变量的数据结构
// ThreadLocal实例作为引用，意味着如果ThreadLocal实例为null
// 就可以从table中删除对应的Entry。
static class Entry extends WeakReference<ThreadLocal<?>> {

Object value;

// 把ThreadLocal与value封装成Entry
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}

// 数组初始大小为16
private static final int INITIAL_CAPACITY = 16;

// 存储数组
private Entry[] table;

private int size = 0;
private int threshold; // 默认为0
private void setThreshold(int len) {
threshold = len * 2 / 3;
}

private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}

private static int prevIndex(int i, int len) {
return ((i - 1 >= 0) ? i - 1 : len - 1);
}

// 构造函数
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);
}

private ThreadLocalMap(ThreadLocalMap parentMap) {
Entry[] parentTable = parentMap.table;
int len = parentTable.length;
setThreshold(len);
table = new Entry[len];

for (int j = 0; j < len; j++) {
Entry e = parentTable[j];
if (e != null) {
@SuppressWarnings("unchecked")
ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
if (key != null) {
Object value = key.childValue(e.value);
Entry c = new Entry(key, value);
int h = key.threadLocalHashCode & (len - 1);
while (table[h] != null)
h = nextIndex(h, len);
table[h] = c;
size++;
}
}
}
}

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;
}

if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}

tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
}

三、主要方法

public class ThreadLocal<T> {

// 跟hash值相关的部分
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);
}

// 此方法在每个线程中最多执行一次，如果第一次执行get()，会调用此方法
// 如果在第一次执行get()之前已经调用过set()，则此方法永远不执行
// 可以看到默认返回null值，为了避免不必要错误，最好重写此方法
protected T initialValue() {
return null;
}

// 构造函数
public ThreadLocal() {
}

// 获取线程所属的值
public T get() {

// 获取当前线程
Thread t = Thread.currentThread();

// 每个线程有维护一个ThreadLocalMap变量，调用getMap获取
ThreadLocalMap map = getMap(t);

// 如果map不为空
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);

// 如果map中已经有该ThreadLocal的值，返回
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}

// 在没有map或map中没有添加该ThreadLocal时调用初始化
return setInitialValue();
}

// 初始化
private T setInitialValue() {
// 调用initialValue获取默认值
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
// 如果Thread中并没有map，则新建一个
// 这里注意，是每个Thread维护一个ThreadLocalMap
createMap(t, value);
return value;
}

// 赋值
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
// 这里同样有可能调用创建ThreadLocalMap
createMap(t, value);
}

public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}

// 返回Thread中维护的TreadLocalMap
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}

// 如果Thread中并没有map，则新建一个
// 这里注意，是每个Thread维护一个ThreadLocalMap
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
}

四、总结

ThreadLocal类最重要的一个概念是，其原理是通过一个ThreadLocal的静态内部类ThreadLocalMap实现，但是实际中，ThreadLocal不保存ThreadLocalMap，而是有每个Thread内部维护

ThreadLocal.ThreadLocalMap threadLocals

一份数据结构。

这里画张图更容易理解，假如我们有如下的代码

class ThreadLocalDemo
{
ThreadLocal<Integer> localA = new ThreadLocal<Integer>();
ThreadLocal<Integer> localB = new ThreadLocal<Integer>();
}

在多线程环境下，数据结构应该是如下图所示