Kotlin協程上下文與上下文元素深入理解

2022-08-01 18:05:47

一.EmptyCoroutineContext

EmptyCoroutineContext代表空上下文，由於自身為空，因此get方法的返回值是空的，fold方法直接返回傳入的初始值，plus方法也是直接返回傳入的context，minusKey方法返回自身，程式碼如下：

public object EmptyCoroutineContext : CoroutineContext, Serializable {
    private const val serialVersionUID: Long = 0
    private fun readResolve(): Any = EmptyCoroutineContext
    public override fun <E : Element> get(key: Key<E>): E? = null
    public override fun <R> fold(initial: R, operation: (R, Element) -> R): R = initial
    public override fun plus(context: CoroutineContext): CoroutineContext = context
    public override fun minusKey(key: Key<*>): CoroutineContext = this
    public override fun hashCode(): Int = 0
    public override fun toString(): String = "EmptyCoroutineContext"
}

二.CombinedContext

CombinedContext是組合上下文，是儲存Element的重要的資料結構。內部儲存的組織結構如下圖所示：

可以看出CombinedContext是一種左偏(從左向右計算)的列表，這麼設計的目的是為了讓CoroutineContext中的plus方法工作起來更加自然。

由於採用這種資料結構，CombinedContext類中的很多方法都是通過迴圈實現的，程式碼如下：

internal class CombinedContext(
    // 資料結構左邊可能為一個Element物件或者還是一個CombinedContext物件
    private val left: CoroutineContext,
    // 資料結構右邊只能為一個Element物件
    private val element: Element
) : CoroutineContext, Serializable {
    override fun <E : Element> get(key: Key<E>): E? {
        var cur = this
        while (true) {
            // 進行get操作，如果當前CombinedContext物件中存在，則返回
            cur.element[key]?.let { return it }
            // 獲取左邊的上下文物件
            val next = cur.left
            // 如果是CombinedContext物件
            if (next is CombinedContext) {
                // 賦值，繼續迴圈
                cur = next
            } else { // 如果不是CombinedContext物件
                // 進行get操作，返回
                return next[key]
            }
        }
    }
    // 資料結構左右分開操作，從左到右進行fold運算
    public override fun <R> fold(initial: R, operation: (R, Element) -> R): R =
        operation(left.fold(initial, operation), element)
    public override fun minusKey(key: Key<*>): CoroutineContext {
        // 如果右邊是指定的Element物件，則返回左邊
        element[key]?.let { return left }
        // 呼叫左邊的minusKey方法
        val newLeft = left.minusKey(key)
        return when {
            // 這種情況，說明左邊部分已經是去掉指定的Element物件的，右邊也是如此，因此返回當前物件，不需要在進行包裹
            newLeft === left -> this
            // 這種情況，說明左邊部分包含指定的Element物件，因此返回只右邊
            newLeft === EmptyCoroutineContext -> element
            // 這種情況，返回的左邊部分是新的，因此需要和右邊部分一起包裹後，再返回
            else -> CombinedContext(newLeft, element)
        }
    }
    private fun size(): Int {
        var cur = this
        //左右各一個
        var size = 2
        while (true) {
            cur = cur.left as? CombinedContext ?: return size
            size++
        }
    }
    // 通過get方法實現
    private fun contains(element: Element): Boolean =
        get(element.key) == element
    private fun containsAll(context: CombinedContext): Boolean {
        var cur = context
        // 迴圈展開每一個CombinedContext物件，每個CombinedContext物件中的Element物件都要包含
        while (true) {
            if (!contains(cur.element)) return false
            val next = cur.left
            if (next is CombinedContext) {
                cur = next
            } else {
                return contains(next as Element)
            }
        }
    }
    ...
}

三.Key與Element

Key介面與Element介面定義在CoroutineContext介面中，程式碼如下：

public interface Key<E : Element>
public interface Element : CoroutineContext {
    // 一個Key對應著一個Element物件
    public val key: Key<*>
    // 相等則強制轉換並返回，否則則返回空
    public override operator fun <E : Element> get(key: Key<E>): E? =
        @Suppress("UNCHECKED_CAST")
        if (this.key == key) this as E else null
    // 自身與初始值進行fold操作
    public override fun <R> fold(initial: R, operation: (R, Element) -> R): R =
        operation(initial, this)
    // 如果要去除的是當前的Element物件，則返回空的上下文，否則返回自身
    public override fun minusKey(key: Key<*>): CoroutineContext =
        if (this.key == key) EmptyCoroutineContext else this
}

四.CoroutineContext

CoroutineContext介面定義了協程上下文的基本行為以及Key和Element介面。同時，過載了"+"操作，相關程式碼如下：

public interface CoroutineContext {
    public operator fun <E : Element> get(key: Key<E>): E?
    public fun <R> fold(initial: R, operation: (R, Element) -> R): R
    public operator fun plus(context: CoroutineContext): CoroutineContext =
        // 如果要與空上下文相加，則直接但會當前物件，
        if (context === EmptyCoroutineContext) this else
            // 當前Element作為初始值
            context.fold(this) { acc, element ->
                // acc:已經加完的CoroutineContext物件
                // element:當前要加的CoroutineContext物件
                // 獲取從acc中去掉element後的上下文removed，這步是為了確保新增重複的Element時，移動到最右側
                val removed = acc.minusKey(element.key)
                // 去除掉element後為空上下文(說明acc中只有一個Element物件)，則返回element
                if (removed === EmptyCoroutineContext) element else {
                    // ContinuationInterceptor代表攔截器，也是一個Element物件
                    // 下面的操作是為了把攔截器移動到上下文的最右端，為了方便快速獲取
                    // 從removed中獲取攔截器
                    val interceptor = removed[ContinuationInterceptor]
                    // 若上下文中沒有攔截器，則進行累加(包裹成CombinedContext物件)，返回
                    if (interceptor == null) CombinedContext(removed, element) else {
                        // 若上下文中有攔截器
                        // 獲取上下文中移除到掉攔截器後的上下文left
                        val left = removed.minusKey(ContinuationInterceptor)
                        // 若移除到掉攔截器後的上下文為空上下文，說明上下文left中只有一個攔截器，
                        // 則進行累加(包裹成CombinedContext物件)，返回
                        if (left === EmptyCoroutineContext) CombinedContext(element, interceptor) else
                            // 否則，現對當前要加的element和left進行累加，然後在和攔截器進行累加
                            CombinedContext(CombinedContext(left, element), interceptor)
                    }
                }
            }
    public fun minusKey(key: Key<*>): CoroutineContext
    ... // (Key和Element介面)
}

1.plus方法圖解

假設我們有一個上下文順序為A、B、C，現在要按順序加上D、C、A。

1）初始值A、B、C

2）加上D

3）加上C

4）加上A

2.為什麼要將ContinuationInterceptor放到協程上下文的最右端？

在協程中有大量的場景需要獲取ContinuationInterceptor。根據之前分析的CombinedContext的minusKey方法，ContinuationInterceptor放在上下文的最右端，可以直接獲取，不需要經過多次的迴圈。

五.AbstractCoroutineContextKey與AbstractCoroutineContextElement

AbstractCoroutineContextElement實現了Element介面，將Key物件作為構造方法必要的引數。

public abstract class AbstractCoroutineContextElement(public override val key: Key<*>) : Element

AbstractCoroutineContextKey用於實現Element的多型。什麼是Element的多型呢？假設類A實現了Element介面，Key為A。類B繼承自類A，Key為B。這時將類B的物件新增到上下文中，通過指定不同的Key(A或B)，可以得到不同型別物件。具體程式碼如下：

// baseKey為衍生類的基礎類別的Key
// safeCast用於對基礎類別進行轉換
// B為基礎類別，E為衍生類
public abstract class AbstractCoroutineContextKey<B : Element, E : B>(
    baseKey: Key<B>,
    private val safeCast: (element: Element) -> E?
) : Key<E> {
    // 頂置Key，如果baseKey是AbstractCoroutineContextKey，則獲取baseKey的頂置Key
    private val topmostKey: Key<*> = if (baseKey is AbstractCoroutineContextKey<*, *>) baseKey.topmostKey else baseKey
    // 用於型別轉換
    internal fun tryCast(element: Element): E? = safeCast(element)
    // 用於判斷當前key是否是指定key的子key
    // 邏輯為與當前key相同，或者與當前key的頂置key相同
    internal fun isSubKey(key: Key<*>): Boolean = key === this || topmostKey === key
}

getPolymorphicElement方法與minusPolymorphicKey方法

如果衍生類使用了AbstractCoroutineContextKey，那麼基礎類別在實現Element介面中的get方法時，就需要通過getPolymorphicElement方法，實現minusKey方法時，就需要通過minusPolymorphicKey方法，程式碼如下：

public fun <E : Element> Element.getPolymorphicElement(key: Key<E>): E? {
    // 如果key是AbstractCoroutineContextKey
    if (key is AbstractCoroutineContextKey<*, *>) {
        // 如果key是當前key的子key，則基礎類別強制轉換成衍生類，並返回
        @Suppress("UNCHECKED_CAST")
        return if (key.isSubKey(this.key)) key.tryCast(this) as? E else null
    }
    // 如果key不是AbstractCoroutineContextKey
    // 如果key相等，則強制轉換，並返回
    @Suppress("UNCHECKED_CAST")
    return if (this.key === key) this as E else null
}

public fun Element.minusPolymorphicKey(key: Key<*>): CoroutineContext {
    // 如果key是AbstractCoroutineContextKey
    if (key is AbstractCoroutineContextKey<*, *>) {
        // 如果key是當前key的子key，基礎類別強制轉換後不為空，說明當前Element需要去掉，因此返回空上下文，否則返回自身
        return if (key.isSubKey(this.key) && key.tryCast(this) != null) EmptyCoroutineContext else this
    }
    // 如果key不是AbstractCoroutineContextKey
    // 如果key相等，說明當前Element需要去掉，因此返回空上下文，否則返回自身
    return if (this.key === key) EmptyCoroutineContext else this
}

到此這篇關於Kotlin協程上下文與上下文元素深入理解的文章就介紹到這了,更多相關Kotlin上下文內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！