ThreadLocal学习

比眉伴天荒 2022-03-10 10:28 171阅读 0赞

# 一. 概论 #

多线程访问同一个共享变量时特别容易出现并发问题，特别是在多个线程需要对一个共享变量进行写入时。为了保证线程安全，一般使用者在访问共享变量时需要进行适当的同步，如下图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6Xzk0MDYxMQ_size_16_color_FFFFFF_t_70][]

同步的措施一般是加锁，这就需要使用者对锁有一定的了解，这显然加重了使用者的负担。那么有没有一种方式可以做到，当创建一个变量后，每个线程对其进行访问的时候访问的是自己线程的变量呢？其实ThreadLocal就可以做这件事情，虽然ThreadLocal并不是为了解决这个问题而出现的。

ThreadLocal是JDK包提供的，他提供了现**线程本地变量**，也就是如果你创建了一个ThreadLocal变量，那么**访问这个变量的每个线程都会有这个变量的一个本地副本**。当多个线程操作这个变量时，**实际操作的是自己本地内存里面的变量**，从而避免了线程安全问题。创建一个ThreadLocal变量后，每个线程都会复制一个变量到自己的本地内存，如下图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6Xzk0MDYxMQ_size_16_color_FFFFFF_t_70 1][]

## 1.1ThreadLocal使用示例 ##

本节介绍如何使用ThreadLocal。本例开启了两个线程，在每个线程内部都设置了本地变量的值，然后调用print函数打印当前本地变量的值。如果打印后调用了本地变量的remove方法，则会删除本地内存中的该变量，代码如下：

package singleton.threadLocal;
    
    /**
     * <p>Coding</p>
     *
     * @author haozz
     * @version $Id: ThreadLocalTest.java, v 0.1 2019/3/10 20:25 haozz Exp $
     */
    public class ThreadLocalTest {
    
        //(1)print方法
        static void print(String str){
            //1.1 打印当前线程本地内存中localVariable变量的值
            System.out.println(str+":"+localVariable.get());
            //1.2 清除当前线程本地内存中localVariable变量
            //localVariable.remove();
        }
    
        //(2)创建ThreadLocal变量
        static ThreadLocal<String> localVariable = new ThreadLocal<String>();
    
        public static void main(String[] args) {
            //(3)创建线程one
            Thread threadOne = new Thread(new Runnable() {
                public void run() {
                    //3.1 设置线程one中本地变量localVariable的值
                    localVariable.set("threadOne localVariable");
                    //3.2 调用打印函数
                    print("threadOne");
                    //3.3 打印本地变量值
                    System.out.println("threadOne remove after:"+localVariable.get());
                }
            });
    
            //(4)创建线程two
            Thread threadTwo = new Thread(new Runnable() {
                public void run() {
                    //4.1 设置线程two中本地变量localVariable的值
                    localVariable.set("threadTwo localVariable");
                    //4.2 调用打印函数
                    print("threadTwo");
                    //4.3 打印本地变量值
                    System.out.println("threadTwo remove after:"+localVariable.get());
                }
            });
    
            //(5)启动线程
            threadOne.start();
            threadTwo.start();
        }
    }

运行结果如下：

threadTwo:threadTwo localVariable
    threadOne:threadOne localVariable
    threadTwo remove after:threadTwo localVariable
    threadOne remove after:threadOne localVariable

代码(2)创建了一个ThreadLocal变量。

代码(3)和(4)分别创建了线程One和Two。

代码(5)启动了两个线程。

线程One中的代码3.1方法通过set方法设置了localVariable的值，这其实**设置的是线程One本地内存中的一个副本，这个副本线程Two是访问不了的**。然后代码3.2调用了print方法，代码1.1通过get方法获取了当前线程（线程One）本地内存中的localVariable的值。线程Two的执行类似线程One。

打开代码1.2的注释后，再次运行，运行结果如下：

threadOne:threadOne localVariable
    threadTwo:threadTwo localVariable
    threadOne remove after:null
    threadTwo remove after:null

# 二. ThreadLocal的实现原理 #

首先看一下ThreadLocal相关类的类图结构，如下图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6Xzk0MDYxMQ_size_16_color_FFFFFF_t_70 2][]

由该图可知，Thread类中有一个threadLocals和一个inheritableThreadLocals，它们都是ThreadLocalMap类型的变量，二ThreadLocalMap是一个定制化的HashMap。在默认情况下，每个线程中这两个变量都为null，只有当前线程第一个调用ThreadLocal的set或者get方法时才会创建它们。其实每个线程的本地变量不是存放在ThreadLocal实例里面，而是存放在调用线程的threadLocals变量里面。也就是说，ThreadLocal类型的本地变量存放在具体的线程内存空间中。ThreadLocal就是一个工具壳，它通过set方法吧value值放入调用线程的threadLocals里面并存放起来，当调用线程调用他的get方法是，再从当前线程的threadLocals里面将其拿出来使用。如果调用线程一直不终止，那么这个本地变量会一直存放在调用线程的threadLocals变量里面，所以当不需要使用本地变量时可以通过调用ThreadLocal变量的remove方法，从当前线程的threadLocals里面删除该本地变量。另外，Thread里面的threadLocals为何被设计为mao结构？很明显是因为每个线程可以关联多个ThreadLocal变量。

下面简单分析ThreadLocal的set、get及remove方法的实现逻辑。

## 2.1 void set(T value) ##

public void set(T value) {
            //(1)获取当前线程
            Thread t = Thread.currentThread();
            //(2)将当前线程作为key，去查找对应的线程变量，找到则设置
            ThreadLocalMap map = getMap(t);
            if (map != null)
                map.set(this, value);
            else
            //(3)第一次调用就创建当前线程对应的HashMap
                createMap(t, value);
        }

代码(1)首先获取调用线程，然后使用当前线程作为参数调用getMap(t)方法，该方法代码如下：

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

可以看到，getMap(t)的作用是获取现成自己的变量threadLocals，该变量被绑定到了线程的成员变量上。

如果getMap(t)的返回值不为空，则把value值设置到threadLocals中，也就是把当前变量值放入当前线程的内存变量threadLocals中。threadLocals是一个HashMap结构，其中key就是当前ThreadLocal的实例对象引用，value是通过set方法传递的值。

如果getMap(t)返回空值则说明是第一次调用set方法，这是创建当前线程的threadLocals变量。下面来看createMap(t,value)做什么。

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

它创建当前线程的threadLocals变量。

**总之，threadLocals是Thread的一个成员变量，是一个HashMap结构（ThreadLocalMap），ThreadLocal就是threadLocals中的key。一个线程可以有多个ThreadLocal，只要定义多个ThreadLocal的实例对象就可以，它们都存放在ThreadLocalMap中。**

## 2.2 T get() ##

public T get() {
            //(4)获取当前线程
            Thread t = Thread.currentThread();
            //(5)获取当前线程的threadLocals变量
            ThreadLocalMap map = getMap(t);
            //(6)如果threadLocals不为null，则返回对应本地变量的值
            if (map != null) {
                ThreadLocalMap.Entry e = map.getEntry(this);
                if (e != null) {
                    @SuppressWarnings("unchecked")
                    T result = (T)e.value;
                    return result;
                }
            }
            //(7)threadLocals为空则初始化当前线程的threadLocals成员变量
            return setInitialValue();
        }

代码(4)首先获取当前线程实例，如果当当前线程的threadLocals变量不为null，则直接返回当前线程绑定的本地变量，否则执行代码(7)进行初始化。setInitialValue()的代码如下：

private T setInitialValue() {
            //(8)初始化为null
            T value = initialValue();
            Thread t = Thread.currentThread();
            ThreadLocalMap map = getMap(t);
            //(9)如果当前线程的threadLocals变量不为空
            if (map != null)
                map.set(this, value);
            else
            //(10)如果当前线程的threadLocals变量为空
                createMap(t, value);
            return value;
        }
    
        protected T initialValue() {
            return null;
        }

如果当前线程的threadLocals变量不为空，则设置当前线程的本地变量值为null，否则调用createMap方法创建当前线程的createMap变量。

## 2.3 void remove() ##

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

如以上代码所示，如果当前线程的threadLocals变量不为空，则删除当前线程中指定ThreadLocal实例的本地变量。

总结：如下图所示，在每个线程内部都有一个名为threadLocals的成员变量，该变量的类型为HashMap，其中key为我们定义的ThreadLocal变量的this引用，value则为我们使用set方法设置的值。每个线程的本地变量存放在线程自己的内存变量threadLocals中，如果当前线程一直不消亡，那么这些本地变量会一直存在，所以可能造成内存溢出，因此使用完毕后要记得调用ThreadLocal的remove方法删除对应线程的threadLocals中的本地变量。JUC包里面的ThreadLocalRandom，就是借鉴ThreadLocal的思想实现的。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6Xzk0MDYxMQ_size_16_color_FFFFFF_t_70 3][]

# 三. ThreadLocal不支持继承性 #

首先看一个例子：

package singleton.threadLocal;
    
    /**
     * <p>Coding</p>
     *
     * @author haozz
     * @version $Id: ThreadLocalTest.java, v 0.1 2019/3/10 20:25 haozz Exp $
     */
    public class ThreadLocalTest {
    
        //(1)创建线程变量
        public static ThreadLocal<String> threadLocal = new ThreadLocal<String>();
    
        public static void main(String[] args) {
            //(2)设置线程变量
            threadLocal.set("hello world");
            //(3)启动子线程
            final Thread thread = new Thread(new Runnable() {
                public void run() {
                    //(4)子线程输出线程变量的值
                    System.out.println("thread:" + threadLocal.get());
                }
            });
            thread.start();
    
            //(5)主线程输出线程变量的值
            System.out.println("main:" + threadLocal.get());
        }
    }

输出结果如下：

main:hello world
    thread:null

也就是说，**同一个ThreadLocal变量在父线程中被设置值后，在子线程总是获取不到的**。根据上节的介绍，这应该是正常现象，因为在子线程thread里面调用get方法时当前线程为thread线程，而这里调用set方法设置线程变量的是main线程，两者是不同的线程，自然子线程访问时返回null。那么有没有办法让子线程能访问到父线程中得到值？当然有。

# 四. InheritableThreadLocal类 #

为了解决上节提出的问题，InheritableThreadLocal应运而生，InheritableThreadLocal继承自ThreadLocal，其提供了一个特性，就是让**子线程可以访问在父线程中设置的本地变量**。下面看一下InheritableThreadLocal的代码：

public class InheritableThreadLocal<T> extends ThreadLocal<T> {
        //(1)
        protected T childValue(T parentValue) {
            return parentValue;
        }
    
        //(2)
        ThreadLocalMap getMap(Thread t) {
           return t.inheritableThreadLocals;
        }
    
        //(3)
        void createMap(Thread t, T firstValue) {
            t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
        }
    }

由如上代码可知，InheritableThreadLocal继承了ThreadLocal，并重写了三个方法。由代码(3)可知，InheritableThreadLocal重写了createMap方法，那么现在当第一次调用set方法是，创建的是当前线程的inheritableThreadLocals变量的实例而不再是threadLocals。由代码(2)可知，当调用get方法获取当前线程内部的map变量时，获取的是inheritableThreadLocals而不再是threadLocals。

综上可知，在InheritableThreadLocal的世界里，变量inheritableThreadLocals替代了threadLocals。

下面我们看一下重写代码(1)何时执行，以及如何让子线程可以访问父线程的本地变量。这要从创建Thread的代码说起，打开Thread类的默认构造函数，代码如下：

public Thread(Runnable target) {
            init(null, target, "Thread-" + nextThreadNum(), 0);
        }
    
        private void init(ThreadGroup g, Runnable target, String name,
                          long stackSize, AccessControlContext acc,
                          boolean inheritThreadLocals) {
            ...
            //(4)获取当前线程
            Thread parent = currentThread();
            ...
            //(5)如果父线程的inheritableThreadLocal变量不为null
            if (inheritThreadLocals && parent.inheritableThreadLocals != null)
                //(6)设置子线程中inheritableThreadLocal变量
                this.inheritableThreadLocals =
                    ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
            this.stackSize = stackSize;
    
            
            tid = nextThreadID();
        }

如上代码在创建线程时，在构造函数里面会调用init方法。代码(4)获取了当前线程（这里指的是main函数所在的线程，也就是父线程），然后代码(5)判断main函数所在线程里面的inheritableThreadLocals属性是否为null，前面我们讲了InheritableThreadLocal类的get和set方法操作的是inheritableThreadLocals，所里这里的inheritableThreadLocals变量不为null，因此会执行代码(6)。下面看一下createInheritableMap的代码：

static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
            return new ThreadLocalMap(parentMap);
        }

可以看到，在createInheritableMap内部使用父线程的inheritableThreadLocals变量作为构造函数创建了一个新的ThreadLocalMap变量，然后赋值给了子线程的inheritableThreadLocals变量。下面我们看看在ThreadLocalMap的构造函数内部都做了什么事情。

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) {
                            //(7)调用重写的方法
                            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++;
                        }
                    }
                }
            }

**在该构造函数内部把父线程的inheritableThreadLocals成员变量的值复制到新的ThreadLocalMap对象中**，其中代码(7)调用了InheritableThreadLocal类重写的代码(1)。

总结：InheritableThreadLocal类通过重写代码(2)和(3)让本地变量保存到了具体线程的InheritableThreadLocals变量里面，那么线程在通过InheritableThreadLocal类实例的set或者get方法设置变量时，就会创建当前线程的inheritableThreadLocals变量。**当父线程创建子线程时，构造函数会把父线程中inheritableThreadLocals变量里面的本地变量复制一份保存到子线程的inheritableThreadLocals变量里面**。

把第三节中的代码(1)修改为：

//(1)创建线程变量
        public static ThreadLocal<String> threadLocal = new InheritableThreadLocal<String>();

执行结果如下：

main:hello world
    thread:hello world

可见，现在可以从子线程正常获取到线程变量的值了。

那么在什么情况下需要子线程可以获取父线程的threadLocals变量呢？情况还是蛮多的，比如子线程需要使用存放在threadLocals变量中的用户登录信息，再比如一些中间件需要把同意的id追踪的整个调用链路记录下来。其实子线程使用父线程中的threadLocals方法有多种方式，比如创建线程时传入父线程中的变量，并将其复制到子线程中，或者再父线程中构造一个map作为参数传递给子线程，但是这些都改变了我们的使用习惯，所以在这些情况下InheritableThreadLocal就显得比较有用。

本文摘自《Java并发编程之美》

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6Xzk0MDYxMQ_size_16_color_FFFFFF_t_70]: /images/20220310/bdfe65bd349b49ae942803723623514a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6Xzk0MDYxMQ_size_16_color_FFFFFF_t_70 1]: /images/20220310/28ddbca751f6425f881cc19e4f8c2574.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6Xzk0MDYxMQ_size_16_color_FFFFFF_t_70 2]: /images/20220310/791019bc079f4d80a9aabff405409ed8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6Xzk0MDYxMQ_size_16_color_FFFFFF_t_70 3]: /images/20220310/dfdd8852c80a4d3ba5520fede6cbbf20.png