ThreadLocal、InheritableThreadLocal、ThreadLocalRandom

ThreadLocal

ThreadLocal是JDk包提供的，它提供了线程的本地变量，也就是如果你创建了一个ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的一个本地副本。

当多个线程操作这个变量时，实际操作的是自己本地内存里面的变量，从而避免了线程安全问题。

使用示例

public class ThreadLocalTest {
   private static ThreadLocal<String> threadLocal = new ThreadLocal<>();
    
   private static void print(String str) {
      System.out.println(str + ":" + threadLocal.get());
      threadLocal.remove();
   }
    
   public static void main(String[] args) {
      new Thread(() -> {
         threadLocal.set("test t1 ThreadLocal variable");
         print("t1");
         System.out.println("t1 remove after:" + threadLocal.get());
      }).start();

      new Thread(() -> {
         threadLocal.set("test t2 ThreadLocal variable");
         print("t2");
         System.out.println("t2 remove after:" + threadLocal.get());
      }).start();
   }
}

/*
t1:test t1 ThreadLocal variable
t2:test t2 ThreadLocal variable
t1 remove after:null
t2 remove after:null
*/

源码

Thread 类中有两个变量

/* ThreadLocal values pertaining to this thread. This map is maintained
 * by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;

/*
 * InheritableThreadLocal values pertaining to this thread. This map is
 * maintained by the InheritableThreadLocal class.
 */
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

每个线程的本地变量不是存放在ThreadLocal实例里面，而是存放在在调用线程的threadLocals变量里面。

ThreadLocal就是一个工具壳，通过set方法把value值放入线程的threadLocals变量里面并存放起来，当调用线程的get方法时，再从当前线程的threadLocals变量里面取出。

如果线程一直不终止，那么这个本地变量会一直存放在调用线程的threadLocals变量里面，所以不需要本地变量的时可以通过remove方法将其删除。

set

public void set(T value) {
	Thread t = Thread.currentThread();
    // 获取当前线程的 threadLocals 变量
	ThreadLocalMap map = getMap(t);
	if (map != null)
		map.set(this, value);
	else
    // 第一次调用时就创建 ThreadLocalMap
		createMap(t, value);
}

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

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

get

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    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() {
    // 初始化 value 为 null
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}

protected T initialValue() {
    return null;
}

remove

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

InheritableThreadLocal

同一个ThreadLocal变量在父线程中被设置后，在子线程中是获取不到的。

InheritableThreadLocal可以解决这个问题。

使用示例

public class InheritableThreadLocalTest {

   private static ThreadLocal<String> inheritableThreadLocal = new InheritableThreadLocal<>();

   public static void main(String[] args) {
      inheritableThreadLocal.set("hello world");
      new Thread(() -> {
         // 输入 inheritableThreadLocal 中的值
         System.out.println("thread: " + inheritableThreadLocal.get());
      }).start();
      System.out.println("main: " + inheritableThreadLocal.get());
      // 习惯性回收不用的变量
      inheritableThreadLocal.remove();
   }
}
/*
main: hello world
thread: hello world
*/

源码

InheritableThreadLocal重写了三个方法childValue、getMap、createMap，使用了Thread的变量inheritableThreadLocals.

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

childValue在Thread的构建方法调用时执行。

public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);
}

private void init(ThreadGroup g, Runnable target, String name, long stackSize) {
    init(g, target, name, stackSize, null);
}

private void init(ThreadGroup g, Runnable target, String name, long stackSize, AccessControlContext acc) {
    // 获取父线程
    Thread parent = currentThread();
    // ......
    if (parent.inheritableThreadLocals != null)
        this.inheritableThreadLocals = ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
    /* Stash the specified stack size in case the VM cares */
    this.stackSize = stackSize;

    /* Set thread ID */
    tid = nextThreadID();
}

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

private ThreadLocalMap(ThreadLocalMap parentMap) {
    // 获取父线程 ThreadLocalMap 的所有 Entry
    Entry[] parentTable = parentMap.table;
    int len = parentTable.length;
    // Set the resize threshold to maintain at worst a 2/3 load factor.
    setThreshold(len);
    // 初始化当前线程的 table 值
    table = new Entry[len];
	// 遍历父线程的 table
    for (int j = 0; j < len; j++) {
        Entry e = parentTable[j];
        if (e != null) {
            @SuppressWarnings("unchecked")
            ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
            if (key != null) {
               	// 调用 InheritableThreadLocal 重写的方法 childValue
                Object value = key.childValue(e.value);
                Entry c = new Entry(key, value);
                int h = key.threadLocalHashCode & (len - 1);
                while (table[h] != null)
                    h = nextIndex(h, len);
                // 将新生成的 Entry 方到当前线程的 table 中
                table[h] = c;
                size++;
            }
        }
    }
}

Random

public int nextInt(int bound) {
    if (bound <= 0)
        throw new IllegalArgumentException(BadBound);
	// 1.根据老的种子生成新的种子
    int r = next(31);
    // 2.根据新的种子计算随机数
    int m = bound - 1;
    if ((bound & m) == 0)  // i.e., bound is a power of 2
        r = (int)((bound * (long)r) >> 31);
    else {
        for (int u = r; u - (r = u % bound) + m < 0; u = next(31))
            ;
    }
    return r;
}

// 采用CAS的方式生成新的种子，多线程下进行CAS只会有一个线程会成功，所以会造成大量线程进行自旋重试，这会降低并发性能
protected int next(int bits) {
    long oldseed, nextseed;
    AtomicLong seed = this.seed;
    do {
        oldseed = seed.get();
        nextseed = (oldseed * multiplier + addend) & mask;
    } while (!seed.compareAndSet(oldseed, nextseed));
    return (int)(nextseed >>> (48 - bits));
}

ThreadLocalRandom

为了弥补Random的缺陷。新增了ThreadLocalRandom，在JUC包下。

ThreadLocalRandom继承了Random，并重写了nextInt等方法，没有使用父类的原子性种子变量。

ThreadLocalRandom中并没有存放具体的种子，而是存放在Thread中的threadLocalRandomSeed变量里面。

当线程调用ThreadLocalRandom的current方法时，会初始化此种子变量。

主要代码实现逻辑

// Unsafe mechanics
private static final sun.misc.Unsafe UNSAFE;
private static final long SEED;
private static final long PROBE;
private static final long SECONDARY;
static {
    try {
        UNSAFE = sun.misc.Unsafe.getUnsafe();
        Class<?> tk = Thread.class;
        SEED = UNSAFE.objectFieldOffset
            (tk.getDeclaredField("threadLocalRandomSeed"));
        PROBE = UNSAFE.objectFieldOffset
            (tk.getDeclaredField("threadLocalRandomProbe"));
        SECONDARY = UNSAFE.objectFieldOffset
            (tk.getDeclaredField("threadLocalRandomSecondarySeed"));
    } catch (Exception e) {
        throw new Error(e);
    }
}

current

public static ThreadLocalRandom current() {
    // 判断 threadLocalRandomProbe 是否为0
    if (UNSAFE.getInt(Thread.currentThread(), PROBE) == 0)
        // 计算当前线程的初始化种子变量
        localInit();
    return instance;
}

static final void localInit() {
    int p = probeGenerator.addAndGet(PROBE_INCREMENT);
    int probe = (p == 0) ? 1 : p; // skip 0
    long seed = mix64(seeder.getAndAdd(SEEDER_INCREMENT));
    Thread t = Thread.currentThread();
    UNSAFE.putLong(t, SEED, seed);
    UNSAFE.putInt(t, PROBE, probe);
}

nextInt

public int nextInt(int bound) {
    if (bound <= 0)
        throw new IllegalArgumentException(BadBound);
    // 根据当前线程种的种子计算新种子
    int r = mix32(nextSeed());
    // 根据新种子和bound计算随机数
    int m = bound - 1;
    if ((bound & m) == 0) // power of two
        r &= m;
    else { // reject over-represented candidates
        for (int u = r >>> 1; u + m - (r = u % bound) < 0;  u = mix32(nextSeed()) >>> 1)
            ;
    }
    return r;
}

nextSeed

final long nextSeed() {
    Thread t; long r; // read and update per-thread seed
    UNSAFE.putLong(t = Thread.currentThread(), SEED,
                   r = UNSAFE.getLong(t, SEED) + GAMMA);
    return r;
}

首先使用r = UNSAFE.getLong(t, SEED)获取当前线程中threadLocalRandomSeed变量的值，然后在种子的基础上加GAMMA值作为新种子。

然后使用UNSAFE.putLong把新种子放入当前线程的threadLocalRandomSeed变量中。