Java 多线程为啥要有ThreadLocal，怎么用，这篇讲全了！-六虎

本文为社区首发签约文章，14天内制止转载，14天后未获授权制止转载，侵权必究！

前面咱们学习的线程并发时的同步控制，是为了确保多个线程对同享数据争用时的正确性的。那假如一个操作自身不触及对同享数据的运用，相反，仅仅希望变量只能由创立它的线程运用（即线程阻隔）就需求到线程本地存储了。

Java 经过 ThreadLocal 供给了程序对线程本地存储的运用。

经过创立 ThreadLocal 类的实例，让咱们可以创立只能由同一线程读取和写入的变量。因而，即便两个线程正在执行相同的代码，而且代码引证了相同称号的 ThreadLocal 变量，这两个线程也无法看到彼此的存储在 ThreadLocal 里的值。否则也就不能叫线程本地存储了。

本文纲要如下：

ThreadLocal

ThreadLocal 是 Java 内置的类，全称 java.lang.ThreadLoal， java.lang 包里界说的类和接口在程序里都是可以直接运用，不需求导入的。

ThreadLocal 的类界说如下：

public class ThreadLocal<T> {
    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        //......
        return setInitialValue();
    }
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            map.set(this, value);
        } else {
            createMap(t, value);
        }
    }
     public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null) {
             m.remove(this);
         }
     }
    protected T initialValue() {
        return null;
    }
    public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
        return new SuppliedThreadLocal<>(supplier);
    }
    // ...
}

上面仅仅列出了 ThreadLocal类里咱们常常会用到的办法，这几个办法他们的阐明如下。

T get()– 用于获取 ThreadLocal 在当时线程中保存的变量副本。
void set(T value) – 用于向ThreadLocal中设置当时线程中变量的副本。
void remove() – 用于删去当时线程保存在ThreadLocal中的变量副本。
initialValue() – 为 ThreadLocal 设置默许的 get办法获取到的始值，默许是 null ，想修正的话需求用子类重写 initialValue 办法，或者是用TheadLocal供给的withInitial办法。

下面咱们具体看一下 ThreadLocal 的运用。

创立和读写 ThreadLocal

经过上面 ThreadLocal 类的界说咱们能看出来， ThreadLocal 是支持泛型的，所以在创立 ThreadLocal 时没有什么特别需求的情况下，咱们都会为其供给类型参数，这样在读取运用 ThreadLocal 变量时就能免除类型转化的操作。

private ThreadLocal threadLocal = new ThreadLocal();
threadLocal.set("A thread local value");
// 创立时没有运用泛型指定类型，默许是 Object
// 运用时要先做类型转化
String threadLocalValue = (String) threadLocal.get();

上面这个比如，在创立 ThreadLocal 时没有运用泛型指定类型，所以存储在其中的值默许是 Object 类型，这样就需求在运用时先做类型转化才行。

下面再看一个运用泛型的版本

private ThreadLocal<String> myThreadLocal = new ThreadLocal<String>();
myThreadLocal.set("Hello ThreadLocal");
String threadLocalValue = myThreadLocal.get();

现在咱们只能把 String 类型的值存到 ThreadLocal 中，而且从 ThreadLocal 读取出值后也不再需求进行类型转化。

关于泛型运用方面的具体解说，可以看本系列中的泛型章节。

看了这篇Java 泛型通关指南，再也不怵满屏尖括号了

想要删去一个 ThreadLocal 实例里存储的值，只需求调用ThreadLocal实例中的 remove 办法即可。

myThreadLocal.remove();

当然，这个删去操作仅仅删去的变量在本地线程中的副本，其他线程不会受到本线程中删去操作的影响。下面咱们把 ThreadLocal 的创立、读写和删去攒一个简单的比如，做下演示。

// 源码: https://github.com/kevinyan815/JavaXPlay/blob/main/src/com/threadlocal/ThreadLocalExample.java
package com.threadlocal;
public class ThreadLocalExample {
    private  ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
    private void setAndPrintThreadLocal() {
        threadLocal.set((int) (Math.random() * 100D) );
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println( Thread.currentThread().getName() + ": " + threadLocal.get() );
        if ( threadLocal.get() % 2 == 0) {
            // 测试删去 ThreadLocal
            System.out.println(Thread.currentThread().getName() + ": 删去ThreadLocal");
            threadLocal.remove();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        ThreadLocalExample tlExample = new ThreadLocalExample();
        Thread thread1 = new Thread(() -> tlExample.setAndPrintThreadLocal(), "线程1");
        Thread thread2 = new Thread(() -> tlExample.setAndPrintThreadLocal(), "线程2");
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
    }
}

上面的例程会有如下输出，当然假如刚好两个线程里 ThreadLocal 变量里存储的都是偶数的话，就不会有第三行输出啦。

线程2: 97
线程1: 64
线程1: 删去ThreadLocal

本比如的源码项目放在了GitHub上，需求的可自行取用进行参阅：ThreadLocal变量操作示例–增删查

为 ThreadLocal 设置初始值

在程序里，声明ThreadLocal类型的变量时，咱们可以一起为变量设置一个自界说的初始值，这样做的好处是，即便没有运用 set 办法给 ThreadLocal 变量设置值的情况下，调用ThreadLocal变量的 get() 时能回来一个对业务逻辑来说更有意义的初始值，而不是默许的 Null 值。

在 Java 中有两种办法可以指定 ThreadLocal 变量的自界说初始值：

创立一个 ThreadLocal 的子类，掩盖 initialValue() 办法，程序中则运用ThreadLocal子类创立实例变量。
运用 ThreadLocal 类供给的的静态办法 withInitial(Supplier<? extends S> supplier) 来创立 ThreadLocal 实例变量，该办法接纳一个函数式接口 Supplier 的完成作为参数，在 Supplier 完成中为 ThreadLocal 设置初始值。

关于函数式接口Supplier假如你还不太清楚的话，可以查看系列中函数式编程接口章节中的具体内容。下面咱们看看别离用这两种办法怎样给 ThreadLocal 变量供给初始值。

运用子类掩盖 initialValue() 设置初始值

经过界说ThreadLocal 的子类，在子类中掩盖 initialValue() 办法的办法给 ThreadLocal 变量设置初始值的办法，可以运用匿名类，简化创立子类的过程。

下面咱们在程序里创立 ThreadLocal 实例时，直接运用匿名类来掩盖 initialValue() 办法的一个比如。

public class ThreadLocalExample {
    private ThreadLocal threadLocal = new ThreadLocal<Integer>() {
        @Override protected Integer initialValue() {
            return (int) System.currentTimeMillis();
        }
    };
	......   
}

有同学可能会问，这块能不能用 Lambda 而不是用匿名类，答案是不能，在这个专栏讲 Lambda 的文章中咱们说过，Lambda 只能用于完成函数式接口（接口中有且只有一个笼统办法，所以这儿只能运用匿名了简化创立子类的过程，不过另外一种经过withInitial办法创立并自界说初始化ThreadLocal变量的时候，是可以运用Lambda 的，咱们下面看看运用 withInital 静态办法设置 ThreadLocal 变量初始值的演示。

经过 withInital 静态办法设置初始值

为 ThreadLocal 实例变量指定初始值的第二种办法是运用 ThreadLocal 类供给的静态工厂办法 withInitial 。withInitial 办法接纳一个函数式接口 Supplier 的完成作为参数，在 Supplier 的完成中咱们可以为要创立的 ThreadLocal 变量设置初始值。

Supplier 接口是一个函数式接口，表示供给某种值的函数。 Supplier 接口也可以被认为是工厂接口。

@FunctionalInterface public interface Supplier { T get(); }

下面的程序里，咱们用 ThreadLocal 的 withInitial 办法为 ThreadLocal 实例变量设置了初始值

public class ThreadLocalExample {
    private ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(new Supplier<Integer>() {
        @Override
        public String get() {
            return (int) System.currentTimeMillis();
        }
    });
	......   
}

关于函数式接口，天经地义会想到用 Lambda 来完成。上面这个 withInitial 的比如用 Lambda 完成的话能进一步简化成：

public class ThreadLocalExample {
	private ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> (int) System.currentTimeMillis());
	......
}

关于 Lambda 和函数式接口 Supplier 的具体内容，可以经过本系列中与这两个主题相关的文章进行学习。

Java Lambda 表达式的各种形状和运用场景，看这篇就够了

Java 中那些绕不开的内置接口 — 函数式编程和 Java 的内置函数式接口

ThreadLocal 在父子线程间的传递

ThreadLocal 供给的线程本地存储，给数据供给了线程阻隔，但是有的时候用一个线程敞开的子线程，往往是需求些相关性的，那么父线程的ThreadLocal中存储的数据能在子线程中运用吗？答案是不行……那怎样能让父子线程上下文能关联起来，Java 为这种情况专门供给了InheritableThreadLocal 给咱们运用。

InheritableThreadLocal 是 ThreadLocal 的一个子类，其界说如下：

public class InheritableThreadLocal<T> extends ThreadLocal<T> {
    protected T childValue(T parentValue) {
        return parentValue;
    }
    /**
     * Get the map associated with a ThreadLocal.
     *
     * @param t the current thread
     */
    ThreadLocalMap getMap(Thread t) {
       return t.inheritableThreadLocals;
    }
    /**
     * Create the map associated with a ThreadLocal.
     *
     * @param t the current thread
     * @param firstValue value for the initial entry of the table.
     */
    void createMap(Thread t, T firstValue) {
        t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
    }
}

与 ThreadLocal 让线程具有变量在本地存储的副本这个形式不同的是，InheritableThreadLocal 答应让创立它的线程和其子线程都能访问到在它里边存储的值。

下面是一个 InheritableThreadLocal 的运用示例

// 源码: https://github.com/kevinyan815/JavaXPlay/blob/main/src/com/threadlocal/InheritableThreadLocalExample.java
package com.threadlocal;
public class InheritableThreadLocalExample {
    public static void main(String[] args) {
        ThreadLocal<String> threadLocal = new ThreadLocal<>();
        InheritableThreadLocal<String> inheritableThreadLocal =
                new InheritableThreadLocal<>();
        Thread thread1 = new Thread(() -> {
            System.out.println("===== Thread 1 =====");
            threadLocal.set("Thread 1 - ThreadLocal");
            inheritableThreadLocal.set("Thread 1 - InheritableThreadLocal");
            System.out.println(threadLocal.get());
            System.out.println(inheritableThreadLocal.get());
            Thread childThread = new Thread( () -> {
                System.out.println("===== ChildThread =====");
                System.out.println(threadLocal.get());
                System.out.println(inheritableThreadLocal.get());
            });
            childThread.start();
        });
        thread1.start();
        Thread thread2 = new Thread(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("===== Thread2 =====");
            System.out.println(threadLocal.get());
            System.out.println(inheritableThreadLocal.get());
        });
        thread2.start();
    }
}

运行程序后，会有如下输出

===== Thread 1 =====
Thread 1 - ThreadLocal
Thread 1 - InheritableThreadLocal
===== ChildThread =====
null
Thread 1 - InheritableThreadLocal
===== Thread2 =====
null
null

这个例程中创立了别离创立了 ThreadLocal 和 InheritableThreadLocal的实例，然后例程中创立的线程Thread1，在线程 Thread1中向 ThreadLocal 和 InheritableThreadLocal 实例中都存储了数据，并测验在敞开了的子线程 ChildThread 中访问这两个数据。依照上面的解释，ChildThread 应该只能访问到父线程存储在 InheritableThreadLocal 实例中的数据。

在例程的最后，程序又创立了一个与 Thread1 不相干的线程 Thread2，它在访问 ThreadLocal 和 InheritableThreadLocal 实例中存储的数据时，由于它自己没有设置过，所以最后得到的结果都是 null。

ThreadLocal 的完成原理

梳理完 ThreadLocal 相关的常用功能都怎样运用后，咱们再来简单过一下 ThreadLocal 在 Java 中的完成原理。

在 Thread 类中维护着一个 ThreadLocal.ThreadLocalMap 类型的成员变量threadLocals。这个成员变量便是用来存储当时线程独占的变量副本的。

public class Thread implements Runnable {
    // ...
    ThreadLocal.ThreadLocalMap threadLocals = null;
    // ...
}

ThreadLocalMap类是 ThreadLocal 中的静态内部类，其界说如下。

package java.lang;
public class ThreadLocal<T> {
    // ...
	static class ThreadLocalMap {
    	// ...
    	static class Entry extends WeakReference<ThreadLocal<?>> {
        	/** The value associated with this ThreadLocal. */
        	Object value;
        	Entry(ThreadLocal<?> k, Object v) {
            	super(k);
            	value = v;
        	}
    	}
    	// ...
	}
}

它维护着一个 Entry 数组，Entry 承继了 WeakReference ，所以是弱引证。 Entry 用于保存键值对，其中：

key 是 ThreadLocal 目标；
value 是传递进来的目标（变量副本）。

ThreadLocalMap 虽然是类似 HashMap 结构的数据结构，但它处理哈希磕碰的时候，运用的计划并非像 HashMap 那样运用拉链法（用链表保存抵触的元素）。

实际上，ThreadLocalMap 采用了线性勘探的办法来处理哈希磕碰抵触。所谓线性勘探，便是依据初始 key 的 hashcode 值确认元素在哈希表数组中的方位，假如发现这个方位上已经被其他的 key 值占用，则运用固定的算法寻找一定步长的下个方位，顺次判别，直至找到可以寄存的方位。

总结

关于 ThreadLocal 的内容就介绍到这了，这块内容在一些基础的面试中还是挺常被问到的，与它一起常常被问到的还有一个 volatile 关键字，这部分内容咱们放到下一篇再讲，喜爱本文的内容还请给点个赞，点个重视，这样就能及时跟上后面的更新啦。

引证链接

Java并发编程–多线程间的同步控制和通信
看了这篇Java 泛型通关指南，再也不怵满屏尖括号了
Java Lambda 表达式的各种形状和运用场景，看这篇就够了
Java 中那些绕不开的内置接口 — 函数式编程和 Java 的内置函数式接口
ThreadLocal变量操作示例–增删查源代码

Java 多线程为啥要有ThreadLocal，怎么用，这篇讲全了！

ThreadLocal

创立和读写 ThreadLocal

为 ThreadLocal 设置初始值

运用子类掩盖 initialValue() 设置初始值

经过 withInital 静态办法设置初始值

ThreadLocal 在父子线程间的传递

ThreadLocal 的完成原理

总结

引证链接

相关文章

从 select、poll、epoll 回答IO多路复用

从零开始学习构建系统之概述

程序界鄙视链的终点

以编程方式在线性布局设置边距实现｜ Java Debug 笔记

作者信息