专栏首页java、Spring、技术分享ThreadLocal和InheritableThreadLocal深入分析

ThreadLocal和InheritableThreadLocal深入分析

  通过ThreadLocal和InheritableThreadLocal,我们能够很方便的设计出线程安全的类。JDK底层是如何做到的呢?ThreadLocal和InheritableThreadLocal有什么区别呢与联系呢?为什么有了ThreadLocal类还需要InheritableThreadLocal类,他们与Thread类是什么关系?带着这些问题我们来分析他们的源码。

ThreadLocal

  ThreadLocal是为每一个线程创建一个单独的变量副本,每个线程都可以独立地改变自己所拥有的变量副本,而不会影响其他线程所对应的副本。ThreadLocal为多线程环境下变量问题提供了另外一种解决思路。下面来看看ThreadLocal内部是如何做到的。下面分别分析ThreadLocal提供的方法。

  • set方法源码解析
public class ThreadLocal<T> {
 
  /**
**传入一个value参数
**/
    public void set(T value) {
        //首先得到当前线程对象
        Thread t = Thread.currentThread();
        //根据当前线程,得到ThreadLocalMap 引用。
        ThreadLocalMap map = getMap(t);
      //如果map不为空,则把值set到map里
        if (map != null)
            map.set(this, value);
        else
//map为空,则创建一个map对象,并设置值
            createMap(t, value);
    }

//根据Thread得到 ThreadLocalMap 对象
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

//map为空的话,会新建一个ThreadLocalMap,并将引用交给当前Thread的threadLocals 变量
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

}

从上面的源码上我们可以很容易的看出来,** ThreadLocal只是提供方法方便我们进行编码,而真正存变量的地方是在ThreadLocalMap 这个对象上的**。Thread对象持有ThreadLocalMap 的引用,ThreadLocalMap 以ThreadLocal为key。他们之间的关系如下图所示:

ThreadLocal对象关系图

  • get方法源码解析
public class ThreadLocal<T> {
  
    public T get() {
        //得到当前线程
        Thread t = Thread.currentThread();
    //这里取的是Thread里的ThreadLocalMap引用
        ThreadLocalMap map = getMap(t);
        if (map != null) {
//从map里取值,key为ThreadLocal对象
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null)
                return (T)e.value;
        }
//map为空的话,会调用setInitialValue方法
        return setInitialValue();
    }

//
    private T setInitialValue() {
//得到一个默认的值,initialValue为protected,留给子类实现,
        T value = initialValue();
//得到当前线程
        Thread t = Thread.currentThread();
//再次尝试得到map对象
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
//调用createMap方法
            createMap(t, value);
        return value;
    }

    protected T initialValue() {
        return null;
    }

}

get方法无非就是得到当前线程的ThreadLocalMap,如果不为空,则根据ThreadLocal为key进行取值,如果为空,则会调用createMap为Thread线程构造一个ThreadLocalMap对象,并返回initialValue方法的值。

InheritableThreadLocal

  InheritableThreadLocal用于子线程能够拿到父线程往ThreadLocal里设置的值。使用代码如下:

public class Test {

    public static ThreadLocal<Integer> threadLocal = new InheritableThreadLocal<Integer>();

    public static void main(String args[]) {
        threadLocal.set(new Integer(456));
        Thread thread = new MyThread();
        thread.start();
        System.out.println("main = " + threadLocal.get());
    }

    static class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("MyThread = " + threadLocal.get());
        }
    }
}

输出结果如下图:

输出结果

如果把上面的InheritableThreadLocal换成ThreadLocal的话,在子线程里的输出将为是空。从上面的代码里也可以看出InheritableThreadLocal是ThreadLocal的子类。下面是InheritableThreadLocal的源码:

package java.lang;
import java.lang.ref.*;

public class InheritableThreadLocal<T> extends ThreadLocal<T> {

 //这个方法留给子类实现
    protected T childValue(T parentValue) {
        return parentValue;
    }

//重写getMap方法,返回的是Thread的inheritableThreadLocals引用
    ThreadLocalMap getMap(Thread t) {
       return t.inheritableThreadLocals;
    }

//重写createMap方法,构造的ThreadLocalMap会传给Thread的inheritableThreadLocals 变量
    void createMap(Thread t, T firstValue) {
        t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
    }
}

从源码上看,跟ThreadLocal不一样的无非是ThreadLocalMap的引用不一样了,从逻辑上来讲,这并不能做到子线程得到父线程里的值。那秘密在那里呢?通过跟踪Thread的构造方法,你能够发现是在构造Thread对象的时候对父线程的InheritableThreadLocal进行了复制。下面是Thread的部分源码:

public class Thread implements Runnable {
      //默认人构造方法,会调用init方法进行初使化
      public Thread() {
        init(null, null, "Thread-" + nextThreadNum(), 0);
    }

    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize) {
        init(g, target, name, stackSize, null);
    }

//最终会调用到当前这个方法
    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc) {
        if (name == null) {
            throw new NullPointerException("name cannot be null");
        }

        this.name = name.toCharArray();
// parent为当前线程,也就是调用了new Thread();方法的线程
        Thread parent = currentThread();
        SecurityManager security = System.getSecurityManager();
        if (g == null) {
            if (security != null) {
                g = security.getThreadGroup();
            }
            if (g == null) {
                g = parent.getThreadGroup();
            }
        }
        g.checkAccess();
        if (security != null) {
            if (isCCLOverridden(getClass())) {
                security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
            }
        }

        g.addUnstarted();

        this.group = g;
//在这里会继承父线程是否为后台线程的属性还有父线程的优先级
        this.daemon = parent.isDaemon();
        this.priority = parent.getPriority();
        if (security == null || isCCLOverridden(parent.getClass()))
            this.contextClassLoader = parent.getContextClassLoader();
        else
            this.contextClassLoader = parent.contextClassLoader;
        this.inheritedAccessControlContext =
                acc != null ? acc : AccessController.getContext();
        this.target = target;
        setPriority(priority);
//这里是重点,当父线程的inheritableThreadLocals 不为空的时候,会调用 ThreadLocal.createInheritedMap方法,传入的是父线程的inheritableThreadLocals。原来复制变量的秘密在这里
        if (parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
        /* Stash the specified stack size in case the VM cares */
        this.stackSize = stackSize;

        /* Set thread ID */
        tid = nextThreadID();
    }

}

通过跟踪Thread的构造方法,我们发现只要父线程在构造子线程(调用new Thread())的时候inheritableThreadLocals变量不为空。新生成的子线程会通过ThreadLocal.createInheritedMap方法将父线程inheritableThreadLocals变量有的对象复制到子线程的inheritableThreadLocals变量上。这样就完成了线程间变量的继承与传递。 ThreadLocal.createInheritedMap方法的源码如下:

public class ThreadLocal<T> {
//根据传入的map,构造一个新的ThreadLocalMap
    static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
        return new ThreadLocalMap(parentMap);
    }

   static class ThreadLocalMap {
//这个private的构造方法就是专门给ThreadLocal使用的
          private ThreadLocalMap(ThreadLocalMap parentMap) {
//ThreadLocalMap还是用Entry数组来存储对象的
            Entry[] parentTable = parentMap.table;
            int len = parentTable.length;
            setThreshold(len);
            table = new Entry[len];
//这里是复制parentMap数据的逻辑
            for (int j = 0; j < len; j++) {
                Entry e = parentTable[j];
                if (e != null) {
                    ThreadLocal key = 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++;
                    }
                }
            }
        }
  }

}

总结:

  • ThreadLocal和InheritableThreadLocal本质上只是为了方便编码给的工具类,具体存数据是ThreadLocalMap 对象。
  • ThreadLocalMap 存的key对象是ThreadLocal,value就是真正需要存的业务对象。
  • Thread里通过两个变量持用ThreadLocalMap 对象,分别为:threadLocals和inheritableThreadLocals。
  • InheritableThreadLocal之所以能够完成线程间变量的传递,是在new Thread()的时候对inheritableThreadLocals对像里的值进行了复制。
  • 子线程通过继承得到的InheritableThreadLocal里的值与父线程里的InheritableThreadLocal的值具有相同的引用,如果父子线程想实现不影响各自的对象,可以重写InheritableThreadLocal的childValue方法。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • java线程池

    线程池能够帮助我们提高系统资源利用效率,并简化线程管理。通过并发包下的Executors(不是Executor)可以方便的创建如下几类线程池。分别为:

    良辰美景TT
  • java线程

      从操作系统的角度,可以简单认为,线程是系统调度的最小单元,一个进程可以包含多个线程,作为任务的真正运作者,有自己的栈(Stack)、寄存器(Register...

    良辰美景TT
  • Spring Cloud Config

      每个系统都会有一些配置信息需要处理,比如通用的数据源的配置,连接池的配置,log信息的配置。原来系统的处理方式都是通过将配置文件打包部署到线上,对于需要动态...

    良辰美景TT
  • ThreadLocal 源码解析

    ThreadLocal 顾名思义就是在每个线程内部都会存储只有当前线程才能访问的变量的一个副本,然后当前线程修改了该副本的值后而不会影响其他线程的值,各个变量之...

    Java技术大杂烩
  • java进阶|HashTable源码分析和理解

    键值对集合Map,HashTable都是我们常用的,但是随着多线程环境以及代码的普及,ConcurrentHashMap这样的并发集合也常用了起来,今天...

    后端Coder
  • 学习笔记:Hashtable和HashMap

    学了这么些天的基础知识发现自己还是个门外汗,难怪自己一直混的不怎么样。但这样的恶补不知道有没有用,是不是过段时间这些知识又忘了呢?这些知识平时的工作好像都是随拿...

    用户1105954
  • 最新!!招银网络科技Java面经,整理附答案

    3月12号现场面试的, 感觉好像所有人有3面的样子。到目前也没有消息,有消息的吱一声,让我早点死了这个心…..

    好好学java
  • HashMap实现原理分析

    HashMap实现原理分析 HashMap主要是用数组来存储数据的,我们都知道它会对key进行哈希运算,哈系运算会有重复的哈希值,对于哈希值的冲突,HashMa...

    xiangzhihong
  • python 字符串(str)和列表(list)的互相转换

    http://blog.csdn.net/cnmcsdn456/article/details/27830671

    双面人
  • Java日志体系(commons-logging)Java日志系统学习

    贾博岩

扫码关注云+社区

领取腾讯云代金券