JUC并发编程(二)---- ThreadLocal

最新推荐文章于 2022-08-08 20:03:05 发布

冬瓜闯世界

最新推荐文章于 2022-08-08 20:03:05 发布

阅读量256

点赞数 1

分类专栏：并发编程

本文链接：https://blog.csdn.net/qq_43404873/article/details/112781399

版权

并发编程专栏收录该内容

3 篇文章 0 订阅

订阅专栏

ThreadLocal

多线程访问同一个共享变量时特别容易出现并发问题，特别是在多个线程需要对一个共享变量进行写入时。为了保证线程安全，一般使用者在访问共享变量时需要进行适当的同步，如下图所示：
在这里插入图片描述
这时候ThreadLocal就出来了。当创建一个变量后，每个线程对其进行访问的时候访问的是自己线程的变量。

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

ThreadLocal使用示例

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

public class ThreadLoaclTest {
    //创建ThreadLocal变量
    static  ThreadLocal<String> localVariable = new ThreadLocal<>();


    //print函数
    static  void print(String str){
        //打印当前线程本地内存中localVariable变量的值
        System.out.println(str+":"+ localVariable.get());

        //清除当前线程本地内存中的localVariable变量
        //localVariable.remove();
    }

    public static void main(String[] args) {
        //创建线程A
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                //设置线程A中本地变量localVariable的值
                localVariable.set("threadA local variable");
                //调用打印函数
                print("threadA");
                //打印本地变量值
                System.out.println("threadA remove after"+":"+localVariable.get());
            }
        });

        //创建线程B
        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                //设置线程A中本地变量localVariable的值
                localVariable.set("threadB local variable");
                //调用打印函数
                print("threadB");
                //打印本地变量值
                System.out.println("threadB remove after"+":"+localVariable.get());
            }
        });

        //启动线程
        threadA.start();
        threadB.start();
    }
}

输出结果如下:
在这里插入图片描述
取消localVariable.remove();的注释，在来看运行结果:

我们可以得出一个结论，创建一个ThreadLocal变量后，每个线程都会复制一个变量到自己的本地内存，线程中使用的是复制的变量。

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方法的源码实现：
1.void set(T value)

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

getMap(Thread t)的源码如下：

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

可以看到，getMap(t)的作用是获取线程自己的变量threadLocals，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变量。

2.T get()

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

setInitialValue（）的代码如下:

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

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中的本地变量。

在这里插入图片描述

ThreadLocal不支持继承性

首先来看一个例子:

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

    public static void main(String[] args) {
        //设置线程变量
        threadLocal.set("Hello world");
        //启动子线程
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                //子线程输出线程变量的值
                System.out.println("thread："+threadLocal.get());
            }
        });
        thread.start();
        //主线程输出线程变量的值
        System.out.println("main："+threadLocal.get());
    }
}

输出结果如下：
在这里插入图片描述
也就是说，同一个ThreadLocal变量在父线程中被设置值后，在子线程中是获取不到的。那么有没有办法让子线程能访问到父线程中的值? 可以通过InheritableThreadLocal类。

InheritableThreadLocal类

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

public class InheritableThreadLocal<T> extends ThreadLocal<T> {
    protected T childValue(T parentValue) {
        return parentValue;
    }

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

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

InheritableThreadLocal重写了createMap方法，那么现在当第一次调用set方法时，创建的是当前线程的inheritableThreadLocals变量的实例而不再是threadLocals。

由getMap()可知，当调用get方法获取当前线程内部的map变量时，获取的是inheritableThreadLocals而不再是threadLocals。

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

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 (inheritThreadLocals && parent.inheritableThreadLocals != null)
        	//(6)设置子线程中的inheritableThreadLocals变量
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
        this.stackSize = stackSize;
        tid = nextThreadID();
    }

代码(4)获取了当前线程(这里是指main函数所在的线程，也就是父线程)。然后代码(5)判断main函数所在的线程里面的inheritableThreadLocals属性是否为null，前面我们讲了InheritableThreadLocal类的get和set方法操作的是inheritableThreadLocals，所以这里的inheritableThreadLocal变量不为null，因此会执行代码（6）。

下面看下createInheritedMap的源码:

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

可以看到，在createInheritedMap内部使用父线程的inheritableThreadLocals变量作为构造函数创建了一个新的ThreadLocalMap变量，然后赋值给了子线程的inheritableThreadLocals变量。

ThreadLocalMap源码:

private ThreadLocalMap(ThreadLocalMap parentMap) {
            Entry[] parentTable = parentMap.table;
            int len = parentTable.length;
            setThreshold(len);
            table = new Entry[len];

            for (Entry e : parentTable) {
                if (e != null) {
                    @SuppressWarnings("unchecked")
                    ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
                    if (key != null) {
                   		//（7）重写的方法
                        Object value = key.childValue(e.value);//返回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对象中。

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

修改上面示例的代码如下:

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

运行结果如下:
在这里插入图片描述
可见，现在可以从子线程正常获取到线程变量的值。

冬瓜闯世界

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JUC并发编程(二)---- ThreadLocal

ThreadLocal多线程访问同一个共享变量时特别容易出现并发问题，特别是在多个线程需要对一个共享变量进行写入时。为了保证线程安全，一般使用者在访问共享变量时需要进行适当的同步，如下图所示：这时候ThreadLocal就出来了。当创建一个变量后，每个线程对其进行访问的时候访问的是自己线程的变量。也就是如果你创建了一个ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的一个本地副本。当多个线程操作这个变量时，实际操作的是自己本地内存里面的变量，从而避免了线程安全问题。创建一个Thr
复制链接

扫一扫