java ThreadLocal用法详解

喜欢ヅ旅行 2023-01-04 14:34 128阅读 0赞

### 1、ThreadLocal简介 ###

在涉及到多线程需要共享变量的时候，容易出现并发问题，特别是在多个线程需要对一个共享变量进行写入时。为了保证线程安全，一般使用者在访问共享变量时需要进行适当的同步。同步的措施一般是加锁，是得在每个时刻只能有一个线程访问该变量，好处就是便于编码，缺点在于增加了线程间的竞争，降低了效率；第二个是使用ThreadLocal。如果说synchronized是以“时间换空间”，那么ThreadLocal就是以“空间换时间”，因为ThreadLocal的原理就是：对于要在线程间共享的变量，为每个线程都提供一个这样的变量，使得这些变量是线程级别的变量，不同线程之间互不影响，从而达到可以并发访问而不出现并发问题的目的。

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g_size_16_color_FFFFFF_t_70][]

### 2、ThreadLocal使用示例 ###

// 多线程访问一个共享变量时特别容易出现并发问题，特别是在多线程需要对一个共享变量进行写入时
    // threadLocal可以在使用者访问共享变量时进行适当的的同步
    public class ThreadLocalTest {
        // 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() {
                @Override
                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() {
                @Override
                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();
        }
    
    }

**执行程序：**

threadOne:threadOne local variable
    threadTwo:threadTwo local variable
    threadOne remove after:threadOne local variable
    threadTwo remove after:threadTwo local variable
    
    Process finished with exit code 0

### 3、ThreadLocal实现原理 ###

首先看一下ThreadLocal相关类的类图结构:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g_size_16_color_FFFFFF_t_70 1][]

由该图可知，Thread类中有一个threadLocals和一个inheritableThreadLocals，它们都是ThreadLocalMap类型的变量，而ThreadLocalMap是一个定制化的Hashmap。在默认情况下，每个线程中的这两个变量都为null，只有当前线程第一次调用ThreadLocal的set或者get方法时才会创建它们。其实每个线程的本地变量不是存放在ThreadLocal实例里面，而是存放在调用线程的threadLocals变量里面。也就说，ThreadLocal类型的本地变量存放在具体的线程内存空间中。

ThreadLocal就是一个工具壳，它通过set方法把value值放入调用线程的threadLocals里面并存放起来，当调用线程调用它的get方法时，再从当前线程的threadLocals变量里面将其拿出来使用。如果调用线程一直不终止，那么这个本地变量会一直存放在调用线程的threadLocals变量里面，所以当不需要使用本地变量时可以通过调用ThreadLocal变量的remove方法，从当前线程的threadLocals里面删除该本地变量。

### 3.1、set方法源码分析 ###

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

### 3.2、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();
        }

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);
            }
            if (this instanceof TerminatingThreadLocal) {
                TerminatingThreadLocal.register((TerminatingThreadLocal<?>) this);
            }
            return value;
        }

### 3.3、remove方法源码分析 ###

public void remove() {
             ThreadLocalMap m = getMap(Thread.currentThread());
             // 如果当前线程的threadLocals变量不为空，则删除当前线程中指定ThreadLocal实例的本地变量
             if (m != null) {
                 m.remove(this);
             }
         }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g_size_16_color_FFFFFF_t_70 2][]

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

### 4、threadLocal不支持继承性 ###

public class TestThreadLocal {
        // 创建线程变量
        public static ThreadLocal<String> threadLocal = new ThreadLocal<String>();
        public static void main(String[] args) {
            // 设置线程变量
            threadLocal.set("hello world");
            // 启动子线程
            Thread thread = new Thread(new Runnable() {
                public void run() {
                    // 子线程输出线程变量的值
                    System.out.println("thread:" + threadLocal.get());
                }
            });
            thread.start();
            // 主线程输出线程变量的值
            System.out.println("main:" + threadLocal.get());
        }
    }

**执行程序：**

main:hello world
    thread:null

### 5、inheritableThreadLocal类 ###

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

把第四节中创建线程的变量修改为：

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

**运行结果：**

thread:hello world
    main:hello world

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g_size_16_color_FFFFFF_t_70]: /images/20221119/8dca552a583e4fc3a6864ee782d585ca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210110170808603.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210110183052805.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g=,size_16,color_FFFFFF,t_70