@SinceKotlin("1.3")
@Suppress("UNCHECKED_CAST")
public fun <R, T> (suspend R.() -> T).startCoroutine(
    作為Receiver
    receiver: R,
    當(dāng)前協(xié)程結(jié)束時(shí)的回調(diào)
    completion: Continuation<T>
) {
    createCoroutineUnintercepted(receiver, completion).intercepted().resume(Unit)
}

startCoroutine實(shí)現(xiàn)
createCoroutineUnintercepted(completion).intercepted().resume(Unit)

mySuspendFunc是一個(gè)suspned函數(shù)
::mySuspendFunc.startCoroutine(object : Continuation<Unit> {
    override val context: CoroutineContext
        get() = EmptyCoroutineContext
    override fun resumeWith(result: Result<Unit>) {
    }
})

val continuation = ::mySuspendFunc.createCoroutine(object :Continuation<Unit>{
    override val context: CoroutineContext
        get() = EmptyCoroutineContext
    override fun resumeWith(result: Result<Unit>) {
        Log.e("hello","當(dāng)前協(xié)程執(zhí)行完成的回調(diào)")
    }
})
continuation.resume(Unit)

class ClassInterceptor() :ContinuationInterceptor {
    override val key = ContinuationInterceptor
    override fun <T> interceptContinuation(continuation: Continuation<T>): Continuation<T> =MyContinuation(continuation)
}
class MyContinuation<T>(private val continuation: Continuation<T>):Continuation<T> by continuation{
    override fun resumeWith(result: Result<T>) {
        Log.e("hello","MyContinuation start ${result.getOrThrow()}")
        continuation.resumeWith(result)
        Log.e("hello","MyContinuation end ")
    }
}

CoroutineScope(Dispatchers.Main).launch {
    val block = async(Dispatchers.IO) {
        // 阻塞的事項(xiàng)
    }
    // 處理其他主線程的事務(wù)
    // 此時(shí)必須需要async的結(jié)果時(shí)，則可通過(guò)await()進(jìn)行獲取
    val result =  block.await()
}

async {
    val result = await {
        suspend 函數(shù)
    }
    消費(fèi)result
}

interface AsyncScope {
    fun myFunc(){
    }
}
fun async(
    context: CoroutineContext = EmptyCoroutineContext,
    block: suspend AsyncScope.() -> Unit
) {
    // 這個(gè)有兩個(gè)作用 1.充當(dāng)receiver 2.completion,接收回調(diào)
    val completion = AsyncStub(context)
    block.startCoroutine(completion, completion)
}
注意這個(gè)類，resumeWith 只會(huì)跟startCoroutine的這個(gè)協(xié)程綁定關(guān)系，跟await的協(xié)程沒(méi)有關(guān)系
class AsyncStub(override val context: CoroutineContext = EmptyCoroutineContext) :
    Continuation<Unit>, AsyncScope {
    override fun resumeWith(result: Result<Unit>) {
        // 這個(gè)是干嘛的 == > 完成的回調(diào)
        Log.e("hello","AsyncStub resumeWith ${Thread.currentThread().id} ${result.getOrThrow()}")
    }
}

await方法里面
suspend fun<T> AsyncScope.await(block:() -> T) = suspendCoroutine<T> {
    // 自定義的Receiver函數(shù)
    myFunc()
    Thread{
         切換線程執(zhí)行await中的方法
        it.resumeWith(Result.success(block()))
    }.start()
}

async {
    val result = await {
        suspend 函數(shù)
    }
    消費(fèi)result
}

public interface ContinuationInterceptor : CoroutineContext.Element
//而CoroutineContext.Element又是繼承于CoroutineContext
CoroutineContext.Element:CoroutineContext

class ClassInterceptor() : ContinuationInterceptor {
    override val key = ContinuationInterceptor
    override fun <T> interceptContinuation(continuation: Continuation<T>): Continuation<T> =
        MyContinuation(continuation)
}
class MyContinuation<T>(private val continuation: Continuation<T>) :
    Continuation<T> by continuation {
    private val handler = Handler(Looper.getMainLooper())
    override fun resumeWith(result: Result<T>) {
        Log.e("hello", "MyContinuation start ${result.getOrThrow()}")
        handler.post {
            continuation.resumeWith(Result.success(自定義內(nèi)容))
        }
        Log.e("hello", "MyContinuation end ")
    }
}

fun async(
    context: CoroutineContext = ClassInterceptor(),
    block: suspend AsyncScope.() -> Unit
) {
    // 這個(gè)有兩個(gè)作用 1.充當(dāng)receiver 2.completion,接收回調(diào)
    val completion = AsyncStub(context)
    block.startCoroutine(completion, completion)
}

async {
    val result = await {
        test()
    }
    Log.e("hello", "result is $result   ${Looper.myLooper() == Looper.getMainLooper()}")
}

class ClassInterceptor() : ContinuationInterceptor {
    override val key = ContinuationInterceptor
    override fun <T> interceptContinuation(continuation: Continuation<T>): Continuation<T> =
        MyContinuation(continuation)
}
class MyContinuation<T>(private val continuation: Continuation<T>) :
    Continuation<T> by continuation {
    private val handler = Handler(Looper.getMainLooper())
    override fun resumeWith(result: Result<T>) {
        Log.e("hello", "MyContinuation start ${result.getOrThrow()}")
        handler.post {
            continuation.resumeWith(Result.success(6 as T))
        }
        Log.e("hello", "MyContinuation end ")
    }
}

interface AsyncScope {
    fun myFunc(){
    }
}
fun async(
    context: CoroutineContext = ClassInterceptor(),
    block: suspend AsyncScope.() -> Unit
) {
    // 這個(gè)有兩個(gè)作用 1.充當(dāng)receiver 2.completion,接收回調(diào)
    val completion = AsyncStub(context)
    block.startCoroutine(completion, completion)
}
class AsyncStub(override val context: CoroutineContext = EmptyCoroutineContext) :
    Continuation<Unit>, AsyncScope {
    override fun resumeWith(result: Result<Unit>) {
        // 這個(gè)是干嘛的 == > 完成的回調(diào)
        Log.e("hello","AsyncStub resumeWith ${Thread.currentThread().id} ${result.getOrThrow()}")
    }
}
suspend fun<T> AsyncScope.await(block:() -> T) = suspendCoroutine<T> {
    myFunc()
    Thread{
        it.resumeWith(Result.success(block()))
    }.start()
}

fun test(): Int {
    Thread.sleep(5000)
    Log.e("hello", "執(zhí)行阻塞函數(shù) test ${Thread.currentThread().id}")
    return 5
}

async {
    val result = await {
        test()
    }
    Log.e("hello", "result is $result   ${Looper.myLooper() == Looper.getMainLooper()}")
}