解决多线程间共享变量线程安全问题的大杀器——ThreadLocal(下)

简介: 解决多线程间共享变量线程安全问题的大杀器——ThreadLocal

2、Threadlocal 不支持继承性

首先看下下面代码:

public class TestThreadLocal {
    //(1)创建线程变量
    public static ThreadLocal<String> threadLocal = new ThreadLocal<>();
    public static void main(String[] args) {
        //(2)赋值本地变量
        threadLocal.set("hello world");
        //(3)启动子线程
        new Thread(() -> {
            //(4)子线程输出线程变量的值
            System.out.println("thread:" + threadLocal.get());
        }).start();
        //(5)主线程输出线程变量的值
        System.out.println("main:" + threadLocal.get());
    }
}

输出结果如下:


20201104171149788.png


输出结果说明:同一个 ThreadLocal 变量在父线程中被设置值后,在子线程中是获取不到的。

原因是:子线程里面调用get方法时,Thread t = Thread.currentThread() 代码是获取当前线程,当前线程是子线程,而调用set方法给threadLocal赋值的线程是main,两者是不同的线程,故子线程调用get方法取得的threadLocal值为null,main线程调用get方法取得的threadLocal值为“hello world”。


有没有方法让子线程能够访问到父线程中的值?继续往下看啦。


3、lnheritableThreadLocal 类

为了解决让子线程能够访问到父线程中的值的问题,lnheritableThreadLocal 应运而生。lnheritableThreadLocal 继承自 ThreadLocal,并提供了一个新特性:让子线程可以访问在父线程中设置的本地变量值。先来看下lnheritableThreadLocal 的实现:


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 的源码可知,lnheritableThreadLocal 继承了 ThreadLocal 类并重新了 childValue、getMap、createMap方法。


由(3)处代码可知,InheritableThreadLocal 重写了 createMap 方法,那么当第一次调用 InheritableThreadLocal 实例的set方法时,创建的就是当前线程的inheritableThreadLocals变量的实例而不再是threadLocals了。


由(2)处代码可知,InheritableThreadLocal 重写了 getMap 方法,那么调用InheritableThreadLocal 实例的get方法时,就是获取当前线程的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) {
        init(g, target, name, stackSize, null, true);
    }
    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc,
                      boolean inheritThreadLocals) {
        ......
        //(4)获取当前线程
        Thread parent = currentThread();
        ......
        //(5)如果父线程的inheritableThreadLocals 变量不为null
        if (parent.inheritableThreadLocals != null)
        //(6)设置子线程中的 inheritableThreadLocals 变量
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
      ......
    }

由(4)处代码,获取了当前线程(main函数所在的线程,即父线程)


这里可能有同学会有疑问,这里获取到的当前线程为何是父线程?

想一下,当我们new Thread()的时候,是不是在main()方法里执行的,所以当前执行创建Thread代码的线程是main线程,所以(4)处代码中currentThread()方法获取到的就是父线程啦!


由(5)处代码,判断main线程里的inheritableThreadLocals 是否为null,不为null时,则执行代码(6)。


由(6)处代码,我们来看看createInheritedMap()方法:

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

在createInheritedMap方法中,使用父线程的inheritableThreadLocals变量作为构造函数创建了一个新的ThreadLocalMap对象,由(6)处:

this.inheritableThreadLocals=ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);

知道将子线程的inheritableThreadLocals引用指向了这个新创建的ThreadLocalMap对象。


再看看 ThreadLocalMap(parentMap)构造函数:

  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)调用了InheritableThreadLocal类重写的 childValue 方法
                        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++;
                    }
                }
            }
        }

在构造函数中就是把父线程的inheritableThreadLocal变量的值复制到新的ThreadLocalMap对象中,(7)处代码实际上是调用了(1)处代码。


总结一下:InheritableThreadLocal实现子线程可以访问父线程的线程变量的实现原理如下:


InheritableThreadLocal通过重写createMap 和 getMap 方法让本地变量保存到了具体线程的inheritableThreadLocal变量中

线程通过调用inheritableThreadLocal实例的set或get方法时,就会创建当前线程的inheritableThreadLocal变量

当父线程创建子线程时,构造函数会把父线程中的inheritableThreadLocal变量里面的本地变量值复制一份保存到子线程的inheritableThreadLocal变量里

将最开始的代码作以下修改:

public class TestThreadLocal {
    //(1)创建线程变量
    public static InheritableThreadLocal<String> threadLocal = new InheritableThreadLocal<>();
    public static void main(String[] args) {
        //(2)赋值本地变量
        threadLocal.set("hello world");
        //(3)启动子线程
        new Thread(() -> {
            //(4)子线程输出线程变量的值
            System.out.println("thread:" + threadLocal.get());
        }).start();
        //(5)主线程输出线程变量的值
        System.out.println("main:" + threadLocal.get());
    }
}

结果就变成了:


20201104181039333.png


很多子线程需要使用父线程中的变量值的场景都可以使用InheritableThreadLocal,是不是很强大呢?


这期就到这里,ThreadLocal、InheritableThreadLocal在Java并发编程中的地位举足轻重,理解了它们的底层实现和应用场景,会让你的大厂面试更有加分项。你们的三连是我创作的最大动力,我们下期见。


相关文章
|
2月前
|
Java 开发者
在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱,帮助你更好地理解和选择适合项目需求的线程创建方式。
27 3
|
2月前
|
Java 开发者
在Java多线程编程中,选择合适的线程创建方法至关重要
【10月更文挑战第20天】在Java多线程编程中,选择合适的线程创建方法至关重要。本文通过案例分析,探讨了继承Thread类和实现Runnable接口两种方法的优缺点及适用场景,帮助开发者做出明智的选择。
23 2
|
2月前
|
Java
Java中多线程编程的基本概念和创建线程的两种主要方式:继承Thread类和实现Runnable接口
【10月更文挑战第20天】《JAVA多线程深度解析:线程的创建之路》介绍了Java中多线程编程的基本概念和创建线程的两种主要方式:继承Thread类和实现Runnable接口。文章详细讲解了每种方式的实现方法、优缺点及适用场景,帮助读者更好地理解和掌握多线程编程技术,为复杂任务的高效处理奠定基础。
38 2
|
1月前
|
数据采集 Java Python
爬取小说资源的Python实践:从单线程到多线程的效率飞跃
本文介绍了一种使用Python从笔趣阁网站爬取小说内容的方法,并通过引入多线程技术大幅提高了下载效率。文章首先概述了环境准备,包括所需安装的库,然后详细描述了爬虫程序的设计与实现过程,包括发送HTTP请求、解析HTML文档、提取章节链接及多线程下载等步骤。最后,强调了性能优化的重要性,并提醒读者遵守相关法律法规。
62 0
|
2月前
|
存储 消息中间件 资源调度
C++ 多线程之初识多线程
这篇文章介绍了C++多线程的基本概念,包括进程和线程的定义、并发的实现方式,以及如何在C++中创建和管理线程,包括使用`std::thread`库、线程的join和detach方法,并通过示例代码展示了如何创建和使用多线程。
58 1
C++ 多线程之初识多线程
|
2月前
|
Java 开发者
Java多线程初学者指南:介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点
【10月更文挑战第20天】Java多线程初学者指南:介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点,重点解析为何实现Runnable接口更具灵活性、资源共享及易于管理的优势。
44 1
|
2月前
|
安全 Java 开发者
Java多线程中的`wait()`、`notify()`和`notifyAll()`方法,探讨了它们在实现线程间通信和同步中的关键作用
本文深入解析了Java多线程中的`wait()`、`notify()`和`notifyAll()`方法,探讨了它们在实现线程间通信和同步中的关键作用。通过示例代码展示了如何正确使用这些方法,并分享了最佳实践,帮助开发者避免常见陷阱,提高多线程程序的稳定性和效率。
49 1
|
2月前
|
Java
在Java多线程编程中,`wait()` 和 `notify()/notifyAll()` 方法是线程间通信的核心机制。
在Java多线程编程中,`wait()` 和 `notify()/notifyAll()` 方法是线程间通信的核心机制。它们通过基于锁的方式,使线程在条件不满足时进入休眠状态,并在条件成立时被唤醒,从而有效解决数据一致性和同步问题。本文通过对比其他通信机制,展示了 `wait()` 和 `notify()` 的优势,并通过生产者-消费者模型的示例代码,详细说明了其使用方法和重要性。
31 1
|
3月前
|
数据采集 负载均衡 安全
LeetCode刷题 多线程编程九则 | 1188. 设计有限阻塞队列 1242. 多线程网页爬虫 1279. 红绿灯路口
本文提供了多个多线程编程问题的解决方案,包括设计有限阻塞队列、多线程网页爬虫、红绿灯路口等,每个问题都给出了至少一种实现方法,涵盖了互斥锁、条件变量、信号量等线程同步机制的使用。
LeetCode刷题 多线程编程九则 | 1188. 设计有限阻塞队列 1242. 多线程网页爬虫 1279. 红绿灯路口
|
2月前
|
存储 前端开发 C++
C++ 多线程之带返回值的线程处理函数
这篇文章介绍了在C++中使用`async`函数、`packaged_task`和`promise`三种方法来创建带返回值的线程处理函数。
79 6