JUC探险-16、ThreadLocal

一、：ThreadLocal简介

  首先说明一个情况，ThreadLocal不是JUC包中的类，它在java.lang包中。之所以在此处提出，是因为它与JUC中的核心功能相似，二者都可以解决线程安全问题。但是二者解决的方式、思想或者说场景又是不一样的。
  线程安全问题的核心在于多个线程会对同一个共享资源进行操作。在JUC的线程同步机制中，利用加锁、阻塞等手段，强制在同一时间点只能有一个线程操作资源，并保证了可见性，因此保障了线程安全。而ThreadLocal则是另辟蹊径，在各个线程中保存自己的“共享资源”，自己操作自己的资源没有别人插手，当然也就没有了线程安全问题。这也是一种“空间换时间”的思想：如果每个线程都有自己的“共享资源”，无疑内存会占用更多，但是由于不需要同步，也就减少了线程可能存在的阻塞等待的情况从而提高的时间效率。

---

二、：ThreadLocal的实现原理

  ①ThreadLocal的核心方法

public class ThreadLocal<T> {
	// 返回此线程局部变量的当前线程的“初始值”
	protected T initialValue() {
	}

	// 返回此线程局部变量的当前线程副本中的值
	public T get() {
	}

	// 将此线程局部变量的当前线程副本中的值设置为指定值
	public void set(T value) {
	}

	// 移除此线程局部变量当前线程的值
	public void remove() {
	}
}

    大体上观察，get()、set()、remove()都是基于ThreadLocalMap操作的，可见ThreadLocalMap是实现线程隔离机制的关键。

  ②ThreadLocal的内部类

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

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

	private Entry[] table;
    ......
}

    ThreadLocalMap提供了一种用键值对方式存储每一个线程的变量副本的方法，key为当前ThreadLocal对象，value则是对应线程的变量副本。同时，Entry也继承WeakReference，所以说Entry所对应key（ThreadLocal实例）的引用为一个弱引用。

  ③ThreadLocal核心方法的实现

    1、initialValue()方法

protected T initialValue() {
    return null;
}

      这个方法很简单，但应该注意它是用protected修饰的，也就是说继承ThreadLocal的子类可重写该方法，实现赋值为其他的初始值。

    2、get()方法

public T get() {
	// 获取当前线程实例对象
    Thread t = Thread.currentThread();
    // 通过当前线程实例获取ThreadLocalMap对象
    ThreadLocalMap map = getMap(t);
    if (map != null) {
    	// 获取map中以当前ThreadLocal实例为key的entry
        ThreadLocalMap.Entry e = map.getEntry(this);
        // 如果当前entry不为null的话，就返回相应的value
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    // 如果map为null或者entry为null的话，调用初始化方法并返回该方法返回的value
    return setInitialValue();
}

ThreadLocalMap getMap(Thread t) {
	// 这里可以看出，ThreadLocalMap的引用是作为Thread的一个成员变量，被Thread维护的
    return t.threadLocals;
}

private Entry getEntry(ThreadLocal<?> key) {
	// 由于采用了开放定址法，所以当前key的哈希值和元素在数组的索引并不是完全对应的
	// 取一个探测数i（key的哈希值）
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
	// 如果所对应的key就是我们所要找的元素，则返回
    if (e != null && e.get() == key)
        return e;
    // 如果不匹配，调用getEntryAfterMiss()方法
    else
        return getEntryAfterMiss(key, i, e);
}

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    Entry[] tab = table;
    int len = tab.length;

    while (e != null) {
        ThreadLocal<?> k = e.get();
        if (k == key)
            return e;
        if (k == null)
        	// 此方法用于帮助GC回收，避免内存泄漏
            expungeStaleEntry(i);
        else
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null;
}

private T setInitialValue() {
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}

void createMap(Thread t, T firstValue) {
	// 将当前线程的threadLocals赋值为一个以当前ThreadLocal实例为key
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

      方法的主要执行流程是：
        ●通过当前线程实例获取ThreadLocalMap对象。
        ●以当前ThreadLocal实例为key获取该map中的键值对（Entry）。
        ●如果Entry不为null，则返回Entry的value。
        ●如果map为null或者Entry为null，就调用初始化方法并返回该方法返回的value。

      ⅰ、ThreadLocalMap中的set()

private void set(ThreadLocal<?> key, Object value) {
    Entry[] tab = table;
    int len = tab.length;
    // 取一个探测数i（key的哈希值）
    int i = key.threadLocalHashCode & (len-1);

	// 采用“线性探测法”，寻找合适位置
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get();

		// 如果key存在，直接覆盖value
        if (k == key) {
            e.value = value;
            return;
        }

		// key == null 且 e != null（之前的ThreadLocal对象已经被回收了）
        if (k == null) {
        	// 用新元素替换旧元素
            replaceStaleEntry(key, value, i);
            return;
        }
    }

	// ThreadLocal对应的key实例不存在也没有旧元素，直接new一个Entry
    tab[i] = new Entry(key, value);
    int sz = ++size;
    // 如果清理旧Entry失败 且 数组中的元素大于了阈值，则调用rehash()方法
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

        虽然都是键值对的数据结构，但是在存入数据的时候，ThreadLocalMap的操作和Map中的不太一样，区别主要在于解决哈希冲突的方式不同。Map采用的是拉链法，而ThreadLocalMap则采用的是开放定址法。
        set()操作除了存储元素外，还有一个很重要的作用，就是replaceStaleEntry()和cleanSomeSlots()这两个方法可以清除掉key == null 的实例，防止内存泄漏。

    3、set()方法

public void set(T value) {
	// 获取当前线程实例对象
    Thread t = Thread.currentThread();
    // 通过当前线程实例获取ThreadLocalMap对象
    ThreadLocalMap map = getMap(t);
    // 如果map不为null，则以当前ThreadLocal实例为key，传入value为value进行存入
    if (map != null)
        map.set(this, value);
    // 如果map为null，则新建ThreadLocalMap并存入value
    else
        createMap(t, value);
}

      方法的主要执行流程是：
        ●通过当前线程实例获取ThreadLocalMap对象。
        ●如果map不为null，则以当前ThreadLocal实例为key，传入value为value进行存入。
        ●如果map为null，则以当前ThreadLocal实例为key，新建ThreadLocalMap并存入value。

    4、remove()方法

public void remove() {
	// 通过当前线程实例获取ThreadLocalMap对象
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
    	// 从map中删除以当前ThreadLocal实例为key的键值对
        m.remove(this);
}

private void remove(ThreadLocal<?> key) {
    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        if (e.get() == key) {
        	// 将Entry的key置为null
            e.clear();
            // 将Entry的value置为null
            expungeStaleEntry(i);
            return;
        }
    }
}

      方法的主要执行流程是：
        ●通过当前线程实例获取ThreadLocalMap对象。
        ●从map中删除以当前ThreadLocal实例为key的键值对。

---

三、：ThreadLocalMap进一步说明

  ①Entry

    从上文ThreadLocal的内部类部分可以看到，ThreadLocalMap内部维护了一个Entry类型的table数组。
    Thread，ThreadLocal，ThreadLocalMap，Entry几方关系如下图所示：（实线表示强引用，虚线表示弱引用）

    如图所示，线程实例可以通过内部变量获取到自己的ThreadLocalMap，而ThreadLocalMap是一个以ThreadLocal实例为key，任意对象为value的Entry数组。当我们为ThreadLocal变量赋值，实际上就是把Entry往这个ThreadLocalMap中存放。

    需要注意的是：Entry中的key是弱引用。当ThreadLocal外部强引用被置为null时，那么GC的时候，这个ThreadLocal会被回收。这样一来，ThreadLocalMap中就会出现key为null的Entry，也没有办法访问这些key为null的Entry的value。如果再加上当前Thread迟迟不结束的话，这些key为null的Entry的value就会一直存在一条强引用链：当前Thread Ref -> 当前Thread -> ThreadLocalMap -> Entry -> value永远无法回收，造成内存泄漏。
    当然，如果当前Thread运行结束，ThreadLocal、ThreadLocalMap、Entry没有引用链可达，在垃圾回收的时候都会被系统进行回收。但在实际开发中，会使用线程池去维护线程的创建和销毁，比如固定大小的线程池，线程为了实现复用是不会主动结束的，所以，这里的内存泄漏问题还是值得我们思考和注意的问题。

  ②哈希冲突解决方法

    上文在分析ThreadLocalMap的set()方法时，提到了和Map中方法的不同。下面就这个问题进行进一步详细分析。

    理想状态下，哈希表就是一个包含关键字的固定大小的数组，通过使用哈希函数，将关键字映射到数组的不同位置。理想状态下，哈希函数可以将关键字均匀的分散到数组的不同位置，不会出现两个关键字哈希值相同（假设关键字数量小于数组的大小）的情况。但在实际使用中，经常会出现多个关键字哈希值相同的情况（被映射到数组的同一个位置），我们将这种情况称为哈希冲突。为了解决哈希冲突，主要有两种方式： 分离链表法（separate chaining）和开放定址法（open addressing）：
      ●分离链表法使用链表解决冲突，将散列值相同的元素都保存到一个链表中。当查询的时候，首先找到元素所在的链表，然后遍历链表查找对应的元素。典型示例就是我们熟悉的HashMap和ConcurrentHashMap中的拉链法。
      ●开放定址法不会创建链表，当关键字散列到的数组单元已经被另外一个关键字占用的时候，就会尝试在数组中寻找其他单元，直到找到一个空的单元。探测数组空单元的方式有很多，这里介绍ThreadLocalMap中的简单实现——线性探测法。线性探测法就是从冲突的数组单元开始，依次往后搜索空单元，如果到数组尾部，再从头开始搜索（环形查找）。

---

四、：ThreadLocal的内存泄漏问题

  关于内存泄漏的原因，在上面已经介绍了，配合图应该不难理解。

  ①jdk为防止内存泄漏的改进

    1、cleanSomeSlots()方法

// 入参依次是：插入Entry的位置、扫描次数控制参数
private boolean cleanSomeSlots(int i, int n) {
    boolean removed = false;
    Entry[] tab = table;
    int len = tab.length;
    do {
        i = nextIndex(i, len);
        Entry e = tab[i];
        if (e != null && e.get() == null) {
            n = len;
            removed = true;
            i = expungeStaleEntry(i);
        }
    } while ( (n >>>= 1) != 0);
    return removed;
}

      方法的主要执行流程是：
        ●从当前位置i处为起点在初始小范围（log2(n)，n为哈希表已插入Entry的个数size）开始向后搜索脏Entry。若在整个搜索过程没有脏Entry，方法结束退出。
        ●如果在搜索过程中遇到脏Entry，通过expungeStaleEntry()方法清理掉当前脏Entry，并且该方法会返回下一个哈希表为null的索引位置i。这时重新令搜索起点为索引位置i，n为哈希表的长度len，再次扩大搜索范围为log2(n)继续搜索。

    2、expungeStaleEntry()方法

private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;

    // expunge entry at staleSlot
    // 清除当前脏Entry
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    size--;

    // Rehash until we encounter null
    Entry e;
    int i;
    // 往后环形查找，直到table[i]==null结束
    for (i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();
        // 如果在向后搜索过程中再次遇到脏Entry，同样将其清理掉
        if (k == null) {
            e.value = null;
            tab[i] = null;
            size--;
        } else {
        	// 处理rehash的情况
            int h = k.threadLocalHashCode & (len - 1);
            if (h != i) {
                tab[i] = null;

                // Unlike Knuth 6.4 Algorithm R, we must scan until
                // null because multiple entries could have been stale.
                while (tab[h] != null)
                    h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    return i;
}

      方法的主要执行流程是：
        ●清理当前脏Entry，即将其value引用置为null，并且将table[staleSlot]也置为null。value置为null后，该value域变为不可达，在下一次GC的时候就会被回收掉，同时table[staleSlot]为null，以便于存放新的Entry。
        ●从当前staleSlot位置向后环形（nextIndex）继续搜索，直到遇到哈希表为null的时候退出。
        ●若在搜索过程再次遇到脏Entry，继续将其清除。

    3、replaceStaleEntry()方法

private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                               int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    Entry e;

    // 向前找到第一个脏Entry
    int slotToExpunge = staleSlot;
    for (int i = prevIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = prevIndex(i, len))
        if (e.get() == null)
            slotToExpunge = i;

    // Find either the key or trailing null slot of run, whichever
    // occurs first
    for (int i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();

        // 如果在向后环形查找过程中发现key相同的Entry就覆盖并且和脏Entry进行交换
        if (k == key) {
            e.value = value;

            tab[i] = tab[staleSlot];
            tab[staleSlot] = e;

            // Start expunge at preceding stale entry if it exists
            // 如果在查找过程中还未发现脏Entry，那么就以当前位置作为cleanSomeSlots的起点
            if (slotToExpunge == staleSlot)
                slotToExpunge = i;
            // 搜索脏entry并进行清理
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            return;
        }

        // 如果向前未搜索到脏Entry，则在查找过程遇到脏Entry的话，后面就以此时这个位置作为起点执行cleanSomeSlots
        if (k == null && slotToExpunge == staleSlot)
            slotToExpunge = i;
    }

    // If key not found, put new entry in stale slot
    // 如果在查找过程中没有找到可以覆盖的Entry，则将新的Entry插入在脏Entry处
    tab[staleSlot].value = null;
    tab[staleSlot] = new Entry(key, value);

    // If there are any other stale entries in run, expunge them
    // 如果还有其他脏Entry存在，则清除他们
    if (slotToExpunge != staleSlot)
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}

      方法的主要执行流程是：
        ●尝试查找和传入key对应的Entry，找到则替换，没找到则在传入的staleSlot处插入一个新的Entry。
        ●在上面的过程中，尽力地去擦除一些找到的staleSlot。
        ●插入一个新的Entry之后，试探性地去删除多余的staleSlot。

    从上面的方法及方法的调用可以看出，在ThreadLocal的生命周期里，针对内存泄漏问题，都会通过cleanSomeSlots()、expungeStaleEntry()、replaceStaleEntry()这三个方法清理掉key为null的脏Entry。

  ②为什么使用弱引用

    上面提到内存泄漏的原因也有弱引用的因素，那么这里为什么要使用弱引用呢？
    要回答这个问题，我们不妨先假设这里使用强引用。在清理ThreadLocal实例的时候，在业务代码中执行threadLocalInstance==null操作。但是因为ThreadLocalMap的Entry强引用ThreadLocal，因此在GC的时候并不会对ThreadLocal进行垃圾回收，这样就无法达到业务目的，发生逻辑错误。
    这里Entry弱引用ThreadLocal，尽管可能出现内存泄漏的问题，但是在上面的改进中、在ThreadLocal的生命周期里，很多时候都会针对key为null的脏Entry进行处理。

  ③使用最佳实践

    每次使用完ThreadLocal，都调用它的remove()方法，清除数据。特别是在使用线程池的情况下，没有及时清理ThreadLocal，不仅是内存泄漏的问题，更严重的是可能导致业务逻辑出现问题。所以，使用ThreadLocal就跟加锁完要解锁一样，用完就清理。

---

五、：总结

  对于ThreadLocal需要注意以下几点：
    ●ThreadLocal不是用于解决共享变量的问题的，也不是为了协调线程同步而存在的，而是为了方便每个线程处理自己的状态而引入的一个机制。这样的思路与不同之处非常重要。
    ●每个Thread内部都有一个ThreadLocal.ThreadLocalMap类型的成员变量，该成员变量用来存储实际的ThreadLocal变量副本。
    ●ThreadLocal并不是为线程保存对象的副本，它仅仅只起到一个索引的作用。它的主要目的是为每一个线程隔离一个类的实例，这个实例的作用范围仅限于线程内部。

  ThreadLocal的使用场景

    ThreadLocal不保存数据，数据实质上是放在每个Thread实例引用的ThreadLocal.ThreadLocalMap中。也就是说不同的线程都拥有专属于自己的数据容器，彼此互不影响。因此ThreadLocal只适用于共享对象会造成线程安全的业务场景。
    比如hibernate中通过ThreadLocal管理Session就是一个典型的案例，不同的请求线程（用户）拥有自己的session，若将session共享出去被多线程访问，必然会带来线程安全问题。

系列文章传送门：

JUC探险-1、初识概貌
JUC探险-2、synchronized
JUC探险-3、volatile
JUC探险-4、final
JUC探险-5、原子类
JUC探险-6、Lock & AQS
JUC探险-7、ReentrantLock
JUC探险-8、ReentrantReadWriteLock
JUC探险-9、Condition
JUC探险-10、常见工具、数据结构
JUC探险-11、ConcurrentHashMap
JUC探险-12、CopyOnWriteArrayList
JUC探险-13、ConcurrentLinkedQueue
JUC探险-14、ConcurrentSkipListMap
JUC探险-15、BlockingQueue
JUC探险-16、ThreadLocal
JUC探险-17、线程池