秀一波多线程的操作技巧，又能 Get 新知识点了
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，但总体原理思路是一致的，这部分大家可以食用源码来了解。
** 04 测试 **
对我们的『小轮子』进行测试一把，看是否符合我们的预期。我们定义两个 MockThreadLocal 变量 mtl1、mtl2 和两个 MockThread 线程。
测试 case 如下：
在线程 1 中测试 mtl1 直接调用 get 方法的结果（预期输出：null）
在线程 1 中先调用 mtl1.set(“二娃_”)后，测试 mtl1 调用 get 方法的结果（预期输出：二娃_）
在线程 1 中先调用 mtl1.remove()后，测试 mtl1 调用 get 方法的结果（预期输出：null）
在线程 2 中测试 mtl2 直接调用 get 方法的结果（预期输出：false）
在线程 2 中先调用 mtl2.set(true)后，测试 mtl2 调用 get 方法的结果（预期输出：true）
在线程 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("{mtl1.get()}")
//mtl1 设置值：二娃_
mtl1.set("二娃_")
log2Logcat("{mtl1.get()}")
Thread.sleep(200)
//mtl1 调用 remove
mtl1.remove()
log2Logcat("{mtl1.get()}")
log2Logcat("$name1 线程运行结束---------------------")
}, "线程 1")
val thread2 = MockThread(Runnable {
val name2 = Thread.currentThread().name
//mtl2 未设置值
log2Logcat("{mtl2.get()}")
//mtl2 设置值：true
mtl2.set(true)
log2Logcat("{mtl2.get()}")
log2Logcat("{mtl1.get()}")
log2Logcat("$name2 线程运行结束---------------------")
}, "线程 2")
thread1.start()
thread2.start()
}
还未添加个人签名 2021.10.31 加入
还未添加个人简介
评论