面试 - handle之看Looper详谈ThreadLocal(3)

最新推荐文章于 2024-08-06 16:10:08 发布

weixin_35682082

最新推荐文章于 2024-08-06 16:10:08 发布

阅读量1

点赞数

文章标签：面试 java 职场和发展开发语言

面试handler系列：

面试 - handle使用及原理(1)

面试 - handle之详谈Message(2)

回顾Looper知识点

在第一篇中面试 - handle使用及原理(1) 在讲到Looper部分源码的时候，Looper生成跟返回有以下源码：

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");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }
    public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
    }

可以看到Looper的对象是放到sThreadLocal里面的，sThreadLocal保持只有一个Looper对象。我们知道，Handler需要获取当前线程中的Looper对象，Looper.loop()是作用于当前线程，并且不同线程拥有的Looper对象不同。使用ThreadLocal对Looper进行保存，那就实现了在不同的线程中读取到的Looper对象就是相应的那个线程中的。

这里的ThreadLocal是何方神圣，可以保持每个线程中拥有独立的Looper对象？

ThreadLocal的定义

ThreadLocal 是 JDK底层提供的一个解决多线程并发问题的工具类,它为每个线程提供了一个本地的副本变量机制，实现了和其它线程隔离，这种变量只在本线程的生命周期内起作用。当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。

言简意赅： ThreadLocal是线程内部的数据存储类，自己线程存储的数据只有自己才能获取到，其它线程获取不到。

面试 - handle之看Looper详谈ThreadLocal(3)_数组

####ThreadLocal例子

class AllTestMain{
    companion object{
       var mThread = ThreadLocal<String>()

        @JvmStatic
        fun main(args: Array<String>) {
            mThread.set("main()")

            //线程A
           var threadA = Thread(Runnable {
                mThread.set("线程A")
                println(mThread.get())
            })

            //线程B
            var threadB = Thread(Runnable {
                mThread.set("线程B")
                println(mThread.get())
            })

            println(mThread.get())
            Thread.sleep(500)
            threadA.start()

            Thread.sleep(500)
            threadB.start()

            Thread.sleep(500)
            println(mThread.get())

        }
    }
}

----------------------打印出来的结果---------------------------------------------------------------------------
main()
线程A
线程B
main()

根据上面的结果可以看到，同一个mThread对象，不同线程中读取出来的信息是不同的，读取的信息都是自己线程下设置的信息。

为什么会有这种效果？这个咱们就得来看看实现的原理了

ThreadLocal原理

分析原理的话，我们从mThread.set()方法开始为切入点吧

set()方法

public void set(T value) {
        Thread t = Thread.currentThread();
      //关键代码1
        ThreadLocalMap map = getMap(t);
      //关键代码2
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

从上面的源码可以看到关键代码1：传入线程的当前线程，并返回一个ThreadLocalMap类型的map对象关键代码2：判断map是否为null 不为null则传入ThreadLocal跟value, 为null则创建map并传入线程对象t跟value

先来看一下createMap(t, value)方法

void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

可以看到实际上存储到ThreadLocal中的数据是存到ThreadLocalMap中，这个一看就是HashMap的类似数据结构，key传入的是this对象是ThreadLocal类型的，value是泛型，我们自己定义的一个数据类型。

ThreadLocalMap类

接下来看 ThreadLocalMap类的大致一些信息

static class ThreadLocalMap {
        //内部类
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;
            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
        private static final int INITIAL_CAPACITY = 16;
        private Entry[] table;
    
          ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
          //新建Entry[]数组，初始化16
            table = new Entry[INITIAL_CAPACITY];
          //hash算法计算一下，位于数组的下标 哈希映射
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
          //将 key 跟 value 存储进去table[i]对应的哈希映射值
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            //设置阈值
            setThreshold(INITIAL_CAPACITY);
        } 
        private void setThreshold(int len) {
            threshold = len * 2 / 3;
        }
}

ThreadLocalMap中可以看到Entry是存储单位，而存储结构实际上是一个Entry[] table数组。上面的构造函数可以看到类似hashmap先用Key值进行hash算法计算映射，求出位于数组的下标的多少，然后将传入的key跟value值初始化一个Entry对象，并放到Entry[] table中。然后设置阈值 len*2/3 (len = 16) 如果超过阈值便要重新分配table

Entry的数据类中继承了WeakReference<ThreadLocal<?>>使用弱引用挟持着ThreadLocal防止挟持线程的数据，导致线程生命周期受到影响进而导致内存泄漏

这里简要说明一下常用的几个引用的作用强应用：这个是我们常用的平时都是new Object()，就算是OOM都不会被虚拟机回收软引用： new SoftReference() ，当要发生OOM的时候会被回收掉弱引用：new WeakReference()，当GC的时候就会被回收掉

返回最开始的mThread.set()方法里面的map.set(this, value)

private void set(ThreadLocal<?> key, Object value) {
            //获取table数组
            Entry[] tab = table;
            //tab数组的长度
            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();
              //如果存在旧数据则替换为新数据
                if (k == key) {
                    e.value = value;
                    return;
                }
              //如果k为null则
                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }
            //正常插入数据
            tab[i] = new Entry(key, value);
            int sz = ++size;
            //超过阈值的时候 重新计算哈希并重组数组
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

上面的简单讲解一下如果传入的key计算出下标，根据下标有三种情况处理：

tab[i]为null :直接插入新的数据，如果sz >= threshold则重新扩增数组rehash() 2.tab[i]不为null分下面两种情况

key不为null ：则更新新的数据e.value = value并返回
key为null：则调用replaceStaleEntry(key, value, i)将数据存储进去，并返回

最主要看下面的几个方法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;
        }

        private void rehash() {
            expungeStaleEntries();

            // Use lower threshold for doubling to avoid hysteresis
            if (size >= threshold - threshold / 4)
                resize();
        }

cleanSomeSlots主要就是将那些key不为null,但是value为空的调用expungeStaleEntry(i)清除掉，如果清除了就是返回ture否则返回false

expungeStaleEntry(i)是真正删除数据的地方，删除那些key存在，但是value不存在的Entry数据

rehash()就是先调用expungeStaleEntry()，然后再根据if (size >= threshold - threshold / 4)去决定要不要resize()

resize()这个就是现在的关键了

private void resize() {
            Entry[] oldTab = table;
            int oldLen = oldTab.length;
            //关键代码1
            int newLen = oldLen * 2;
            Entry[] newTab = new Entry[newLen];
            int count = 0;
          // 关键代码2
            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++;
                    }
                }
            }
          //关键代码3
            setThreshold(newLen);
            size = count;
            table = newTab;
        }

简单的解释一下上面的源码：

关键代码1：生成新的数组，新的数组是旧的数据的两倍

关键代码2：轮训旧数据，将e！= null的Entry取出如果key为null,则清除掉对应的value 如果key不为null，则计算出对应的新的数组的下标并存储进去

关键代码3：设置新的阈值。

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

先看一下没有数据的时候返回什么的吧

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;
    }
  protected T initialValue() {
        return null;
    }

看见了吗，返回了一个空值，并向ThreadLocalMap中插入（key=this,value = null）

那有数据的时候ThreadLocalMap.Entry e = map.getEntry(this) 看一下源码

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

计算出数组下标，然后比较当前的key是不是要找的那个 ThreadLocal，如果不是则调用 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;
                if (k == null)
                    expungeStaleEntry(i);
                else
                    i = nextIndex(i, len);
                e = tab[i];
            }
            return null;
        }

有便返回没有便返回空，发现k==null的时候再调用了expungeStaleEntry(i)去掉该元素。

总结： 1.每个线程都存在ThreadLocalMap,在线程中通过ThreadLoad<T>获取到对应线程下的ThreadLocalMap然后在里面传入ThreadLoad作为键去进行数据的存储跟读取。

面试 - handle之看Looper详谈ThreadLocal(3)_数据_02

面试 - handle之看Looper详谈ThreadLocal(3)_数据_03

自己实现类似功能

//定义基本的功能
class LocalThreadExp<T>() {

    var mHashMap = ConcurrentHashMap<Thread, T>()

    fun set(value: T) {
        mHashMap[Thread.currentThread()] = value
    }

    fun get(): T? {
        val thread = Thread.currentThread()
        var  o = mHashMap[thread]
        return o
    }
}
//这个是测试类
class AllTestMain {
    companion object {
        var local = LocalThreadExp<String>()
        @JvmStatic
        fun main(args: Array<String>) {
            local.set("main()")
            //线程A
            var threadA = Thread(Runnable {
                local.set("线程A")
                println(local.get())
            })
            //线程B
            var threadB = Thread(Runnable {
                local.set("线程B")
                println(local.get())
            })
            println(local.get())
            Thread.sleep(500)
            threadA.start()
            Thread.sleep(500)
            threadB.start()
            Thread.sleep(500)
            println(local.get())
        }
    }
}

------------输出打印的信息--------------------------------------------------------
main()
线程A
线程B
main()

注意事项

声明为全局静态的final成员。

添加的时候是以threadLocal为key，传入的值为value的。所以，不同的threadLocal对象会导致存储的数据对象不一致而导致找不到数据。

避免存储大量对象。
用完之后及时移除对象。

关于ThreadLocal的就到这里，如果有什么疑问或者面试碰到的问题欢迎在评论区留言

原创作者: u_12972174 转载于: https://blog.51cto.com/u_12972174/11661599

weixin_35682082

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面试 - handle之看Looper详谈ThreadLocal(3)

面试handler系列：面试 - handle使用及原理(1) 面试 - handle之详谈Message(2)回顾Looper知识点在第一篇中面试 - handle使用及原理(1) 在讲到Looper部分源码的时候，Looper生成跟返回有以下源码：登录后复制 static final ThreadLocal&lt...
复制链接

扫一扫