ThreadLocal源码分析

ThreadLocal称为线程本地变量，可以让每个线程拥有一个属于自己的变量的副本，主要作用就是做数据隔离，在多线程环境下，每个线程可以拥有自己的变量数据，不被其他线程可见。

使用场景

Spring事务隔离级别

在Spring事务环节讲解

参数传递

在项目中经常会有一个线程调用多个方法的情况，方法间需要传递对象，比如用户信息、业务信息等。如果给每个方法都增加参数会比较麻烦，像第三方的库，对象参数就传递不过去了。我们可以使用ThreadLocal在调用前把参数set进来，其它需要的地方get下就可以了。例如一些cookie、session的数据隔离就是通过ThreadLocal来实现的。

美图

ThreadLocalMap中的Entry继承弱引用WeekReference，我们都知道弱引用的对象在GC时就会被回收，而Entry的key存放的是threadlocal，为弱引用，但是value为强引用，ThreadLocal在使用完后，没有强引用关联，当GC时ThreadLocal就会被回收，这时候对应的key就为null，但是value的值还是存在，就出现了key=null的value。如果线程一直存活，value就不会被回收，例如线程池中的线程。

当使用完ThreadLocal后，调用remove()方法就可以避免内存泄露的问题。

源码

ThreadLocal使用方法：

package com.doaredo.test;

import org.junit.Test;

public class ThreadLocalDemo {

    @Test
    public void test(){
        ThreadLocal<String> tl = new ThreadLocal<>();
        tl.set("xxxx");
        String name = tl.get();
        System.out.println(name);
        tl.remove();
    }
}

源码分析：

public void set(T value) {
    // 获取当前线程
    Thread t = Thread.currentThread();
    // 获取ThreadLocalMap
    ThreadLocalMap map = getMap(t);
    if (map != null)
      	map.set(this, value);
    else
      	createMap(t, value);
}

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

public class Thread implements Runnable {
    
    /* 每个线程都维护了自己的threadLocals变量，其它线程无法获取，从而实现隔离
     */
    ThreadLocal.ThreadLocalMap threadLocals = null;

    /*
     * InheritableThreadLocal values pertaining to this thread. This map is
     * maintained by the InheritableThreadLocal class.
     */
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
}

ThreadLocalMap并没有实现Map接口，并且Entry继承WeakReference弱引用。在set方法中，使用的是Entry数组，因为Thread可以使用多个ThreadLocal，所以需要数组来存储。

static class ThreadLocalMap {

    /**
         * The entries in this hash map extend WeakReference, using
         * its main ref field as the key (which is always a
         * ThreadLocal object).  Note that null keys (i.e. entry.get()
         * == null) mean that the key is no longer referenced, so the
         * entry can be expunged from table.  Such entries are referred to
         * as "stale entries" in the code that follows.
         */
    static class Entry extends WeakReference<ThreadLocal<?>> {
        /** The value associated with this ThreadLocal. */
        Object value;

        Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }
    
    private void set(ThreadLocal<?> key, Object value) {
        Entry[] tab = table;
        int len = tab.length;
        // 计算ThreadLocal对应数组的位置
        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;
            }
		   // 如果数组位置为空，初始化一个Entry对象放入该位置
            if (k == null) {
                replaceStaleEntry(key, value, i);
                return;
            }
        }

        tab[i] = new Entry(key, value);
        int sz = ++size;
        // 如果对应位置不为空，且不是要更新的key，就找下一个空位置，直到找到空位置
        if (!cleanSomeSlots(i, sz) && sz >= threshold)
            rehash();
    }
    
    /* get会根据ThreadLocal对象的hash值，定位到数组中的位置，然后判断
       该位置的Entry对象中的key是否和传入的key一致，如果不一致则判断下一个位置
       如果冲突严重的话，可想效率还是较低的
     */
    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);
    }

    private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
        Entry[] tab = table;
        int len = tab.length;
	   // 根据ThreadLocal获取到table的i值，然后对比key是否相等
        while (e != null) {
            ThreadLocal<?> k = e.get();
            // 相等就直接返回，不相待继续查找，直到找到相等的位置
            if (k == key)
                return e;
            if (k == null)
                expungeStaleEntry(i);
            else
                i = nextIndex(i, len);
            e = tab[i];
        }
        return null;
    }
}

共享ThreadLocal

Thread源码中除了threadLocals变量外，还有一个inheritableThreadLocals变量，通过inheritableThreadLocals就可以实现多个线程访问ThreadLocal的值。

private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc) {
    // ...代码略
    // 如果父线程的inheritThreadLocals不为空，就把父线程的inheritThreadLocals给当前线程
    // 这样一来就达到了ThreadLocal共享
    if (parent.inheritableThreadLocals != null)
        this.inheritableThreadLocals =
        ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
    /* Stash the specified stack size in case the VM cares */
    this.stackSize = stackSize;

    /* Set thread ID */
    tid = nextThreadID();
}