线程变量ThreadLocal的使用和分析

一、ThreadLocal的基本使用

// 创建一个ThreadLocal对象
final static ThreadLocal<String> mThreadLocal = new ThreadLocal<>();
    @Test
    public void myThread() {
        new Thread() {
            @Override
            public void run() {
                mThreadLocal.set("AAA");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (Exception e) {
                }
                System.out.println("===" + Thread.currentThread().getName() + "===" + mThreadLocal.get());
            }
        }.start();
        new Thread() {
            @Override
            public void run() {
                mThreadLocal.set("BBB");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (Exception e) {
                }
                System.out.println("===" + Thread.currentThread().getName() + "===" + mThreadLocal.get());
            }
        }.start();
}

// 结果是：
===Thread-0===AAA
===Thread-1===BBB

mThreadLocal是一个变量，线程一对其设置了AAA后，就休眠1秒。此时线程二把这个值改成了BBB，为什么线程一获取到的还是AAA，而线程二获取到的却是BBB？

二、源码分析

// ThreadLocal类的构造方法，平淡无奇
public ThreadLocal() {
}

// ThreadLocal类set方法
public void set(T value) {
        // 获取当前的线程对象
        Thread t = Thread.currentThread();
        // (1) 获取线程对象里的ThreadLocalMap对象
        ThreadLocalMap map = getMap(t);
        if (map != null)
            // 如果不是空，就把值设置到这个Map里，其中key就是当前的ThreadLocal对象
            map.set(this, value);
        else
            // (4)如果这个Map是空的，就去创建这个Map
            createMap(t, value);
}

// (1)的getMap方法，返回的是线程对象里的threadLocals
// 点进去知道，threadLocals就是Thread类的成员变量，类型是ThreadLocalMap
// 那么ThreadLocalMap又是什么(2)？
ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
}

// (2)，ThreadLocalMap是ThreadLocal类的静态内部类
// 用于存放键值对，其中key是ThreadLocal类型，value是任何类型
// 可以简单理解，把这里想象成HashMap，也是涉及到hash冲突、扩容等问题
static class ThreadLocalMap {
        // Entry继承自WeakReference（弱引用，生命周期只能存活到下次GC前），
        // 但只有Key是弱引用类型的，Value并非弱引用。
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;
            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
}

// (4) 创建一个ThreadLocalMap，并复制给当前线程对象的threadLocals变量
void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
 }

// TheradLocal的get方法
public T get() {
        // 获取当前线程对象
        Thread t = Thread.currentThread();
        // 获取当前线程对象的成员变量ThreadLocalMap
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            // 根据key=this，获取ThreadLocalMap的value
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
}

至此，我们可以知道ThreadLocal是什么了？
从名字我们就可以看到ThreadLocal叫做线程变量，意思是ThreadLocal中填充的变量属于当前线程，该变量对其他线程而言是隔离的。ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。
结构如下图：

三、ThreadLocalMap，hash冲突

和HashMap的最大的不同在于，ThreadLocalMap结构非常简单，没有next引用，也就是说ThreadLocalMap中解决Hash冲突的方式并非链表的方式，而是采用线性探测的方式，所谓线性探测，就是根据初始key的hashcode值确定元素在table数组中的位置，如果发现这个位置上已经有其他key值的元素被占用，则利用固定的算法寻找一定步长的下个位置，依次判断，直至找到能够存放的位置。

/**
 * Increment i modulo len.
 */
private static int nextIndex(int i, int len) {
    return ((i + 1 < len) ? i + 1 : 0);
}

/**
 * Decrement i modulo len.
 */
private static int prevIndex(int i, int len) {
    return ((i - 1 >= 0) ? i - 1 : len - 1);
}

可以看出，ThreadLocalMap解决Hash冲突的方式就是简单的步长加1或减1，寻找下一个相邻的位置。显然ThreadLocalMap采用线性探测的方式解决Hash冲突的效率很低，如果有大量不同的ThreadLocal对象放入map中时发送冲突，或者发生二次冲突，则效率很低。

四、ThreadLocalMap引起的内存泄漏

由于ThreadLocalMap的key是弱引用，而Value是强引用。这就导致了一个问题，ThreadLocal在没有外部对象强引用时，发生GC时弱引用Key会被回收，而Value不会回收，如果创建ThreadLocal的线程一直持续运行，那么这个Entry对象中的value就有可能一直得不到回收，发生内存泄露。那么如何避免泄漏？
既然Key是弱引用，那么我们要做的事，就是在调用ThreadLocal的get()、set()方法时完成后再调用remove方法，将Entry节点和Map的引用关系移除，这样整个Entry对象在GC Roots分析后就变成不可达了，下次GC的时候就可以被回收。

五、应用场景

1、Android源码，Looper对象的保存就是基于线程的ThreadLocalMap来存储的。
2、在Java的多线程编程中，为保证多个线程对共享变量的安全访问，通常会使用synchronized来保证同一时刻只有一个线程对共享变量进行操作。这种情况下可以将[类变量]放到ThreadLocal类型的对象中，使变量在每个线程中都有独立拷贝，不会出现一个线程读取变量时而被另一个线程修改的现象。最常见的ThreadLocal使用场景为用来解决数据库连接、Session管理等。