ThreadLocal源码学习

最新推荐文章于 2024-07-23 10:03:49 发布

黑山老妖2018

最新推荐文章于 2024-07-23 10:03:49 发布

阅读量139

点赞数

分类专栏： android

本文链接：https://blog.csdn.net/cxm2015/article/details/83016538

版权

android 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

在学习EventBus源码的时候看到了ThreadLocal，经查阅相关资料才知道ThreadLocal用到的地方还挺多，所以就简单在这里分析下ThreadLocal的原理及问题

什么是ThreadLocal

ThreadLocal是一个能帮助线程存储变量副本的工具类，为什么是变量副本，因为当多个线程访问同一个变量，ThreadLocal就会将每个线程和这个变量一一建立映射关系（注意这里一一映射只是个伪概念），这样每个线程对应的都是这个变量的副本，互不影响，互不干扰，尤其是在高并发情况下，每个线程可以通过ThreadLocal获取相应的信息进行操作。

实现思路

查看Thread源码可以发现，Thread类里存在一个ThreadLocal.ThreadLocalMap类型的成员变量threadLocals，即每个线程里都单独有一个ThreadLocal.ThreadLocalMap。而ThreadLocal.ThreadLocalMap里维护了一个Entry数组，Entry是一个key-value形式的存储类，其中key是ThreadLocal对象的弱引用，value是要存入的副本变量。ThreadLocal在给每个Thread存数据的时候都是以当前ThreadLocal实例的弱引用为key，将数据插入到到自己的ThreadLocalMap当中，所以不同的线程在根据key（同一个ThreadLocal实例的弱引用）读写数据时互不影响，互不干扰。

现在我们来看看ThreadLocal的`代码片`

ThreadLocal核心方法

//获取当前线程存储的副本变量值，如果当前线程没有存储该值，则返回initialValue()方法返回值
public T get()

//初始化当前线程的副本变量
private T setInitialValue()

//设置当前线程的副本变量
public void set(T value)

//移除当前线程的副本变量
public void remove() 

//初始化当前线程的副本变量 
protected T initialValue()

ThreadLocal核心内部类

public T get()

public T get() {
    //获取当前线程
    Thread t = Thread.currentThread();
    //获取当前线程的ThreadLocalMap
    ThreadLocalMap map = getMap(t);
    if (map != null) {
       //通过ThreadLocal对象获取Entry对象
       ThreadLocalMap.Entry e = map.getEntry(this);
       if (e != null) {
          @SuppressWarnings("unchecked")
          T result = (T)e.value;
             return result;
          }
       }
       //如果map为null，则构建map
        return setInitialValue();
   }

    private Entry getEntry(ThreadLocal<?> key) {
        int i = key.threadLocalHashCode & (table.length - 1);
        Entry e = table[i];
        //如果e不为null且key没有被回收且e的key值弱引用指向的ThreadLocal与key相等
        //则返回该entry对象
        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;

            while (e != null) {
                ThreadLocal<?> k = e.get();
                //找到目标，直接返回entry对象
                if (k == key)
                    return e;
                //如果key值指向的ThreadLocal对象被回收，则执expungeStaleEntry
                //进行清理
                if (k == null)
                    expungeStaleEntry(i);
                else
                    i = nextIndex(i, len);
                e = tab[i];
            }
            return null;
        }

    //因为staleSlot位置的entry对象的key指向区域已经被回收，所以手动将
    //tab[staleSlot]以及tab[staleSlot].value置为null
    //第二件事，从staleSlot开始遍历，对每个位置上的非空entry进行位置调整
	private int expungeStaleEntry(int staleSlot) {
    	Entry[] tab = table;
    	int len = tab.length;

    	//因为key ThreadLocal的弱引用已经被置为null被回收或者即将被回收，所以将
    	//entry的value也置为null，entry也置为null
    	tab[staleSlot].value = null;
    	tab[staleSlot] = null;
    	//size减1
    	size--;

     	Entry e;
	    int i;
     	for (i = nextIndex(staleSlot, len);(e = tab[i]) != null;i = 		nextIndex(i, len)) {
        	ThreadLocal<?> k = e.get();
        	if (k == null) {
        	//如果key ThreadLocal的弱引用已经被置为null被回收，则将
        	//entry的value也置为null，entry也置为null，同时大小减1
           		e.value = null;
           		tab[i] = null;
           		size--;
         	} else {
          	//如果没有被回收，则获取k的hash值，判断是否是当前位置，
          	//如果不是，则从k位置开始遍历直到找到entry为null的时候，将当前i位置的
          	//entry赋值到tab[h]上，同时将当前i位置的entry对象置为null
           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;
   }

private T setInitialValue()

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;
    }

  //这里可以看到给Thread的ThreadLocalMap成员变量赋值，再进入ThreadLocalMap的构造函数看看
  void createMap(Thread t, T firstValue) {
      t.threadLocals = new ThreadLocalMap(this, firstValue);
  }

  private static final int INITIAL_CAPACITY = 16;
 
  ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
      //大小为16的entry对象数组
      table = new Entry[INITIAL_CAPACITY];
      //firstKey.threadLocalHashCode与INITIAL_CAPACITY取模获取哈希值，也是数组中的位置
      int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
      table[i] = new Entry(firstKey, firstValue);
      size = 1;
      setThreshold(INITIAL_CAPACITY);
  }

public void remove()

public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
      //根据ThreadLocal对象删除变量副本
      m.remove(this);
}

private void remove(ThreadLocal<?> key) {
    //获取entry数组
    Entry[] tab = table;
    //获取数组长度
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);
    //对数组进行遍历，当找到key时，执行e.clear（），显示将弱引用置为null
    //同时执行expungeStaleEntry（）方法
    for (Entry e = tab[i];e != null;e = tab[i = nextIndex(i, len)]) {
        if (e.get() == key) {
            e.clear();
            expungeStaleEntry(i);
            return;
         }
     }
  }

public void set(T value)

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
       map.set(this, value);
    else
       createMap(t, value);
 }

//ThreadLocalMap set
private void set(ThreadLocal<?> key, Object value) {
     Entry[] tab = table;
     int len = tab.length;
     int i = key.threadLocalHashCode & (len-1);

     //遍历entry数组
     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已经被回收，则替换掉快要失效的entry
          if (k == null) {
             replaceStaleEntry(key, value, i);
             return;
           }
       }

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

//ThreadLocal的内部类
static class ThreadLocalMap {

    //这里可以看出Entry类是key-value的数据结构，并且Entry（key）是持有
    //ThreadLocal的软引用
	static class Entry extends WeakReference<ThreadLocal<?>> {
       /** The value associated with this ThreadLocal. */
       Object value;

       Entry(ThreadLocal<?> k, Object v) {
          super(k);
          value = v;
        }
     }
     
     //初始容量，必须为2的幂
     private static final int INITIAL_CAPACITY = 16;
	 //entry数组，大小必须为2的幂
     private Entry[] table;
     //entry数组大小
     private int size = 0;
     
     private int threshold; // Default to 0
}

   //返回下一个索引
    private static int nextIndex(int i, int len) {
       return ((i + 1 < len) ? i + 1 : 0);
    }
    
    //返回上一个索引
    private static int prevIndex(int i, int len) {
       return ((i - 1 >= 0) ? i - 1 : len - 1);
    }

可以看出ThreadLocalMap维护的tab数组是一个环形结构，数组里每个对象都是Entry对象（key-value的结构），一个ThreadLocalMap可以存储多个ThreadLoad对象key值。

ThreadLocal问题所在

ThreadLocal.ThreadLocalMap使用ThreadLocal对象的弱引用作为Entry的key，一旦ThreadLocal对象被回收，即key为null，如果一个线程里存储了上百个ThreadLoad对象空间，则出现key为null的Entry对象就会越来越多，加上这个线程一直存在不结束的可能，这时候就会引发内存泄漏。

那么问题来了，这时候是不是会认为是弱引用的key值导致Entry对象不能被回收的从而内存泄漏的。其实不然，我们来看以下两种情况：
1.key 使用强引用：在回收ThreadLocal的对象时，但是ThreadLocalMap还持有ThreadLocal的强引用，如果没有手动置为null，则ThreadLocal不会被回收，导致Entry内存泄漏。
2.key 使用弱引用：在回收ThreadLocal的对象时，由于ThreadLocalMap持有ThreadLocal的弱引用，即使没有手动置为null，ThreadLocal也会被回收。value在下一次ThreadLocalMap调用set，get，remove的时候会被清除。

所以问题的本质在于没有手动将key置为null。
ThreadLocal是通过将key设置为弱引用，并且同时利用set，get，remove方法来手动删除key为null的Entry对象来避免内存泄漏。当ThreadLocal存储很多Key为null的Entry的时候，而不再去调用remove、get、set方法，那么将导致内存泄漏。