源码系列 之 ThreadLocal

简介

   ThreadLocal的作用是做数据隔离，存储的变量只属于当前线程，相当于当前线程的局部变量，多线程环境下，不会被别的线程访问与修改。常用于存储线程私有成员变量、上下文，和用于同一线程，不同层级方法间传参等。JDK 1.8 中的 ThreadLocal 共741行代码，其中包含3个成员变量，13个成员方法和两个内部类。 我们先来看下核心原理，再来详细看下源码。

问题

我们可以带着问题去学习这部分内容，希望学习完后，能回答这些问题：

1. ThreadLocal能不能代替Synchronized？和Synchronized的区别是什么？
2. Thread、ThreadLocal、ThreadLocalMap的关系是怎么样的？
3. 存储在jvm的堆还是栈中？
4. ThreadLocal会导致内存泄漏吗，为什么？
5. ThreadLocalMap为什么用Entry数组而不是Entry对象？
6. ThreadLocal里的对象一定是线程安全的吗？
7. ThreadLocalMap只用单纯的数组存值吗？如果出现哈希冲突怎么存值？

核心原理

   这个要从java.lang.Thread类说起，每个Thread对象中都拥有一个ThreadLocalMap（ThreadLocal的内部类）的成员变量。ThreadLocalMap内部又拥有一个Entry数组，每个Entry是一个键值对，key是ThreadLocal本身，value是ThreadLocal的泛型值。 （这里Thread类虽然有ThreadLocalMap成员变量，但没有get()，set()，remove()等增删改查的方法，其实就是通过ThreadLocal来操作的。）
   例如我们每一次请求，就是一个线程，然后一个线程里就有且只有一个ThreadLocalMap，然后我们的业务里可能new了好几个ThreadLocal对象，存了几个ThreadLocal的值，这些就存在Entry数组中，然后，我们根据当前线程和当前ThreadLocal就能找到唯一的value值。再简单点讲：每个线程里都有一个成员变量，本质是一个数组，里面存的就是你想线程私有化的几个对象。
结构图如下：

核心源码如下：

// java.lang.Thread类里持有ThreadLocalMap的引用
public class Thread implements Runnable {
	... ...
    ThreadLocal.ThreadLocalMap threadLocals = null;
    ... ...
}

// java.lang.ThreadLocal有内部静态类ThreadLocalMap，主要提供给Thread类使用
public class ThreadLocal {
	
	... ...
	
    static class ThreadLocalMap {
    	// 存线程私有变量
        private Entry[] table;
        
        // ThreadLocalMap内部有Entry类，Entry的key是ThreadLocal本身，value是泛型值
        static class Entry extends WeakReference> {
            Object value;
            Entry(ThreadLocal k, Object v) {
                super(k);
                value = v;
            }
        }
    }

	... ...
}

ThreadLocal的成员变量

  这里介绍一下ThreadLocal的成员变量。

• private final int threadLocalHashCode = nextHashCode()
  自定义的哈希值，主要是调用nextHashCode()方法获取。
• private static AtomicInteger nextHashCode = new AtomicInteger()
  下一个要给出的哈希码。自动更新。从0开始。
• private static final int HASH_INCREMENT = 0x61c88647;
  连续生成的哈希码之间的差异，此为一个魔数。

ThreadLocal的成员方法

  这里介绍一下ThreadLocal的成员方法。

• public ThreadLocal()
  构造器。

	public ThreadLocal() {
    }

• private static int nextHashCode()
  返回下一个哈希码。

	private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

• protected T initialValue()
  用以初始化值，这个方法将在线程第一次使用get方法访问变量时被调用，如果调用get()前使用了set()设置值，则不会被调用，这里只是简单的初始化成了null，如果需要初始化成其它值，则必须将ThreadLocal子类化，并重写此方法。

// 由子类提供实现。
// protected
protected T initialValue() {
   return null;
}

• public static ThreadLocal withInitial(Supplier supplier)
  可根据提供的函数，生成初始值。

public static  ThreadLocal withInitial(Supplier supplier) {
        return new SuppliedThreadLocal<>(supplier);
    }

• public T get()
  返回该当前线程对应的线程局部变量值。

public T get() {
    // 获取当前线程，这里的currentThread()是个native方法
    Thread t = Thread.currentThread();
    // 获取当前线程对应的ThreadLocalMap对象
    ThreadLocalMap map = getMap(t);
    // 若获取到了。则获取此ThreadLocalMap下的entry对象，若entry也获取到了，那么直接获取entry对应的value返回即可
    if (map != null) {
        // 获取此ThreadLocalMap下的entry对象，把当前ThreadLocal当参数传进去
        ThreadLocalMap.Entry e = map.getEntry(this);
        // 若entry也获取到了
        if (e != null) {
            @SuppressWarnings("unchecked")
            // 直接获取entry对应的value返回
            T result = (T)e.value;
            return result;
        }
    }
    // 若没获取到ThreadLocalMap或没获取到Entry，则设置初始值
    //  初始值方法是延迟加载
    return setInitialValue();
}

• boolean isPresent()
  如果当前线程中ThreadLocalMap不为空，且该局部变量也不为空，则返回true，否则返回false。

	boolean isPresent() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        return map != null && map.getEntry(this) != null;
    }

• private T setInitialValue()
  设置初始值，调用initialValue。

// 设置初始值
private T setInitialValue() {
    // 调用初始值方法，由子类提供。
    T value = initialValue();
    // 获取当前线程
    Thread t = Thread.currentThread();
    // 获取map
    ThreadLocalMap map = getMap(t);
    // 获取到了
    if (map != null)
        // set
        map.set(this, value);
    else
        // 没获取到。创建map并赋值
        createMap(t, value);
    // 返回初始值。
    return value;
}

• public void set(T value)
  设置当前线程的线程局部变量的值。

public void set(T value) {
    // 获取当前线程
    Thread t = Thread.currentThread();
    // 获取当前线程对应的ThreadLocalMap实例
    ThreadLocalMap map = getMap(t);
    // 若当前线程有对应的ThreadLocalMap实例，则将当前ThreadLocal对象作为key，value做为值存到ThreadLocalMap的entry里。
    if (map != null)
        map.set(this, value);
    else
        // 若当前线程没有对应的ThreadLocalMap实例，则创建ThreadLocalMap，并将此线程与之绑定
        createMap(t, value);
}

• public void remove()
  删除当前线程局部变量的值，目的是为了减少内存占用，和防止内存泄漏。

public void remove() {
    // 获取当前线程的ThreadLocalMap对象，并将其移除。
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        m.remove(this);
}

• ThreadLocalMap getMap(Thread t)
  获取ThreadLocalMap，在你调用ThreadLocal.get()方法的时候就会调用这个方法，它的返回是当前线程里的threadLocals的引用。

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

• void createMap(Thread t, T firstValue)
  创建ThreadLocalMap，ThreadLocal底层其实就是一个map来维护的。

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

// ThreadLocalMap构造器。
ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
    table = new Entry[INITIAL_CAPACITY];
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    // new了一个ThreadLocalMap的内部类Entry，且将key和value传入。
    // key是ThreadLocal对象。
    table[i] = new Entry(firstKey, firstValue);
    size = 1;
    setThreshold(INITIAL_CAPACITY);
}

• static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap)
  用工厂方法创建继承的线程局部变量的映射。

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

• T childValue(T parentValue)
  childValue()是用来在ThreadLocal子类中定义实现的，在这里定义，主要是提供给createInheritedMap工厂方法调用。

T childValue(T parentValue) {
        throw new UnsupportedOperationException();
    }

ThreadLocal的内部类

  这里介绍一下ThreadLocal的内部类。

• static final class SuppliedThreadLocal extends ThreadLocal {}
  ThreadLocal的扩展，从指定的提供者获取初始值。

static final class SuppliedThreadLocal extends ThreadLocal {

        private final Supplier supplier;
        
        SuppliedThreadLocal(Supplier supplier) {
            this.supplier = Objects.requireNonNull(supplier);
        }

        @Override
        protected T initialValue() {
            return supplier.get();
        }
    }

• static class ThreadLocalMap {}
  ThreadLocalMap是一个定制的散列映射，只适合维护线程本地值。ThreadLocalMap用类似HashMap的方式，存储ThreadLocal和他对应泛型的值，只不过这里只单纯的用了数组没有用到链表。没有用链表，怎么解决哈希冲突问题呢？其实很简单，依次向下一个索引查找，把值存在下一个为null的位置。

	static class ThreadLocalMap {

        /**
         * ThreadLocalMap 里数组里具体存的值
         */
        static class Entry extends WeakReference> {
            /**
            * 与当前ThreadLocal 对应的值
            */
            Object value;

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

        /**
         * 初始容量必须是2的幂次数，当前默认为16
         */
        private static final int INITIAL_CAPACITY = 16;

        /**
         * ThreadLocalMap 里的Entry[] 数组，长度必须为2的幂次数
         */
        private Entry[] table;

        /**
         * 当前 Entry[] table 的长度
         */
        private int size = 0;

        /**
         * 阈值，超过后需扩容
         */
        private int threshold; // Default to 0

        /**
         * 设置阈值为长度的 三分之二
         */
        private void setThreshold(int len) {
            threshold = len * 2 / 3;
        }

        /**
         * I对len取模
         */
        private static int nextIndex(int i, int len) {
            return ((i + 1 < len) ? i + 1 : 0);
        }

        /**
         * 获取前一个索引值
         */
        private static int prevIndex(int i, int len) {
            return ((i - 1 >= 0) ? i - 1 : len - 1);
        }

        /**
         * 构造方法，懒加载的
         */
        ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
        	// 根据初始容量，初始化表
            table = new Entry[INITIAL_CAPACITY];
            // 获取当前哈希值后，对len进行取模，确定索引位置
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            // 初始化长度，和阈值
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }

        /**
         * 从给定父映射创建新映射         
         * */
        private ThreadLocalMap(ThreadLocalMap parentMap) {
        	// 初始化参数
            Entry[] parentTable = parentMap.table;
            int len = parentTable.length;
            setThreshold(len);
            table = new Entry[len];

            for (Entry e : parentTable) {
                if (e != null) {
                    @SuppressWarnings("unchecked")
                    ThreadLocal