ThreadLocal原理详解--面试粉碎机-51CTO.COM

一种解决多线程环境下成员变量的问题的方案，但是与线程同步无关，其思路是为每一个线程创建一个单独的变量副本，从而每个线程都可以独立地改变所拥有的变量副本，而不会影响其他线程所对应的副本；
ThreadLocal不是用于解决共享变量的问题的，也不是为了协调线程同步而存在，而是为了方便每个线程处理自己的状态而引入的一个机制；

1、threadlocal使用

void set(Object value)

设置当前线程的线程局部变量的值

public Object get()

该方法返回当前线程所对应的线程局部变量

public void remove()

将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是JDK 5.0新增的方法。需要指出的是，当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度；

创建一个ThreadLocal对象

private ThreadLocal<Integer> localInt = new ThreadLocal<>();
public int setAndGet(){
    localInt.set(8);
    return localInt.get();
}

设置变量的值为8

ThreadLocal里设置的值，只有当前线程自己看得见，这意味着你不可能通过其他线程为它初始化值。为了弥补这一点，ThreadLocal提供了一个withInitial()方法统一初始化所有线程的ThreadLocal的值：

private ThreadLocal<Integer> localInt = ThreadLocal.withInitial(() -> 6);

上述代码将ThreadLocal的初始值设置为6，这对全体线程都是可见的

2、ThreadLocal源码分析

ThreadLocal类源码

/**
 * ThreadLocals依赖于附加到每个线程的每个线程线性探测哈希映射（thread.ThreadLocals和可继承的ThreadLocal）。
 * ThreadLocal对象充当键，通过threadLocalHashCode进行搜索。
 * 这是一个自定义哈希代码（仅在ThreadLocalMaps中有用），在相同线程使用连续构造的ThreadLocal的常见情况下消除了冲突，
 * 而在不常见的情况下保持良好的行为。
 */
private final int threadLocalHashCode = nextHashCode();
/**
 * 要给出的下一个哈希代码。原子更新。从零开始。
 */
private static AtomicInteger nextHashCode = new AtomicInteger();
/**
 * 连续生成的哈希码之间的差异-将隐式顺序线程本地ID转换为两个大小表的幂的近似最优的乘法哈希值。
 */
private static final int HASH_INCREMENT = 0x61c88647;
/**
 * 返回下一个哈希代码。
 */
private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}
/**
 * 设置调整大小阈值，在最坏的情况下为 2/3 负载系数
 */
private void setThreshold(int len) {
    threshold = len * 2 / 3;
}
/**
 * 根据传入的下标，返回下一个下标 (环形: 0-1-...-(len-1)-len-0-1-...-len)
 */
private static int nextIndex(int i, int len) {
    return ((i + 1 < len) ? i + 1 : 0);
}
/**
 * ThreadLocalMap 内部类
 */
static class ThreadLocalMap {
    private Entry[] table;//数据数组
    private int size = 0;//数组大小
    private int threshold; //阈值
    private static final int INITIAL_CAPACITY = 16; //默认大小
    /*
     * Entry 继承WeakReference，并且用ThreadLocal作为key.
     * 如果key为null(entry.get() == null)，意味着key不再被引用，
     * 因此这时候entry也可以从table中清除。
     */
    static class Entry extends WeakReference<ThreadLocal<?>> {
        Object value; //存储线程值
        Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }
    /**
    * 初始化
    */
    ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
        table = new Entry[INITIAL_CAPACITY];
        int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
        table[i] = new Entry(firstKey, firstValue);
        size = 1;
        setThreshold(INITIAL_CAPACITY);
    }
}

作为一个存储数据的类，关键点就在get和set方法。

（1）set 方法

//set 方法
public void set(T value) {
      //获取当前线程
      Thread t = Thread.currentThread();
      //实际存储的数据结构类型
      ThreadLocalMap map = getMap(t);
      //如果存在map就直接set，没有则创建map并set
      if (map != null)
          map.set(this, value);
      else
          createMap(t, value);
  }
//getMap方法
ThreadLocalMap getMap(Thread t) {
      //thred中维护了一个ThreadLocalMap
      return t.threadLocals;
 }
//createMap
void createMap(Thread t, T firstValue) {
      //实例化一个新的ThreadLocalMap，并赋值给线程的成员变量threadLocals
      t.threadLocals = new ThreadLocalMap(this, firstValue);
}

首先获取当前线程，并根据当前线程获取一个Map。
如果获取的Map不为空，则将参数设置到Map中（当前ThreadLocal的引用作为key）。
(这里调用了ThreadLocalMap的set方法)**。
如果Map为空，则给该线程创建 Map，并设置初始值。
(这里调用了ThreadLocalMap的构造方法)**。
构造方法`ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue)。

/*
  * firstKey : 本ThreadLocal实例(this)
  * firstValue ： 要保存的线程本地变量
  */
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
        //初始化table
        table = new ThreadLocal.ThreadLocalMap.Entry[INITIAL_CAPACITY];
        //计算索引(重点代码）
        int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
        //设置值
        table[i] = new ThreadLocal.ThreadLocalMap.Entry(firstKey, firstValue);
        size = 1;
        //设置阈值
        setThreshold(INITIAL_CAPACITY);
    }

构造函数首先创建一个长度为16的Entry数组，然后计算出firstKey对应的索引，然后存储到table中，并设置size和threshold。

ThreadLocalMap中的set方法

private void set(ThreadLocal<?> key, Object value) {
        ThreadLocal.ThreadLocalMap.Entry[] tab = table;
        int len = tab.length;
        //计算索引(重点代码，刚才分析过了）
        int i = key.threadLocalHashCode & (len-1);
        /**
         * 使用线性探测法查找元素（重点代码）
         */
        for (ThreadLocal.ThreadLocalMap.Entry e = tab[i];
             e != null;
             e = tab[i = nextIndex(i, len)]) {
            ThreadLocal<?> k = e.get();
            //ThreadLocal 对应的 key 存在，直接覆盖之前的值
            if (k == key) {
                e.value = value;
                return;
            }
            // key为 null，但是值不为 null，说明之前的 ThreadLocal 对象已经被回收了，
           // 当前数组中的 Entry 是一个陈旧（stale）的元素
            if (k == null) {
                //用新元素替换陈旧的元素，这个方法进行了不少的垃圾清理动作，防止内存泄漏
                replaceStaleEntry(key, value, i);
                return;
            }
        }
        //ThreadLocal对应的key不存在并且没有找到陈旧的元素，则在空元素的位置创建一个新的Entry。
            tab[i] = new Entry(key, value);
            int sz = ++size;
            /**
             * cleanSomeSlots用于清除那些e.get()==null的元素，
             * 这种数据key关联的对象已经被回收，所以这个Entry(table[index])可以被置null。
             * 如果没有清除任何entry,并且当前使用量达到了负载因子所定义(长度的2/3)，那么进行              * rehash（执行一次全表的扫描清理工作）
             */
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
}
 /**
     * 获取环形数组的下一个索引
     */
    private static int nextIndex(int i, int len) {
        return ((i + 1 < len) ? i + 1 : 0);
    }

首先还是根据key计算出索引 i，然后查找i位置上的Entry。
若是Entry已经存在并且key等于传入的key，那么这时候直接给这个Entry赋新的value值。
若是Entry存在，但是key为null，则调用replaceStaleEntry来更换这个key为空的Entry。
不断循环检测，直到遇到为null的地方，这时候要是还没在循环过程中return，那么就在这个null的位置新建一个Entry，并且插入，同时size增加1。
ThreadLocalMap使用线性探测法来解决哈希冲突的；该方法一次探测下一个地址，直到有空的地址后插入，若整个空间都找不到空余的地址，则产生溢出。

（2）get()方法

//ThreadLocal中get方法
public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}
//ThreadLocalMap中getEntry方法
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);
   }

通过计算出索引直接从数组对应位置读取即可；

（3）ThreadLocal特性

ThreadLocal和Synchronized都是为了解决多线程中相同变量的访问冲突问题；
Synchronized是通过线程等待，牺牲时间来解决访问冲突
ThreadLocal是通过每个线程单独一份存储空间，牺牲空间来解决冲突，并且相比于Synchronized，ThreadLocal具有线程隔离的效果，只有在线程内才能获取到对应的值，线程外则不能访问到想要的值；
正因为ThreadLocal的线程隔离特性，使他的应用场景相对来说更为特殊一些。在android中Looper、ActivityThread以及AMS中都用到了ThreadLocal；
当某些数据是以线程为作用域并且不同线程具有不同的数据副本的时候，就可以考虑采用ThreadLocal；

3、ThreadLocal内存泄漏

我们调用threadLocal的set，get方法时，会判断当前的key是否为null，将Entry中的value赋值为null，但是这个释放value还有其他条件限制，并不是一定会发生，当系统内存不足时，由于Entry中的key继承软引用，回被垃圾回收器回收调，这时，Entry中的key为null，无法被线程访问，但是value仍然占用一定的内存空间，虽然在调用set，get方法时有可能进行系统回收，仍然无法回收无用所有内存。无法被访问的vlaue就会导致内存泄漏，怎么解决内存泄漏呢，最好的方法就是当我们使用完变量副本后及时调用remove方法，手动进行垃圾回收。

public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }
   /**
    * Remove the entry for key.
    */
 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) {
                    e.clear();//清除value
                    expungeStaleEntry(i);
                    return;
                }
            }
    }

当线程发生内存泄漏时，线程与内部的ThreadLocalMap之间存在着强引用，导致ThreadLocalMap无法被释放，这时由于ThreadLocalMap中的Entry的key为弱引用，ThreadLocal容易被回收，导致key为null，当调用remove方法时，会清除key为null对应的value。
所以为了避免内存泄漏的出现，我们在使用完ThreadLocal的set方法后，及时调用remove方法进行内存释放。避免出现内存泄漏。