ThreadLocal

ThreadLocal是java.lang包下、从JDK1.2开始提供的一个类，而且JUC并发包的作者Doug Lea大神也参与了该类的编码。在多线程编程中，ThreadLocal能提供很不错的技术支持。

 

Thread线程，Local局部的，ThreadLocal即线程局部的值。使用ThreadLocal提供的方法能够将一个值绑定到当前线程上，或从该线程上解除绑定。（当前线程指的是调用了ThreadLocal的set方法的线程）

将一个值绑定到当前线程上，有两种实现方式。第一种是直接对Thread类进行修改，对外提供一个方法（比如setXX）来将值设置到线程对象上。第二种就是像ThreadLocal这样，提供一个工具类处理某个值与线程之间的关系。对于JDK使用第二种方式提供一个工具类ThreadLocal而不是直接改造Thread的原因，我的理解是因为Thread类是从JDK1.0中就提供的，如果再往后版本的JDK中对Thread类进行对外暴露方法的添加，这样就破坏了高内聚低耦合的性质，况且直接去使用Thread来绑定值的话，也会造成使用方面的安全性。

---

先来看这样的一个例子：

public void method1() {

    String str = "hello world";

    method2();

}

public void method2() {

}

有两个方法，分别为method1、method2。在方法method1中定义了一个字符串局部变量str。思考：如何在method2中访问到局部变量str，并将其输出到控制台。

①实现方式1：修改method2，增加参数传入：

public void method1() {

    String str = "hello world";

    method2(str);

}

public void method2(String str) {
    System.out.println(str);
}

 ②实现方式2：借助ThreadLocal：

private ThreadLocal<String> threadLocal = new ThreadLocal<>();

public void method1() {

    String str = "hello world";
    // 使用set方法，将字符串绑定到当前线程中
    threadLocal.set(str);

    method2();

}

public void method2() {
    String str = threadLocal.get();
    System.out.println(str);
}

此种实现方式，借助了ThreadLocal，在不用修改方法结构的同时能够实现功能。对比两种实现方式，显然第二种实现方式使用ThreadLocal没有破坏方法的结构的方式在更好的。

下面就从ThreadLocal的set、get方法开始探究ThreadLocal的工作原理。

---

█ ThreadLocal

• set

通过ThreadLocal将某个值与当前线程Thread绑定到一起。也就是相当于map.set(threadLocal, value)。

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

①Thread t = Thread.currentThread();

获取当前线程，即调用set方法的线程。set方法在哪个线程中被调用，则会将参数传进来的value值绑定到该线程上。

②getMap

将当前线程对象作为参数传进getMap方法中。

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

直接获取当前线程对象t中的字段threadLocals。

关于threadLocals，其是在Thread类中定义的一个全局变量，从声明上看，threadLocals的类型为ThreadLocalMap，并且访问权限为默认的权限，即只有和Thread在同一个包下才能访问到该变量。因为ThreadLocal与Thread在同一个包下，因此ThreadLocal可以访问到threadLocals。

ThreadLocal.ThreadLocalMap threadLocals = null;

ThreadLocalMap是Thread中定义的一个内部类，从名称上看，其本质上是一个Map，是一个key为ThreadLocal对象，value为ThreadLocal中set方法的参数值。可以简单理解成这样：Map<ThreadLocal, T> ThreadLocalMap = new HashMap<>();正因为key为ThreadLocal对象，因此结合Map的特点，一个ThreadLocal一次只能与一个值对应。

③if (map != null)

获取到当前线程Thread对象中的threadLocals ，threadLocals的初始值是为null的，即在第一次调用之前，threadLocals==null，不满足map!=null的条件，需要先对其进行初始化。

④createMap

方法参数为当前线程对象，和当前要绑定的值。

void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

 初始化很简单，就是创建一个ThreadLocalMap对象，并将其赋值给当前线程对象的threadLocals，这样就完成了对threadLocals的初始化。

⑤map.set(this, value);

当threadLocals已经完成了初始化，第二次再调用set方法时，if (map != null)条件语句就成立了，直接调用threadLocals的set方法将当前ThreadLocal对象与值绑定到Thread中的ThreadLocalMap变量中。此时threadLocals的key为当前ThreadLocal对象，value为set方法的参数值。

• get

获取当前线程中当前ThreadLocal对象对应的绑定的值。也就是相当于map.get(threadLocal)。

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

①Thread t = Thread.currentThread();

仍然是获取当前线程，即当前调用get方法的线程。

②getMap

获取当前线程对象的全局变量threadLocals。

③setInitialValue

threadLocals若为null，需要进行初始值的设置。

private T setInitialValue() {
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}

initialValue：

获取初始值，初始值为null。

protected T initialValue() {
    return null;
}

获取初始值后，接下来将初始化绑定到当前线程对象的ThreadLocalMap变量threadLocals中。此时，threadLocals的key为当前ThreadLocal对象，value为null。

④如果threadLocals!=null，将去threadLocals中获取到当前ThreadLocal对象对应到的值并且返回。根据key为当前ThreadLocal对象去获取对应的Entry对象，如果能够获取到就取出Entry中的值，如果获取不到说明当前线程不存在当前ThreadLocal对应的值，就依然会走setInitialValue的逻辑，返回null。

• remove

将当前ThreadLocal对象和对应的值从当前线程解绑，也就是相当于map.remove(threadLocal)。

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

解绑很简单，就是获取当前线程的threadLocals，然后调用其remove方法移除key。

---

█ ThreadLocalMap

ThreadLocal的功能实现借助于ThreadLocalMap，ThreadLocalMap是ThreadLocal中定义的一个内部类，其key为ThreadLocal对象，value为需要绑定的值。

字段：

①table

private Entry[] table;

Map底层使用数组来存放元素。数组元素类型为Entry，Entry为键值对对象。

Entry：

Entry为ThreadLocalMap中定义的一个内部类。从Entry构造器中可以看出，键为ThreadLocal对象，值为ThreadLocal对应的值，并且ThreadLocal键对象是弱引用的（WeakReference）。

static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;

    Entry(ThreadLocal<?> k, Object v) {
        super(k);
        value = v;
    }
}

②INITIAL_CAPACITY

private static final int INITIAL_CAPACITY = 16;

table数组的初始化容量大小。该值必须为2的n次方。比如2、4、8、16......

③size

private int size = 0;

table中实际存放的Entry个数。

④threshold

private int threshold

对table数组进行扩容时的一个阈值。

构造器：

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

 ①table = new Entry[INITIAL_CAPACITY];

对table数组进行初始化，初始化大小为16个长度。

②int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);

根据ThreadLocal的hashCode与数组的容量来计算该ThreadLocal在数组中的下标，依次来将该其存放在数组对应的下标位置。

③table[i] = new Entry(firstKey, firstValue);

将ThreadLocal对象与其对应的值封装成Entry对象，添加到数组对应的下标位置。

threadLocalHashCode：

threadLocalHashCode是ThreadLocal中定义的一个全局变量：

private final int threadLocalHashCode = nextHashCode();

private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}

private static AtomicInteger nextHashCode =
    new AtomicInteger();
    
private static final int HASH_INCREMENT = 0x61c88647;    

（2）

ThreadLocalMap还提供了一个以ThreadLocalMap类型为参数的构造器，将parentMap中的内容复制到当前新的ThreadLocalMap。

private ThreadLocalMap(ThreadLocalMap parentMap) {
    ......
}

方法：

• set

以ThreadLocal对象为key，其对应的值为value，封装成Entry对象存储在table数组中。对应ThreadLocal的set方法。（具体的实现原理，感兴趣的同学可以去阅读源码）

private void set(ThreadLocal<?> key, Object value) {
    
    Entry[] tab = table;
    int len = tab.length;
    // 计算出该key对象对应的数组下标位置
    int i = key.threadLocalHashCode & (len-1);
    
    // 遍历table数组，进行比对，在数组中拿出每一个Entry对象
    // 如果当前的Entry对象中的key是当前的ThreadLocal对象，则进行值的替换
    // 如果Entry对象中的key为null，则可以将当前的ThreadLocal对象存放在改Entry对象中。
    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();
}

• getEntry

参数为ThreadLocal对象，去table数组中取出该ThreadLocal对象对应的Entry。对应ThreadLocal中的get方法。

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

• remove

参数为ThreadLocal对象，将该ThreadLocal对应的Entry对象从table数组中移除，即也就移除了该ThreadLocal对象。对应ThreadLocal中的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;
        }
    }
}

---

（1）在使用ThreadLocal将一个值绑定到线程上时，调用set、get、remove等方法时，需要是在同一个线程中，因为方法中都是通过Thread.currentThread()来获取线程对象的。从始至终都只有针对的是同一个线程也能正确的存值、获取值、删除值。

（2）ThreadLocal是不具有继承性的，即在父线程调用set方法将值绑定到父线程上后，在子线程中通过get方法是获取不到这个值的。于是针对这个场景，JDK提供了具有继承性的InheritableThreadLocal。