读懂ThreadLocal

ThreadLocal该类可以实现线程本地变量，即每个线程访问的变量是属于不同的副本的。先来段测试代码，然后根据源码解读其实现原理。

package com.walterlife.javacore;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadLocalTest {
    public static class Task implements Runnable {
        private ThreadLocal threadLocal = new ThreadLocal();

        @Override
        public void run() {
            threadLocal.set((int)(Math.random() * 100D));
            try {
                Thread.sleep(1000); // sleep为了可以使每个线程变量赋值语句执行完毕
            } catch (InterruptedException e) {

            }
            System.out.println(threadLocal.get());
        }
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        Task task = new Task();
        executorService.execute(task);
        executorService.execute(task);
        executorService.shutdown();
    }
}

上述代码中在多线程中使用threadLocal静态变量，来表示线程本地变量，运行结果为:2个线程结果不一致

16
82

现在开始解读其原理，先从ThreadLocal.set 方法说起，代码如下

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

第一次set肯定先调用createMap 创建Thread的ThreadLocalMap对象，

// t 是Thread线程对象,所以ThreadLocalMap是属于Thread的，存储值k:v -> ThreadLocal:value,map中可以存储多个ThreadLocal值
t.threadLocals = new ThreadLocalMap(this, firstValue);

其中ThreadLocalMap就是最核心的机制，该类型可以看作是自己内部实现的HashMap
其中存储key/value的类实现如下，

 static class Entry extends WeakReference<ThreadLocal<?>> {
            /** 该值就是与ThreadLocal关联的线程需要读写的值 */
            Object value;

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

然后ThreadLocalMap使用Entry[] table 来存储多个ThreadLocal，来实现多个私有变量的读写。
然后我们继续之前set方法的调用 map.set(this, value)，这里最终调用的就是ThreadLocalMap的set方法

private void set(ThreadLocal<?> key, Object value) {
            Entry[] tab = table;
            int len = tab.length;
            // 计算hashcode值，即table索引值
            int i = key.threadLocalHashCode & (len-1);

            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();

                if (k == key) {
                    e.value = value;
                    return;
                }

                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                // 对table进行扩容操作
                rehash();
}       

至此 ThreadLocal的set机制已经了解的差不多了其根本思想就是使用HashTable存储机制存储多个ThreadLocal->value键值对。
那么get方法就比较好理解啦，顾名思义就是先取到当前线程的ThreadLocalMap，然后用ThreadLocal当作key值去index找到value值。代码也很简单

private Entry getEntry(ThreadLocal<?> key) {
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            if (e != null && e.get() == key)
                return e;
            else
                return getEntryAfterMiss(key, i, e);
}

另外Entry继承的引用的弱引用(WeakReference)，这么做可以在JVM垃圾回收时内存不足的时候即使回收ThreadLocal变量内存，从而不容易出现内存溢出异常。

好了，以上就是我对ThreadLocal类的个人理解。如有不足，欢迎留言补充。