Java多线程:ThreadLocal(二)

导读:本篇文章讲解 Java多线程:ThreadLocal(二),希望对大家有帮助,欢迎收藏,转发!站点地址:www.bmabk.com

一、ThreadLocal是什么?

多线程访问同一个共享变量时特别容易出现并发问题,特别是在多个线程需要对一个共享变量进行写入时。为了保证线程安全,一般使用者在访问共享变量时需要进行适当的同步。
ThreadLocal是除了加锁这种同步方式之外的一种保证规避多线程访问出现线程不安全的方法,当我们在创建一个变量后,如果每个线程对其进行访问的时候访问的都是线程自己的变量这样就不会存在线程不安全问题
同步的措施一般是加锁,这就需要使用者对锁有一定的了解,这显然加重了使用者的负担。那么有没有一种方式可以做到,当创建一个变量后,每个线程对其进行访问的时候访问的是自己线程的变量呢?其实ThreadLocal就可以做这件事情,虽然ThreadLocal并不是为了解决这个问题而出现的。
在这里插入图片描述
ThreadLocal是JDK包提供的,它提供了线程本地变量,也就是如果你创建了一个ThreadLocal变量,那么访问这个变量的每个线程都会有这个变量的一个本地副本。当多个线程操作这个变量时,实际操作的是自己本地内存里面的变量,从而避免了线程安全问题。创建一个ThreadLocal变量后,每个线程都会复制一个变量到自己的本地内存,如图所示。
在这里插入图片描述

二、ThreadLocal使用案例

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

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

    public static void main(String[] args) {
        //(3) 创建线程one
        Thread threadOne = new Thread(new Runnable() {
            public void run() {
                //3.1设置线程One中本地变量localVariable的值
                localVariable.set("threadOne local variable");
                //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 local variable");
                //4.2调用打印函数
                print("threadTwo");
                //4.3打印本地变量值
                System.out.println("threadTwo remove after" + ":" + localVariable.get());
            }
        });
        //(5)启动线程
        threadOne.start();
        threadTwo.start();
    }
}

在这里插入图片描述
代码(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 的注释后,再次运行,运行结果如下。
在这里插入图片描述

三、ThreadLocal的原理

下图为ThreadLocal的类图
在这里插入图片描述
由该图可知,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为何被设计为map结构?很明显是因为每个线程可以关联多个ThreadLocal变量。

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

方法set(T value)

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

方法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() ;
}

方法remove()

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

总结:如图所示,在每个线程内部都有一个名为threadLocals的成员变量,该变量的类型为HashMap,其中key为我们定义的ThreadLocal变量的this引用,value 则为我们使用set方法设置的值。每个线程的本地变量存放在线程自己的内存变量threadLocals中,如果当前线程一直不消亡,那么这些本地变量会一直存在, 所以可能会造成内存溢出(是指程序在申请内存时,没有足够的内存空间供其使用),因此使用完毕后要记得调用ThreadLocal的remove方法删除对应线程的threadLocals中的本地变量

内存溢出 ,是指程序在申请内存时,没有足够的内存空间供其使用,出现out of memory;比如申请了一个integer,但给它存了long才能存下的数,那就是内存溢出

内存泄漏,是指你向系统申请分配内存进行使用(new),可是使用完了以后却不归还(delete),结果你申请到的那块内存你自己也不能再访问(也许你把它的地址给弄丢了),而系统也不能再次将它分配给需要的程序
在这里插入图片描述

四、ThreadLocal不支持继承性

示例

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

    public static void main(String[] args) {
        //(2) 设置线程变量
        threadLocal.set("hello world");
        //(3) 启动子线程
        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());
    }
}

在这里插入图片描述
也就是说,同一个ThreadLocal变量在父线程中被设置值后,在子线程中是获取不到的。这属于正常现象,因为在子线程thread里面调用get方法时当前线程为thread 线程,而这里调用set 方法设置线程变量的是main线程,两者是不同的线程,自然子线程访问时返回null。

五、InheritableThreadlocal类

InheritableThreadLocal继承自ThreadLocal,其提供了一个特性,就是让子线程可以访问在父线程中设置的本地变量。下面看一下InheritableThreadIocal的代码。

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

    public static void main(String[] args) {
        //(2) 设置线程变量
        threadLocal.set("hello world");
        //(3) 启动子线程
        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());
    }
}

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

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而不再是threadIocals。综上可知,在InheritableThreadLocal的世界里,变量inheritableThreadLocals替代了threadLocals。下面我们看一下重写的代码(1)何时执行,以及如何让子线程可以访问父线程的本地变量。这要从创建Thread的代码说起,打开Thread类的默认构造函数,代码如下。
在这里插入图片描述
如上代码在创建线程时,在构造函数里面会调用init方法。代码(4)获取了当前线程(这里是指main函数所在的线程,也就是父线程),然后代码(5)判断main函数所在线程里面的inheritableThreadLocals属性是否为null,前面我们讲了InheritableThreadLocal 类的get和set方法操作的是inheritableThreadLocals,所以这里的inheritableThreadLocal变量不为null,因此会执行代码(6)。

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

文章由极客之家整理,本文链接:https://www.bmabk.com/index.php/post/77205.html

(0)
小半的头像小半

相关推荐

极客之家——专业性很强的中文编程技术网站,欢迎收藏到浏览器,订阅我们!