ThreadLocal 源码分析

写在前面

我们知道在使用handler进行消息传递时,需要创建Looper.prepare(),以及执行Looper.loop()方法
不了解的可以看下Handler消息机制源码分析
查看Looper.java$prepare方法源码

  private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

   private Looper(boolean quitAllowed) {
        //创建MessageQueue 这也是为什么一个Looper中只有一个MessageQueue的原因
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }

可以看到是sThreadLocal调用了set方法创建Looper ,查看Looper.java代码发现Looper是存储在ThreadLocal里面的

  static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

ThreadLocal是什么呢 ,ThreadLocal是存储当前线程数据的数据存储类。
我们知道Looper.loop()方法中调用myLooper()获取Looper对象,查看myLooper方法源码

  public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
    }

发现是直接通过调用ThreadLocal类中的get方法获取存储在ThreadLocal中的Looper。

源码分析

这里先分析ThreadLocal的set方法查看其源码

    public void set(T value) {
        //获取当前线程
        Thread t = Thread.currentThread();
        // ThreadLocalMap为ThreadLocal的静态内部类,后面会对该类进行分析
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

先看ThreadLocal类的createMap方法

   void createMap(Thread t, T firstValue) {
        //t.threadLocals是一个ThreadLocalMap对象
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }
//查看Thread类
ThreadLocal.ThreadLocalMap threadLocals = null;

每个线程通过ThreadLocal.ThreadLocalMap与ThreadLocal进行绑定,确保每个线程访问到的thread local variable都是该线程的。

现在分析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)
                return (T)e.value;
        }
        return setInitialValue();
    }

先看setInitialValue()方法源码

   private T setInitialValue() {
        //为thread local 初始化值
        T value = initialValue();
        //下面则与ThreadLocal的set方法源码相同
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }

从ThreadLocal的get方法中可以看到该方法调用了ThreadLocalMap中的set方法和getEntry方法,接下来分析ThreadLocalMap的实现。
我们先看ThreadLocalMap的介绍:是一个自定义的哈希映射表用于维护线程本地值。查看ThreadLocalMap的数据结构:

 //Entry 为ThreadLocalMap的静态内部类,继承弱引用的ThreadLocal
 static class Entry extends WeakReference<ThreadLocal> {
           // 实际保存的对象值
            Object value;
            
            Entry(ThreadLocal k, Object v) {
                super(k);
                value = v;
            }
        }

       //Entry[] 的初始大小,其值必须是2的n次幂
        private static final int INITIAL_CAPACITY = 16;

        //实际存放对象的容器,其大小必须是2的n次幂
        private Entry[] table;

        //Entry表元素的数量
        private int size = 0;

        //哈希表的扩容阈值默认值为0
        private int threshold; // Default to 0

查看ThreadLocalMap构造函数

      ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            //用firstKey的threadLocalHashCode与初始值取模获取元素放置的下标位置
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            //初始化该节点
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            //设置阈值
            setThreshold(INITIAL_CAPACITY);
        }

firstKey 为ThreadLocal对象,ThreadLocalHashCode在被ThreadLocal创建的时候就生成了

 // 相当于ThreadLocal的ID
 private final int threadLocalHashCode = nextHashCode();

接下来查看ThreadLocalMap类中的getEntry方法源码

   private Entry getEntry(ThreadLocal<?> key) {
            //根据key获取索引
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            //如果对应的Entry存在且未失效则返回
            if (e != null && e.get() == key)
                return e;
            else
                //使用线性探测,继续查找目标Entry
                return getEntryAfterMiss(key, i, e);
        }

查看getEntryAfterMiss方法源码

      private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
            Entry[] tab = table;
            int len = tab.length;
            // 基于线性探测法不断向后探测直到遇到空entry。
            while (e != null) {
                ThreadLocal<?> k = e.get();
                if (k == key)
                    return e;
                if (k == null)
                    //k为空则说明Entry中对应的ThreadLocal已经被回收,调用该方法来清理无效的entry
                    expungeStaleEntry(i);
                else
                    i = nextIndex(i, len);
                e = tab[i];
            }
            return null;
        }

查看expungeStaleEntry方法源码

 // 该函数是ThreadLocal中的核心清理函数,从staleSlot开始遍历
 //将对应Entry中的Vaule值置为空
 private int expungeStaleEntry(int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;

            // 将staleSlot对应的Entry已经Entry中的Value置为null
            tab[staleSlot].value = null;
            tab[staleSlot] = null;
            size--;

            // Rehash until we encounter null
            Entry e;
            int i;
            //从staleSlot开始遍历
            for (i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {
                ThreadLocal<?> k = e.get();
                // 清理对应ThreadLocal已经被回收的entry
                if (k == null) {
                    e.value = null;
                    tab[i] = null;
                    size--;
                } else {
                    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;
        }

查看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;
            int i = key.threadLocalHashCode & (len-1);
            //线性探测
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();
                //通过key查找到对应的Entry
                if (k == key) {
                    e.value = value;
                    return;
                }
                //替换失效的Entry
                if (k == null) {
                    //如果entry里对应的key为null的话,表明此entry为 旧的,就将其替换为当前的key和value
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                //清除失效entry并进行扩容
                rehash();
        }

接着查看replaceStaleEntry方法源码

 private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                                       int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;
            Entry e;
            int slotToExpunge = staleSlot;
            //向前扫描,查找最前的一个无效slot
            for (int i = prevIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = prevIndex(i, len))
                if (e.get() == null)
                    slotToExpunge = i;

            //向后遍历table
            for (int i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {
                ThreadLocal<?> k = e.get();

                if (k == key) {
                    e.value = value;
                    tab[i] = tab[staleSlot];
                    tab[staleSlot] = e;

                    // Start expunge at preceding stale entry if it exists
                    if (slotToExpunge == staleSlot)
                        slotToExpunge = i;
                    // 清理无效slot
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
                    return;
                }

                // 如果当前的slot已经无效,并且向前扫描过程中没有无效slot,
                // 则更新slotToExpunge为当前位置
                if (k == null && slotToExpunge == staleSlot)
                    slotToExpunge = i;
            }

            // key没找到就创建一个新的entry
            tab[staleSlot].value = null;
            tab[staleSlot] = new Entry(key, value);

            // 如果运行中有其他无效的slot则删除它们对应的entry
            if (slotToExpunge != staleSlot)
                cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
        }

查看cleanSomeSlots方法源码

     private boolean cleanSomeSlots(int i, int n) {
            boolean removed = false;
            Entry[] tab = table;
            int len = tab.length;
            do {
                i = nextIndex(i, len);
                Entry e = tab[i];
                if (e != null && e.get() == null) {
                    n = len;
                    removed = true;
                    i = expungeStaleEntry(i);
                }
            } while ( (n >>>= 1) != 0);
            return removed;
        }

清除无效的slot发现最后还是调用的expungeStaleEntry方法。

查看ThreadLocalMap的rehash方法源码

private void rehash() {
            //清除table中所有的失效的Entry
            expungeStaleEntries();

            // Use lower threshold for doubling to avoid hysteresis
            if (size >= threshold - threshold / 4)
                //对table的容量进行2倍扩容
                resize();
        }
//继续查看
 private void resize() {
            Entry[] oldTab = table;
            int oldLen = oldTab.length;
            //以原来表容量的2倍进行扩容
            int newLen = oldLen * 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
                    } 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;
        }

分析结束。

©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 212,332评论 6 493
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 90,508评论 3 385
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 157,812评论 0 348
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 56,607评论 1 284
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 65,728评论 6 386
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 49,919评论 1 290
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 39,071评论 3 410
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 37,802评论 0 268
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 44,256评论 1 303
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,576评论 2 327
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,712评论 1 341
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 34,389评论 4 332
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 40,032评论 3 316
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,798评论 0 21
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,026评论 1 266
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 46,473评论 2 360
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 43,606评论 2 350

推荐阅读更多精彩内容