ThreadLocal原理分析与代码验证

ThreadLocal提供了线程安全的数据存储和访问方式，利用不带key的get和set方法，居然能做到线程之间隔离，非常神奇。

比如

ThreadLocal threadLocal = new ThreadLocal<>();

in thread 1

//in thread1
treadLocal.set("value1");
.....
//value的值是value1
String value = threadLocal.get();

in thread 2

//in thread2
treadLocal.set("value2");
.....
//value的值是value2
String value = threadLocal.get();

不论thread1和thread2是不是同时执行，都不会有线程安全问题，我们来测试一下。

线程安全测试

开10个线程，每个线程内都对同一个ThreadLocal对象set不同的值，会发现ThreadLocal在每个线程内部get出来的值，只会是自己线程内set进去的值，不会被别的线程影响。

static void testUsage() throws InterruptedException {
    Utils.println("-------------testUsage-------------------");
    ThreadLocal threadLocal = new ThreadLocal<>();

    AtomicBoolean threadSafe = new AtomicBoolean(true);
    int count = 10;
    CountDownLatch countDownLatch = new CountDownLatch(count);
    Random random = new Random(736832);
    for (int i = 0; i < count; i ++){
        new Thread(() -> {
            try {
                //生成一个随机数
                Long value = System.nanoTime() + random.nextInt();
                threadLocal.set(value);
                Thread.sleep(1000);

                Long value2 = threadLocal.get();
                if (!value.equals(value2)) {
                    //get和set的value不一致，说明被别的线程修改了，但这是不可能出现的
                    threadSafe.set(false);
                    Utils.println("thread unsafe, this could not be happen!");
                }
            } catch (InterruptedException e) {

            }finally {
                countDownLatch.countDown();
            }

        }).start();
    }

    countDownLatch.await();

    Utils.println("all thread done, and threadSafe is " + threadSafe.get());
    Utils.println("------------------------------------------");
}

输出：

-------------testUsage------------------
all thread done, and threadSafe is true
-----------------------------------------

原理浅析

翻开ThreadLocal的源码，会发现ThreadLocal只是一个空壳子，它并不存储具体的value，而是利用当前线程（Thread.currentThread()）的threadLocalMap来存储value，key就是这个threadLocal对象本身。

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

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

Thread的threadLocals字段是ThreadLocalMap类型（你可以简单理解为一个key value的Map），key是ThreadLocal对象，value是我们在外层设置的值

• 当我们调用threadLocal.set(value)方法的时候，会找到当前线程的threadLocals这个map，然后以this作为key去set key value
• 当我们调用threadLocal.get()方法的时候，会找到当前线程的threadLocals这个map，然后以this作为key去get value
• 当我们调用threadLocal.remove()方法的时候，会找到当前线程的threadLocals这个map，然后以this作为key去remove

这就相当于：

Thread.currentThread().threadLocals.set(threadLocal1, "value1");
.....
//value的值是value1
String value = Thread.currentThread().threadLocals.get(threadLocal1);

因为每个Thread都是不同的对象，所以他们的threadLocals也是不同的map，threadLocal在不同的线程里工作时，实际上是从不同的map里get/set，这也就是线程安全的原因了，了解到这一点就差不多了。

再深入一些，ThreadLocalMap的结构

如果继续翻ThreadLocalMap的源码，会发现它有个字段table，是Entry类型的数组。

我们不妨写段代码，把ThreadLocalMap的结构输出出来。

由于Thread.threadLocals和ThreadLocalMap类不是public的，我们只有通过反射来获取它的值。反射的代码如下（如果嫌长可以不看，直接看输出）：

static Object getThreadLocalMap(Thread thread) throws NoSuchFieldException, IllegalAccessException {        
    //get thread.threadLocals
    Field threadLocals = Thread.class.getDeclaredField("threadLocals");
    threadLocals.setAccessible(true);
    return threadLocals.get(thread);
}

static void printThreadLocalMap(Object threadLocalMap) throws NoSuchFieldException, IllegalAccessException {
    String threadName = Thread.currentThread().getName();
    
    if(threadLocalMap == null){
        Utils.println("threadMap is null, threadName:" + threadName);
        return;
    }

    Utils.println(threadName);

    //get threadLocalMap.table
    Field tableField = threadLocalMap.getClass().getDeclaredField("table");
    tableField.setAccessible(true);
    Object[] table = (Object[])tableField.get(threadLocalMap);
    Utils.println("----threadLocals (ThreadLocalMap), table.length = " + table.length);

    for (int i = 0; i < table.length; i ++){
        WeakReference> entry = (WeakReference>)table[i];
        printEntry(entry, i);
    }
}
static void printEntry(WeakReference> entry, int i) throws NoSuchFieldException, IllegalAccessException {
    if(entry == null){
        Utils.println("--------table[" + i + "] -> null");
        return;
    }
    ThreadLocal key = entry.get();
    //get entry.value
    Field valueField = entry.getClass().getDeclaredField("value");
    valueField.setAccessible(true);
    Object value = valueField.get(entry);

    Utils.println("--------table[" + i + "] -> entry key = " + key + ", value = " + value);
}

测试代码：

static void testStructure() throws InterruptedException {
    Utils.println("-------------testStructure----------------");
    ThreadLocal threadLocal1 = new ThreadLocal<>();
    ThreadLocal threadLocal2 = new ThreadLocal<>();

    Thread thread1 = new Thread(() -> {
        threadLocal1.set("threadLocal1-value");
        threadLocal2.set("threadLocal2-value");

        try {
            Object threadLocalMap = getThreadLocalMap(Thread.currentThread());
            printThreadLocalMap(threadLocalMap);

        } catch (NoSuchFieldException | IllegalAccessException e) {
            e.printStackTrace();
        }

    }, "thread1");

    thread1.start();

    //wait thread1 done
    thread1.join();

    Thread thread2 = new Thread(() -> {
        threadLocal1.set("threadLocal1-value");
        try {
            Object threadLocalMap = getThreadLocalMap(Thread.currentThread());
            printThreadLocalMap(threadLocalMap);

        } catch (NoSuchFieldException | IllegalAccessException e) {
            e.printStackTrace();
        }

    }, "thread2");

    thread2.start();
    thread2.join();
    Utils.println("------------------------------------------");
}

我们在创建了两个ThreadLocal的对象threadLocal1和threadLocal2，在线程1里为这两个对象设置值，在线程2里只为threadLocal1设置值。然后分别打印出这两个线程的threadLocalMap。

输出结果为：

-------------testStructure----------------
thread1
----threadLocals (ThreadLocalMap), table.length = 16
--------table[0] -> null
--------table[1] -> entry key = java.lang.ThreadLocal@33baa315, value = threadLocal2-value
--------table[2] -> null
--------table[3] -> null
--------table[4] -> null
--------table[5] -> null
--------table[6] -> null
--------table[7] -> null
--------table[8] -> null
--------table[9] -> null
--------table[10] -> entry key = java.lang.ThreadLocal@4d42db5c, value = threadLocal1-value
--------table[11] -> null
--------table[12] -> null
--------table[13] -> null
--------table[14] -> null
--------table[15] -> null
thread2
----threadLocals (ThreadLocalMap), table.length = 16
--------table[0] -> null
--------table[1] -> null
--------table[2] -> null
--------table[3] -> null
--------table[4] -> null
--------table[5] -> null
--------table[6] -> null
--------table[7] -> null
--------table[8] -> null
--------table[9] -> null
--------table[10] -> entry key = java.lang.ThreadLocal@4d42db5c, value = threadLocal1-value
--------table[11] -> null
--------table[12] -> null
--------table[13] -> null
--------table[14] -> null
--------table[15] -> null
------------------------------------------

从结果上可以看出：

• 线程1和线程2的threadLocalMap对象的table字段,是个数组，长度都是16
• 由于线程1里给两个threadLocal对象设置了值，所以线程1的ThreadLocalMap里有两个entry，数组下标分别是1和10，其余的是null（如果你自己写代码验证，下标不一定是1和10，不需要纠结这个问题，只要前后对的上就行）
• 由于线程2里只给一个threadLocal对象设置了值，所以线程1的ThreadLocalMap里只有一个entry，数组下标是10，其余的是null
• threadLocal1这个对象在两个线程里都设置了值，所以当它作为key加入二者的threadLocalMap时，key是一样的，都是java.lang.ThreadLocal@4d42db5c；下标也是一样的，都是10。

为什么是WeakReference

查看Entry的源码，会发现Entry继承自WeakReference：

static class Entry extends WeakReference> {
    /** The value associated with this ThreadLocal. */
    Object value;

    Entry(ThreadLocal k, Object v) {
        super(k);
        value = v;
    }
}

构造函数里把key传给了super，也就是说，ThreadLocalMap中对key的引用，是WeakReference的。

Weak reference objects, which do not prevent their referents from being
made finalizable, finalized, and then reclaimed. Weak references are most
often used to implement canonicalizing mappings.

通俗点解释：

当一个对象仅仅被weak reference（弱引用）, 而没有任何其他strong reference（强引用）的时候, 不论当前的内存空间是否足够，当GC运行的时候， 这个对象就会被回收。

看不明白没关系，还是写代码测试一下什么是WeakReference吧...

static void testWeakReference(){
    Object obj1 = new Object();
    Object obj2 = new Object();
    WeakReference