头条Android岗三面：说说ThreadLocal是如何工作的？工作原理是什么？(2)-优快云博客

本文链接：https://blog.youkuaiyun.com/2401_84520377/article/details/138385604

起源

在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 {

/**

往当前线程上绑定数据
*/
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 {

… 省略代码

/**

定义该类，用于实际保存数据、处理数据
/
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)
}
}
}