12.ThreadLocal类的使用和实现原理

ThreadLocal

ThreadLocal，顾名思义就是线程本地对象，理解起来就是线程局部变量，这个类可以将对象绑定到线程，使之成为线程私有对象。这种解决并发安全问题的方式就是不共享，使用私有变量来保证线程安全。

线程局部变量(ThreadLocal)其实的功用非常简单，就是为每一个使用该变量的线程都提供一个变量值的副本，是Java中一种较为特殊的线程绑定机制，是每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。

概括起来说，对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。

《Java核心技术》中关于ThreadLocal的示例：

public static final ThreadLocal dateFormat= 
        ThreadLocal.withInitial(()->new SimpleDateFormat("yyyy-mm-dd"));

这段代码使得每个访问此共享变量的线程，持有一个私有的对象。
因为这个SimpleDateFormat不是线程安全的类，在并发情况下其内部的状态可能会出现安全问题，且在并发使用过程中，并不需要修改这个对象的状态，所以为了线程安全，使其“局部化”简单又安全。

// 访问数据
SimpleDateFormat format = dateFormat.get();

在一个给定的线程中首次调用get方法时，会调用initialValue方法，在此之后，get方法会返回属于当前线程的那个实例。

在Java 7中提供了一个类似ThreadLocal类的辅助类：ThreadLocalRandom类，ThreadLocalRandom.current()会返回一个特定于当前线程的Random类实例。

API

基本方法

• public static ThreadLocal withInitial(Supplier supplier)使用函数式接口创建ThreadLocal对象，接口内实现初始化动作
• public T get() 获取Local值
• public void set(T value)设置Local值
• public void remove() 删除Local值

直观的示例

public class ThreadLocalpractice {
    // 线程私有变量,和当前线程绑定，所以各个线程对其的改变不会被其他线程读取到到
    private final ThreadLocal local = ThreadLocal.withInitial(() -> 1);

    public void add(int a) {
        local.set(local.get() + a);
    }

    public Integer get() {
        return local.get();
    }

    public static void main(String[] args) {
        ThreadLocalpractice tlp = new ThreadLocalpractice();
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                tlp.add(1);
                System.out.println(Thread.currentThread().getName() + " get is " + tlp.get());
            }).start();
        }
        while (true) {
        }
    }
}

结果是每个打印都是2，说明各自的add都是独立的。

实现原理

ThreadLocal内部的变量是如何绑定到Thread对象上的？

• 查看set和get的源码：

  public T get() {
        // 获取当前线程
        Thread t = Thread.currentThread();
        // 以当前线程对象为参数，调用getMap()方法-->查看getMap
        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();
    }

从get方法可以看出，首先会获取当前线程，如何以当前线程对象为参数getMap():

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

发现getMap是获取Thread对象的一个属性，查看Thread源码关于此属性：

/* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;

可见首次get，map是null,继续查看get方法，如果map为null会直接return setInitialValue（）：

    
    private T setInitialValue() {
    // 初始化Local的value 
        T value = initialValue();
        Thread t = Thread.currentThread();
        // 获取Thread的threadLocals属性，首次为null，触发羡慕的createMap方法
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }
    // 在此方法中为Thread对象的threadlocals属性赋值，到此为止，map对象已经和Thread绑定成功了。
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

首次set也会创建map，即执行初始化工作：

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

• 总结

1. 在创建ThreadLocal对象时，对象的值为null；
2. 可以通过继承ThreadLocal并重写initialValue方法来设置初始值或者使用静态方法withInitial来设置初始值。
3. 当线程首次调用TL的get或set方法时，会为当前线程对象创建一个ThreadLocalMap对象，并将ThreadLocal对象作为Map的key,ThreadLocal的value作为map的value，然后将这个map传给Thread对象的threadLocals属性，达到将ThreadLocal绑定到Thread的目的。
4. 在之后的get、set或remove操作中，实际上只是在操作线程的threadlocals，这个属性不会在线程间共享，自然就相当于局部变量了。

ThreadLocalMap

从上面数据绑定的原理中可以知道，线程的ThreadLocal值是存在一个叫ThreadLocalMap的数据结构中的，既然是Map，一定是一个支持键值对的数据结构。那么是否使用的就是HashMap呢？

• ThreadLocalMap部分源码

    /**
     * ThreadLocalMap is a customized hash map suitable only for
     * maintaining thread local values. No operations are exported
     * outside of the ThreadLocal class. The class is package private to
     * allow declaration of fields in class Thread.  To help deal with
     * very large and long-lived usages, the hash table entries use
     * WeakReferences for keys. However, since reference queues are not
     * used, stale entries are guaranteed to be removed only when
     * the table starts running out of space.
     */
    static class ThreadLocalMap {
    //  ...
    static class Entry extends WeakReference> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal k, Object v) {
                super(k);
                value = v;
            }
        }
        
    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 void set(ThreadLocal key, Object value) {

            // We don't use a fast path as with get() because it is at
            // least as common to use set() to create new entries as
            // it is to replace existing ones, in which case, a fast
            // path would fail more often than not.

            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;
                }
        // 支持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();
        }

    
    // ...
    }

浏览源码可以发现，是一个ThreadLocal专用的HashMap，底层和hashmap相似。

参考资料

[1] Java并发编程实战
[2] Java核心技术