ThreadLocal & ThreadLocalRandom

[TOC]

ThreadLocal

并发下，多线程对共享变量进行操作，为保证线程安全，通常要控制好各线程的同步情况，最直接的办法是给当前共享变量加锁。

有没有一种方法使得创建一个变量后，每个线程对该变量的访问都是在自己的线程空间中的呢？这就是 ThreadLocal。

测试示例

public static void main(String[] args){

        ThreadLocal<String> testThreadLocal = new ThreadLocal<>();
        testThreadLocal.set("初始值");

        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                testThreadLocal.set("Thread A");
                try {
                    // 让线程A暂停一会，观察B写入是否会产生影响
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("ThreadA's threadLocal:" + testThreadLocal.get());
            }
        });

        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    // 让线程A先执行
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                testThreadLocal.set("Thread B");
                System.out.println("ThreadB's threadLocal:" + testThreadLocal.get());
            }
        });

        threadA.start();
        threadB.start();
    }

可以看出线程内部对 ThreadLocal 变量的操作没有互相影响，保证了该变量在各个线程中的隔离性。

ThreadLocal 实现方式

由图可以看出，Thread 类中有一个 threadsLocals 和一个 inheritableThreadLocals 属性。

默认情况下都为 null ，在线程调用 ThreadLocal 中的 get或set方法时会被创建。下面为 ThreadLocal 中的 set方法，在此添加注释以便说明

public void set(T value) {
    // 获取当前线程
    Thread t = Thread.currentThread();
    // 获取线程的 threadLocals
    // getMap 方法代码为: return t.threadLocals
    ThreadLocalMap map = getMap(t);
    if (map != null)
        // 在线程的 threadLocals 中添加键值对 <当前threadLocals实例引用， 值>
        map.set(this, value);
    else
        createMap(t, value);
}

可以看出，实际上的 ThreadLocals 的值其实是存储在线程的空间中的，每个线程互不干扰，这种操作方式会产生内存泄漏问题，原因如下：

由于 threadLocals 存在于线程中，我们通过get/set对其内容进行操作。若是不需要该 ThreadLocals 实例了呢？很容易明白，存放在 threadLocals 中的变量就会一直存在，造成内存泄漏。

因此当不需要 threadLocal 变量时，一定要使用 ThreadLocal 变量中的 remove方法。

可被子线程继承的 InheritableThreadLocals

由于 ThreadLocal 不具有继承性，于是 InheritableThreadLocals 应运而生。

观察 Thread 的inti方法中有如下代码，当

private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc,
                      boolean inheritThreadLocals) {
        //...
    	// 当 inheritThreadLocals 为 true 且父线程中的 inheritableThreadLocals 不为空
        if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            // 将父线程的 inheritableThreadLocals 复制到子线程当中
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
        //...
    }

ThreadLocalRandom

首先，需要提前直到的是，在计算机中进行随机数生成，需要准备一个 随机数种子 ，用以在运行过程中能报保证产生不同的数字。

在 Java 中，随机数生成会使用 java.util.Random 。使用方法如下：

public static void main(String[] args){
        Random random = new Random();
    	// 生成随机数 0~10
        int r = random.nextInt(10);
        System.out.println(r);
}

Random 中随机数生成策略如下：

使用旧种子生成新种子
使用新种子生成随机数

在并发环境下，可能会导致多个线程使用同一个旧种子，并生成同样的新种子，破坏了随机性，因此要保证对种子操作的原子性，例如：

线程A 使用种子1 生成种子2，那么线程B 需要丢弃旧种子，使用种子1 生成新的种子。

如此保证 Random 在多线程下的随机性。而 Random 采用 CAS 保证原子操作，在多个线程竞争下只会有一个线程生成种子，会造成大量线程自旋重试，降低性能。

于是，ThreadLocalRandom 营运而生。

ThreadLocalRandom 实现

ThreadLocalRandom 原理其实和 ThreadLocal 差不多，下图是 Thread 类中的属性，让每个线程持有一个本地的种子变量，该种子变量只有在使用随机数时才会被初始化。从而在多线程环境下保证了隔离性，避免竞争。