ThreadLocal类和ThreadLocalRandom类

一、ThreadLocal类

ThreadLocal可以视作为一个工具类，它并不包含线程变量，线程变量都存储在各自Thread实例中ThreadLocals变量中，实现了线程变量内存隔离，保证线程安全（以空间换取的）。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类核心方法，set与get:实际控制Thread.currentThread().threadLocals对象来操作当前线程的变量

    /**
     * Sets the current thread's copy of this thread-local variable
     * to the specified value.  Most subclasses will have no need to
     * override this method, relying solely on the {@link #initialValue}
     * method to set the values of thread-locals.
     *
     * @param value the value to be stored in the current thread's copy of
     *        this thread-local.
     */
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

    /**
     * Returns the value in the current thread's copy of this
     * thread-local variable.  If the variable has no value for the
     * current thread, it is first initialized to the value returned
     * by an invocation of the {@link #initialValue} method.
     *
     * @return the current thread's value of this thread-local
     */
    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;
            }
        }
        return setInitialValue();
    }

    /**
     * Get the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param  t the current thread
     * @return the map
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;//取当前线程Thread对象中的ThreadLocals变量
    }

实现：

/**
 * 优点：线程之间变量内存隔离，线程安全
 * 缺点：变量保存到当前线程中，线程不结束会一直占用内存，可能导致内存泄漏，需要调用remove清除；ThreadLocal保存到当前线程threadLocals中，不具有继承性，父线程的threadLocalMap取不到；
 */
public class ThreadLocalTest {

    static ThreadLocal<String> localVariable = new ThreadLocal<>();

    static void print(String str){
        System.out.println(str + ":" + localVariable.get());
        localVariable.remove();//内存泄漏    }

    public static void main(String[] args){
        Thread threadOne = new Thread(new Runnable() {
            @Override
            public void run() {
                localVariable.set("threadOne local variable");
                localVariable.set("threadOne local variable2");
                print("threadOne");
                System.out.println("threadOne remove after" + ":" + localVariable.get());
            }
        });
        Thread threadTwo = new Thread(new Runnable() {
            @Override
            public void run() {
                localVariable.set("threadTwo local variable");
                print("threadTwo");
                System.out.println("threadTwo remove after" + ":" + localVariable.get());
            }
        });
        threadOne.start();
        threadTwo.start();
    }
}

二、InheritableThreadLocal类

继承ThreadLocal类，主要解决第二个缺点ThreadLocal不具有继承性，父线程变量取不到

因此在Thread类中加入了inheritableThreadLocals用来存储父线程的变量的拷贝

注意：父线程变量拷贝是在Thread.init方法即创建线程时实现的，所以需要先赋值后创建子线程

        /*
         * Thread.init方法中
         */if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);

实现：

public class InheritableThreadLocalTest {

    static ThreadLocal<String> inheritableLocal = new InheritableThreadLocal<>();

    static void print(String str){
        System.out.println(str + ": parents variable :" + inheritableLocal.get());
    }

    public static void main(String[] args) throws InterruptedException {
        inheritableLocal.set("mainThread variable");//父线程先赋值
        Thread threadOne = new Thread(new Runnable() {
            @Override
            public void run() {
                print("threadOne");
            }
        });
        inheritableLocal.remove();//变量拷贝所以threadOne中不会清除
        Thread threadTwo = new Thread(new Runnable() {
            @Override
            public void run() {
                print("threadTwo");
            }
        });

        threadOne.start();
        threadTwo.start();
    }
}

三、Random类

public class RandomTest {

    public static void main(String[] args){
        Random random = new Random();
        for (int i = 0; i < 10; i++){
            System.out.println(random.nextInt());
        }
    }
}
/*
 * nextInt() 源码
 */
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));//获取nextseed采用CAS保证原子性，多线程会使大量线程进行自旋重试，降低了并发性能。
return (int)(nextseed >>> (48 - bits)); }

四、ThreadLocalRandom类

继承了Random重写了nextInt，类似于ThreadLocal的实现，在各自Thread实例中保存自己的seed，具体声明源码如下。

    // The following three initially uninitialized fields are exclusively
    // managed by class java.util.concurrent.ThreadLocalRandom. These
    // fields are used to build the high-performance PRNGs in the
    // concurrent code, and we can not risk accidental false sharing.
    // Hence, the fields are isolated with @Contended.

    /** The current seed for a ThreadLocalRandom */
    @sun.misc.Contended("tlr")
    long threadLocalRandomSeed;

    /** Probe hash value; nonzero if threadLocalRandomSeed initialized */
    @sun.misc.Contended("tlr")
    int threadLocalRandomProbe;

    /** Secondary seed isolated from public ThreadLocalRandom sequence */
    @sun.misc.Contended("tlr")
    int threadLocalRandomSecondarySeed;

ThreadLocalRandom实现

public class ThreadLocalRandomTest {

    public static void main(String[] args){
        ThreadLocalRandom random = ThreadLocalRandom.current();
        for (int i = 0;i < 10; i++){
            System.out.println(random.nextInt(5));
        }
    }
}

/**
 * nextseed获取源自各自线程中保存的seed，实现了线程隔离
 */
    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);//Thread.currentThread.threadLocalRandomSeed
        return r;
    }

ThreadLocalRandom主要源码模块

1.unsafe初始化

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

2.构造方法私有化，提供静态方法current实例化，保证单例

    /** Constructor used only for static singleton */
    private ThreadLocalRandom() {
        initialized = true; // false during super() call
    }
    static final ThreadLocalRandom = new ThreadLocalRandom();
    /**
     * Returns the current thread's {@code ThreadLocalRandom}.*/
    public static ThreadLocalRandom current() {
        if (UNSAFE.getInt(Thread.currentThread(), PROBE) == 0)//根据当前线程threadLocalRandomProbe标志，判断当前线程threadLocalRandomSeed是否已初始化
            localInit();
        return instance;
    }

    /**
     * Initialize Thread fields for the current thread.  Called only
     * when Thread.threadLocalRandomProbe is zero, indicating that a
     * thread local seed value needs to be generated. Note that even
     * though the initialization is purely thread-local, we need to
     * rely on (static) atomic generators to initialize the values.
     */
    static final void localInit() {
        int p = probeGenerator.addAndGet(PROBE_INCREMENT);
        int probe = (p == 0) ? 1 : p; //初始化probe的值，p等于0时表示未初始化，所以skip掉
        long seed = mix64(seeder.getAndAdd(SEEDER_INCREMENT));//初始化seed的值
        Thread t = Thread.currentThread();
        UNSAFE.putLong(t, SEED, seed);//存到当前线程的threadLocalRandomSeed中
        UNSAFE.putInt(t, PROBE, probe);//
    }

3.随机数

    /**
     * Returns a pseudorandom {@code int} value between zero (inclusive)
     * and the specified bound (exclusive).
     *
     * @param bound the upper bound (exclusive).  Must be positive.
     * @return a pseudorandom {@code int} value between zero
     *         (inclusive) and the bound (exclusive)
     * @throws IllegalArgumentException if {@code bound} is not positive
     */
    public int nextInt(int bound) {
        if (bound <= 0)
            throw new IllegalArgumentException(BadBound);
        int r = mix32(nextSeed());//重点下一个seed
        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;
    }

    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);//取得是当前线程中的threadLocalRandomSeed变量
        return r;
    }

注意：初始化的seed值和probe值是写死的，nextSeed方法中累加的GAMMA也是写死的，所以多个线程第n次取随机数一样

参考《Java并发编程之美》