秀一波多线程的操作技巧,又能Get新知识点了

本篇文章来自 二娃_ 的投稿,分享了他对ThreadLocal原理的理解,希望对大家有所帮助! 同时也感谢作者贡献的精彩文章。

二娃_ 的博客地址:

https://juejin.im/user/5bf67660e51d45218f3d0938

在Android的handler消息机制中looper是怎么绑定线程的?为什么这样做可以达到绑定线程的目的?

想要解答并彻底理解这两个问题那就需要搞明白ThreadLocal到底是什么?它又是如何工作的?我们本篇的目的就是先搞明白这两个问题,然后回答上边的两个问题。

在开始之前我想先说这么一个观点:一般情况下,大家学习一个源码原理的时候,都是通过解读甚至精读源码来学会一个原理,我认为这是背诵式的学习方式,就好比源码写的是一、二、三,我们通过读懂了『一、二、三』从而学会了、知道了他的实现原理,但我们容易忽略本质的问题,就是源码的实现要解决的问题是什么?为什么它这么做就能解决问题?如果让我们做是否能想到这样的方案或者其它的方案?

所以 对于一些原理性的知识,我认为如果我们能从本质问题出发,从演化的角度去思考它解决问题的方式、去模拟(手写代码)它解决问题的过程,甚至去思考扩展其它的解决方案,我想这样得来的知识才是透彻的、想忘都忘不掉的。

/   ThreadLocal到底是什么   /

ThreadLocal的存在肯定是在解决某个问题的,所以这个问题是什么呢?

问题是:如何将数据与线程绑定起来,从而该数据只能在绑定的线程里访问,而其它线程无法访问?

ThreadLocal能很方便的解决这个问题,这也就是所谓的线程间数据隔离。Local这个单词有『局部的』意思,并且在源码首行注释中已写明『This class provides thread-local variables.(该类提供线程局部变量)』,所以ThreadLocal的最佳理解是线程局部变量辅助器,通过它能很方便的设置或者获取线程私有的数据。而线程私有的数据也被美其名曰线程局部变量。

/   ThreadLocal是如何工作的   /

思考分析

NOTE:该思路与源码是一致的,请放心食用,我们重在复现并理解思路的演化过程。 我们已经了解了问题,那换做我们会如何思考解决呢?现在有这么个思路:

Thread本身就是个线程对象,可以在其内部用一个Map数据结构来存储要绑定的数据。 就是这种简单的方式,让数据与线程关联起来,就可以达到与线程绑定的目的。 为了模拟我们定义一个MockThread类, 在内部定义一个Map数据结构类型的成员变量。

我们定义一个MockThreadLocal类作为辅助器,专门用来操作当前线程里的Map。 因为每次操作的都是当前线程,所以就达到了隔离的目的。 我们对外暴露set,get和remove三个API方法。

我们将使用MockThreadLocal的实例作为Map的key,并且key需要使用弱引用进行一次包装。 这样一来对外部使用者来说,只要有MockThreadLocal的实例就可以很方便的set,get和remove的数据。 因为MockThreadLocal的生命周期将和MockThread一样长,需要做防止内存泄漏的处理。

我们将在MockThreadLocal类上定义泛型,该泛型用于存储到Map里的Value的类型。

思路已确定,接下来手写ThreadLocal!

手写ThreadLocal

先写下MockThread类,这个比较简单。需要注意的是ThreadLocalMap是定义在MockThreadLocal类中的。

class MockThread(target: Runnable, name: String) : Thread(target, name) {
    //用于保存绑定到线程上的数据
    var threadLocals: MockThreadLocal.ThreadLocalMap? = null
}

再写下MockThreadLocal类,代码本身并没有难度,我们以get方法为例分析一把(我把详细的注释加到了代码上)。

open class MockThreadLocal<T> {

    /**      * 往当前线程上绑定数据      */
    fun set(value: T) {
        val t = Thread.currentThread() as MockThread
        val map = getMap(t)
        if (map != null)
            map.set(this, value as Any?)
        else
            createMap(t, value)
    }

    /**      * 获取在当前线程上绑定的数据      */
    fun get(): T? {
        // 获取当前的线程
        val t = Thread.currentThread() as MockThread
        // 获取当前线程持有的ThreadLocalMap
        val map = getMap(t)
        if (map != null) {
            // 如果map不为null,就使用自己作为key来获取value(MockThreadLocal的实例)
            val e = map.get(this)
            if (e != null) {
                return e as T?
            }
        }
        // 如果map为null,设置初始化的值,并返回该值
        return setInitialValue()
    }

    /**      * 移除在当前线程上绑定的数据      */
    fun remove() {
        val m = getMap(Thread.currentThread() as MockThread)
        m?.remove(this)
    }

    /**      * 设置初始化的值      */
    private fun setInitialValue(): T? {
        val value = initialValue()
        val t = Thread.currentThread() as MockThread
        val map = getMap(t)
        if (map != null)
            map.set(this, value as Any?)
        else
            createMap(t, value)
        return value
    }

    /**      * 默认初始化的值,子类可复写该方法,自定义初始化值      */
    open fun initialValue(): T? {
        return null
    }

    /**      * 创建数据保存类,并赋值给线程      */
    private fun createMap(t: MockThread, value: T?) {
        t.threadLocals = ThreadLocalMap(this, value as Any?)
    }

    /**      * 获取线程中的数据保存类      */
    private fun getMap(t: MockThread): ThreadLocalMap? {
        return t.threadLocals
    }

    ... 省略ThreadLocalMap相关代码
}

最后就是写下ThreadLocalMap类,该类是实际保存、处理数据的类,代码同样没有难度。其中一个重点就是对弱引用的处理,每次都要尝试清除无用数据,来尽量避免内存泄漏。

open class MockThreadLocal<T> {

    ... 省略代码

    /**      * 定义该类,用于实际保存数据、处理数据      */
    class ThreadLocalMap(firstKey: MockThreadLocal<*>, firstValue: Any?) {
        private var mMap: MutableMap<WeakReference<MockThreadLocal<*>>, Any?>? = null

        init {
            //首次初始化时,设置初始化值
            mMap = mutableMapOf(WeakReference(firstKey) to firstValue)
        }

        /**          * 设置一个存储的数据          */
        fun set(key: MockThreadLocal<*>, value: Any?) {
            //优先清除一次无用数据,防止内存泄漏
            expungeStaleEntry()
            if (mMap != null) {
                var keyExist = false
                mMap!!.forEach { (k, _) ->
                    //若相应的key已存在,只需替换该value即可
                    if (k.get() == key) {
                        mMap!![k] = value
                        keyExist = true
                    }
                }

                //若相应的key不存在,则保存新的数据
                if (!keyExist) {
                    mMap!![WeakReference(key)] = value
                }
            }
        }

        /**          * 获取一个存储的数据          */
        fun get(key: MockThreadLocal<*>): Any? {
            //优先清除一次无用数据,防止内存泄漏
            expungeStaleEntry()
            mMap?.forEach { (k, v) ->
                if (k.get() == key) {
                    return v
                }
            }
            return null
        }

        /**          * 移除一个存储的数据          */
        fun remove(key: MockThreadLocal<*>) {
            //优先清除一次无用数据,防止内存泄漏
            expungeStaleEntry()
            mMap?.forEach { (k, _) ->
                if (k.get() == key) {
                    mMap?.remove(k)
                }
            }
        }

        /**          * 清除key的实际值(MockThreadLocal)已被GC回收的数据,防止内存泄漏          * NOTE:当最后一次MockThreadLocal使用完后,一个好的习惯是主动调用remove方法移除绑定的数据,          * 若不调用,那么本方法将再无机会被调用,依旧有内存泄漏的可能。          */
        private fun expungeStaleEntry() {
            mMap?.forEach { (k, _) ->
                if (k.get() == null) {
                    mMap!!.remove(k)
                }
            }
        }
    }
}

到这里我们的代码就写完了,可以发现ThreadLocal的工作原理,不但没有难度,甚至简单的令人感到意外。需要注意的是源码中ThreadLocalMap没有像我一样直接使用的HashMap,但总体原理思路是一致的,这部分大家可以食用源码来了解

/   测试   /

对我们的『小轮子』进行测试一把,看是否符合我们的预期。我们定义两个MockThreadLocal变量mtl1、mtl2和两个MockThread线程。

测试case如下:

  1. 在线程1中测试mtl1直接调用get方法的结果(预期输出:null)

  2. 在线程1中先调用mtl1.set("二娃_")后,测试mtl1调用get方法的结果(预期输出:二娃_)

  3. 在线程1中先调用mtl1.remove()后,测试mtl1调用get方法的结果(预期输出:null)

  4. 在线程2中测试mtl2直接调用get方法的结果(预期输出:false)

  5. 在线程2中先调用mtl2.set(true)后,测试mtl2调用get方法的结果(预期输出:true)

  6. 在线程1内进行Thread.sleep(200)操作以保证在线程2先执行完的环境下,在线程2中测试mtl1直接调用get方法的结果(预期输出:null)

测试代码如下:

//定义两个MockThreadLocal
val mtl1 = MockThreadLocal<String>()
val mtl2 = object : MockThreadLocal<Boolean>() {
    override fun initialValue(): Boolean? {
        return false
    }
}

//测试按钮点击时执行
btnRun.setOnClickListener {
    val thread1 = MockThread(Runnable {
        val name1 = Thread.currentThread().name

        //mtl1未设置值
        log2Logcat("$name1 mtl1未设置值时:mtl1.get()=${mtl1.get()}")

        //mtl1设置值:二娃_
        mtl1.set("二娃_")
        log2Logcat("$name1 mtl1设置值后:mtl1.get()=${mtl1.get()}")

        Thread.sleep(200)

        //mtl1调用remove
        mtl1.remove()
        log2Logcat("$name1 mtl1调用remove后:mtl1.get()=${mtl1.get()}")

        log2Logcat("$name1 线程运行结束---------------------")
    }, "线程1")

    val thread2 = MockThread(Runnable {
        val name2 = Thread.currentThread().name

        //mtl2未设置值
        log2Logcat("$name2 mtl2未设置值时:mtl2.get()=${mtl2.get()}")

        //mtl2设置值:true
        mtl2.set(true)
        log2Logcat("$name2 mtl2设置值后:mtl2.get()=${mtl2.get()}")

        log2Logcat("$name2 获取mtl1的值:mtl1.get()=${mtl1.get()}")

        log2Logcat("$name2 线程运行结束---------------------")
    }, "线程2")

    thread1.start()
    thread2.start()
}

测试结果如下:

可以看到测试结果都是符合我们预期的,至此本篇的主要工作就结束了,希望大家都能在不用背的前提下掌握了ThreadLocal原理。撒花!撒花!

/   问题解答   /

经过前面的一通操作解答文头的两个问题就是手到擒来的事了。

在Android的handler消息机制中looper是怎么绑定线程的?这里肯定是使用threadLocal的set方法绑定的,系统源码如下:

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

为什么这样做可以达到绑定线程的目的?

这就是ThreadLocal的原理部分,ThreadLocal本就是设置或者获取线程私有数据的辅助类,通过它可以很方便的把数据存储到当前线程内部持有的Map数据结构中。 源码地址:

https://github.com/drawf/SourceSet/blob/master/app/src/main/java/me/erwa/sourceset/framework/threadlocal/MockThreadLocal.kt

喜欢 就关注吧,欢迎投稿!

我来评几句
登录后评论

已发表评论数()

相关站点

热门文章