Android-ThreadLocal

概述

• ThreadLocal用于保存线程作用域内的对象；对象是线程共享的，所以为了达到线程之间使用不同的对象，使用者不能将对象赋值给类变量或者实例变量，只能赋值给局部变量，ThreadLocal对象无限制，但是ThreadLocal需要static(一般为static final或者private static，但是禁止外部方法重复创建ThreadLocal对象)；
• 主要涉及ThreadLocal和ThreadLocalMap两个类，简单说下两个类的作用，方便源码解析；ThreadLocal对象相当于一份数据在不同线程的数据对象的集合，通过ThreadLocal获取数据时，只能获取到当前线程对应的数据；ThreadLocalMap相当于一个线程内所有的ThreadLocal对象在该线程内的数据对象Map，key是ThreadLocal的hashCode（定制hashCode，并非Object.hashCode生成）；ThreadLocalMap外部不能访问，只能通过ThreadLocal获取数据；
• 很多SDK源码或者第三方库中都用到了ThreadLocal，比如Looper对象就是保存在ThreadLocal中；
• 源码是基于Android-SDK-29；

源码

ThreadLocalMap

• ThreadLocalMap相当于单线程作用域的Map，是所有ThreadLocal对象在本线程的数据的Map集合；
• ThreadLocalMap是存储在Thraed对象中，也就确保了一个线程对应了一个ThredLocalMap，ThreadLocalMap里存储的都是本线程对应的所有数据；
• ThreadLocal.ThreadLocalMap.Entry

  static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;
    Entry(ThreadLocal<?> k, Object v) {
      super(k);
      value = v;
    }
  }
  

  • Entry类似于HashMap中的Entry，用来保存真正的数据；
  • Entry继承于WeakReference<ThreadLocal>，如果ThreadLocal（可以理解成对数据的封装了一层，get/set都是和当前相关联的数据）被回收了（比如static的ThreadLocal被重新赋值并触发GC，原来的ThreadLocal对象就会被回收），但是Entry对象或者数据并没有回收，在相关方法调用时做后续处理；
• ThreadLocal.ThreadLocalMap
  • ThreadLocalMap的数据结构是数组，数组元素是Entry，根据ThreadLocal对象的hashCode和数组长度求模算出对应的索引，如果数组对应的引用为null，则直接存储，否则，循环索引递增求模，直到数组对应索引为null存储；
  • ThreadLocalMap有个很重要的概念，源码中是 run ，可以理解成“链”，即数组中连续不为null的部分称为“链”；
  • ThreadLocalMap.set

    private void set(ThreadLocal<?> key, Object value) {
            // We don't use a fast path as with get() because it is at
            // least as common to use set() to create new entries as
            // it is to replace existing ones, in which case, a fast
            // path would fail more often than not.
    
            Entry[] tab = table;
            int len = tab.length;
            //ThreadLocal对象的hashCode（定制）和数组长度求模，得到数组的索引；
            int i = key.threadLocalHashCode & (len-1); 
            //从索引开始递增，直到索引对应的引用为null
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();
                //ThreadLocal对象为static，所以直接用 == 做判断
                if (k == key) {
                    //更新已存在的数据
                    e.value = value;
                    return;
                }
                //ThreadLocal对象已被回收
                if (k == null) {
                    //替换Entry并清除已回收的ThreadLocal
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }
            //新创建Entry对象，放在末尾处
            tab[i] = new Entry(key, value);
            int sz = ++size;
            //清除已回收ThreadLocal
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash(); //扩容
        }
    

    • 1.根据ThreadLocal的hashCode（定制hashCode）求模，算出对应的索引；
    • 2.循环索引递增，如果Entry中的ThreadLocal匹配，则更新数据，如果Entry中ThreadLocal已被回收，则替换Entry并删除其他被回收的Entry；
    • 3.如果没有找到Entry，则创建新的Entry并放在链的末尾；
  • 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); //在链中寻找
        }
    
    private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
            Entry[] tab = table;
            int len = tab.length;
            //循环迭代直到链结束
            while (e != null) {
                ThreadLocal<?> k = e.get();
                if (k == key)
                    return e; //ThreadLocal匹配，直接返回
                if (k == null)
                    expungeStaleEntry(i); //从i开始到链结束，删除已回收ThreadLocal，未被回收的重新求模存储；
                else
                    i = nextIndex(i, len);
                e = tab[i];
            }
            return null;
        }
    

  • ThreadLocalMap.remove

    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();
                    //从i开始循环当前链，删除已回收ThreadLocal，未被回收的重新求模存储；
                    expungeStaleEntry(i);
                    return;
                }
            }
        }
    

  • ThreadLocalMap.resize

    private void rehash() {
            //删除所有已被回收的ThreadLocal，并重新求模存储
            expungeStaleEntries();
            // Use lower threshold for doubling to avoid hysteresis
            if (size >= threshold - threshold / 4) //超过阈值的3/4，就扩容；阈值是数组长度的2/3；
                resize(); //扩容
        }
    private void resize() {
            Entry[] oldTab = table;
            int oldLen = oldTab.length;
            int newLen = oldLen * 2; //2倍扩容
            Entry[] newTab = new Entry[newLen];
            int count = 0;
    
            for (int j = 0; j < oldLen; ++j) {
                Entry e = oldTab[j];
                if (e != null) {
                    ThreadLocal<?> k = e.get();
                    if (k == null) {
                        e.value = null; // Help the GC，处理已被回收的ThreadLocal
                    } else {
                        //重新求模存储
                        int h = k.threadLocalHashCode & (newLen - 1);
                        while (newTab[h] != null)
                            h = nextIndex(h, newLen);
                        newTab[h] = e;
                        count++;
                    }
                }
            }
    
            setThreshold(newLen);
            size = count;
            table = newTab;
        }
    

    • 扩容是按照原来数组长度的两倍扩容；触发扩容是大于等于3/4阈值，阈值是数组长度的2/3，触发扩容是数组长度的1/2；

ThreadLocal

• ThreadLocal对象可以理解为数据对象在不同线程中的备份的集合；ThreadLocal对象是static，才能确保线程内唯一；
• hashCode

  //当前ThreadLocal对象的hashCode
  private final int threadLocalHashCode = nextHashCode();
  //静态变量，存储最后一个创建的ThreadLocal对象的hashCode
  private static AtomicInteger nextHashCode = new AtomicInteger();
  //ThreadLocal对象之间hashCode的间隔
  private static final int HASH_INCREMENT = 0x61c88647;
  //用于生成下一个ThreadLocal对象的hashCode
  private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
  }
  

  • ThreadLocal对象的hashCode是定制的，对象之间的hashCode是固定间隔的，对于同一个ThreadLocal的不同线程之间的备份数据对象，由于是同一个ThreadLocal对象，所以hashCode是一样的；
• ThreadLocal.get

  public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            //获取ThreadLocalMap中ThreadLocal对应的Entry
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                //本线程对应的数据
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }
  
  ThreadLocalMap getMap(Thread t) {
        return t.threadLocals; //Thread中的ThreadLocalMap变量
    }
  

• ThreadLocal.set

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

• ThreadLocal.remove

  public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }
  

总结

• 只有在线程内唯一实例的时候，才需要用ThreadLoal，ThreadLocal变量要static，并且确保同一份数据（对于业务层）只有一个ThreadLocal对象；
• 数据本身不要被类变量或者实例变量引用，只有在方法内部使用的时候，通过ThreadLocal获取；否则，不同线程的数据对象还是可以被其他线程访问；