ThreadLocal

1、ThreadLocal是什么？

多线程访问同一个共享变量的时候容易出现并发问题，特别是多个线程对一个变量进行写入的时候，为了保证线程安全，一般使用者在访问共享变量的时候需要进行额外的同步措施才能保证线程安全性。ThreadLocal是除了加锁这种同步方式之外的一种保证一种规避多线程访问出现线程不安全的方法，当我们在创建一个变量后，如果每个线程对其进行访问的时候访问的都是线程自己的变量这样就不会存在线程不安全问题。

　　ThreadLocal是JDK包提供的，它提供线程本地变量，如果创建一乐ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的一个副本，在实际多线程操作的时候，操作的是自己本地内存中的变量，从而规避了线程安全问题，如下图所示

ThreadLocal 直译就是「线程本地变量」，意思是 ThreadLocal 中填充的变量属于「当前」线程，该变量对其他线程而言是隔离的。ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。ThreadLocal 的作用是提供线程内的局部变量，这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或者组件之间一些公共变量的传递的复杂度。但是如果滥用 ThreadLocal，就可能会导致内存泄漏。在 Android 的消息机制中，很重要的一个角色 Looper，其中每个线程都要有自己的 Looper，这就是通过 ThreadLocal 实现的。直接看代码：

public final class Looper {
    // sThreadLocal.get() will return null unless you've called prepare().
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
  
    private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        // Setter
        sThreadLocal.set(new Looper(quitAllowed));
    }
  
    /**
     * Return the Looper object associated with the current thread.  Returns
     * null if the calling thread is not associated with a Looper.
     */  
    public static @Nullable Looper myLooper() {
        // Getter 返回当前线程的 Looper
        return sThreadLocal.get();
    }
}

总结：

1、在进行对象跨层传递的时候，使用ThreadLocal可以避免多次传递，打破层次间的约束。

2、线程间数据隔离。

3、进行事务操作，用于存储线程事务信息。

4、数据库连接，Session会话管理。

2、ThreadLocal怎么用？

package test;

public class ThreadLocalTest {

    static ThreadLocal<String> localVar = new ThreadLocal<>();

    static void print(String str) {
        //打印当前线程中本地内存中本地变量的值
        System.out.println(str + " :" + localVar.get());
        //清除本地内存中的本地变量
        localVar.remove();
    }

    public static void main(String[] args) {
        Thread t1  = new Thread(new Runnable() {
            @Override
            public void run() {
                //设置线程1中本地变量的值
                localVar.set("localVar1");
                //调用打印方法
                print("thread1");
                //打印本地变量
                System.out.println("after remove : " + localVar.get());
            }
        });

        Thread t2  = new Thread(new Runnable() {
            @Override
            public void run() {
                //设置线程1中本地变量的值
                localVar.set("localVar2");
                //调用打印方法
                print("thread2");
                //打印本地变量
                System.out.println("after remove : " + localVar.get());
            }
        });

        t1.start();
        t2.start();
    }
}

输出结果：

3、ThreadLocal源码

Setter部分：

public class ThreadLocal<T> {
    /**
     * Sets the current thread's copy of this thread-local variable
     * to the specified value. 
     *
     * @param value the value to be stored in the current thread's copy of
     *        this thread-local.
     */
    public void set(T value) {
        Thread t = Thread.currentThread(); 
        // 获取当前线程关联的 ThreadLocalMap
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
          // 取到的 Map 为空就去创建，同时把这个值作为第一个值存储到 map
            createMap(t, value);
    }
  
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    } 
}

static class ThreadLocalMap {
    // 用来关联 ThreadLocal 和 其对应的 value
    static class Entry extends WeakReference<ThreadLocal<?>> {
       /** The value associated with this ThreadLocal. */
       Object value;

       Entry(ThreadLocal<?> k, Object v) {
           // 注意这里的 key 就是 ThreadLocal<?> k，实际上 Entry 对它仅持有一个弱引用
           super(k); 
           value = v;
       }
    }
    
    private Entry[] table;
    
    private void set(ThreadLocal<?> key, Object value) {

        Entry[] tab = table;
        int len = tab.length;
        // 通过 TheadLocal 的 hash 值去确定 Entry 该存放的位置
        int i = key.threadLocalHashCode & (len-1);

        for (Entry e = tab[i];//目标位置
             e != null; // 循环至目标位置为空
             e = tab[i = nextIndex(i, len)]) { // 目标位置不可用继续找下一个位置，到结尾则 index 跳到 0
            ThreadLocal<?> k = e.get();

            if (k == key) { //同一个 key，直接替换值即可
                e.value = value;
                return;
            }

            if (k == null) { 
               // key 已经过时被回收了，替换这个 Entry，并且该方法也会去检查和清除其它过期的 Entry
                replaceStaleEntry(key, value, i);
                return;
            }
        }

        tab[i] = new Entry(key, value);
        int sz = ++size;
        if (!cleanSomeSlots(i, sz) && sz >= threshold)
            rehash(); // 整理 + 扩容
    }    
}

我们可以看到，这个 ThreadLocalMap 比 HashMap 的实现简单得多，只是简单的通过一个数组来保存 keyValue 的组合 entry，并且在 hash 值计算得出来的 Index 已经有数据时也仅需要简单的找下一个位置即可。另外这个 Hash 值的计算也是非常的简单：

public class ThreadLocal<T> {
    // 每次 new 一个 ThreadLocal ，它的 hash 值都会递增
    private final int threadLocalHashCode = nextHashCode();
    private static AtomicInteger nextHashCode = new AtomicInteger();
    // hash 值累加的常量
    private static final int HASH_INCREMENT = 0x61c88647; 
    /**
     * Returns the next hash code.
     * 这个 hash 值和它本身没多少关系，仅和它是第几个被初始化的有关系。感觉挺有意思的
     */
    private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }    
}

小结一下:

• 每个 Thread 都有一个 ThreadLocalMap 里面存放了这个 Thread 的所有 ThreadLocal

• 这个 map 会在 ThreadLocal 设置值的时候去懒加载，再将 ThreadLocal 作为 key 要存的值作为 value 一起放入 map

• 通过 ThreadLocal 的 hash 值去确定需要 value 放在 Map 的哪个位置

Getter部分：

public class ThreadLocal<T> {

public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            // 从 map 取 entry，前面看完了 set 方法，这边不用看源码也知道
            // 通过 ThreadLocal 的 hash 值计算 index, index 取到的 key 值与 当前 ThreadLocal 一致则为目标值返回；否则取下一个 index，直到取到的 entry 为空则直接返回空。
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        // 还未设置过值的时候默认初始化方法的值
        return setInitialValue();
    }

    private T setInitialValue() {
        T value = initialValue();
        ... // 省略 map 为空时初始化方法
        map.set(this, value);
        ....
        return value;
    }
    
    // 默认值为空
    protected T initialValue() {
        return null;
    }
}

4.内存泄漏：

ThreadLocalMap使用ThreadLocal的弱引用作为key，如果一个ThreadLocal没有外部强引用来引用它，那么系统 GC 的时候，这个ThreadLocal势必会被回收，这样一来，ThreadLocalMap中就会出现key为null的Entry，就没有办法访问这些key为null的Entry的value，如果当前线程再迟迟不结束的话，这些key为null的Entry的value就会一直存在一条强引用链：Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value永远无法回收，造成内存泄漏。

其实，ThreadLocalMap的设计中已经考虑到这种情况，也加上了一些防护措施：在ThreadLocal的get(),set(),remove()的时候都会清除线程ThreadLocalMap里所有key为null的value。

但是这些被动的预防措施并不能保证不会内存泄漏：

1. 使用static的ThreadLocal，延长了ThreadLocal的生命周期，可能导致的内存泄漏（参考ThreadLocal 内存泄露的实例分析）。

2. 分配使用了ThreadLocal又不再调用get(),set(),remove()方法，那么就会导致内存泄漏。

为什么使用弱引用：

从表面上看内存泄漏的根源在于使用了弱引用。网上的文章大多着重分析ThreadLocal使用了弱引用会导致内存泄漏，但是另一个问题也同样值得思考：为什么使用弱引用而不是强引用？

我们先来看看官方文档的说法：

To help deal with very large and long-lived usages, the hash table entries use WeakReferences for keys.为了应对非常大和长时间的用途，哈希表使用弱引用的 key。

下面我们分两种情况讨论：

1.key 使用强引用：引用的ThreadLocal的对象被回收了，但是ThreadLocalMap还持有ThreadLocal的强引用，如果没有手动删除，ThreadLocal不会被回收，导致Entry内存泄漏。

2.key 使用弱引用：引用的ThreadLocal的对象被回收了，由于ThreadLocalMap持有ThreadLocal的弱引用，即使没有手动删除，ThreadLocal也会被回收。value在下一次ThreadLocalMap调用set,get，remove的时候会被清除。

比较两种情况，我们可以发现：由于ThreadLocalMap的生命周期跟Thread一样长，如果都没有手动删除对应key，都会导致内存泄漏，但是使用弱引用可以多一层保障：弱引用ThreadLocal不会内存泄漏，对应的value在下一次ThreadLocalMap调用set,get,remove的时候会被清除。

因此，ThreadLocal内存泄漏的根源是：由于ThreadLocalMap的生命周期跟Thread一样长，如果没有手动删除对应key就会导致内存泄漏，而不是因为弱引用。

5.ThreadLocal 最佳实践

1. 每次使用完ThreadLocal，都调用它的remove()方法，清除数据。

2. 在使用线程池的情况下，没有及时清理ThreadLocal，不仅是内存泄漏的问题，更严重的是可能导致业务逻辑出现问题。所以，使用ThreadLocal就跟加锁完要解锁一样，用完就清理。

参考文章：谈谈你对 ThreadLocal 的理解

                   ThreadLocal的原理及用法 - 简书

                   https://www.toutiao.com/i6811791925943730699/