fun calculate(a: Int, b: Int): Int = a + b
fun main() {
    val result = calculate(1, 2)
    Log.d("liduo",result)
}

interface Continuation {
    fun next(result: Int)
}

fun calculate(a: Int, b: Int, continuation: Continuation) = 
    continuation.next(a + b)
fun main() {
    calculate(1, 2) { result ->
        Log.d("liduo", result)
    }
}

interface CoroutineContext {
    // 重載"[]"操作
    operator fun <E : Element> get(key: Key<E>): E?
    // 單值歸一化操作
    fun <R> fold(initial: R, operation: (R, Element) -> R): R
    // 重載 "+"操作
    operator fun plus(context: CoroutineContext): CoroutineContext
    // 獲取當前指定key外的其他上下文
    fun minusKey(key: Key<*>): CoroutineContext
    interface Element : CoroutineContext {
        val key: Key<*>
    }
    interface Key<E : Element>
}

interface CoroutineScope {
    // 作用域內(nèi)啟動協(xié)程的默認上下文
    val coroutineContext: CoroutineContext
}

interface Job : CoroutineContext.Element {
    ...
    // 三個狀態(tài)標志
    val isActive: Boolean
    val isCompleted: Boolean
    val isCancelled: Boolean
    // 獲取具體的取消異常
    fun getCancellationException(): CancellationException
    // 啟動協(xié)程
    fun start(): Boolean
    // 取消協(xié)程
    fun cancel(cause: CancellationException? = null)
    ...
    // 等待協(xié)程執(zhí)行結束
    suspend fun join()
    // 用于select語句
    val onJoin: SelectClause0
    // 用于注冊協(xié)程執(zhí)行結束的回調(diào)
    fun invokeOnCompletion(handler: CompletionHandler): DisposableHandle
    ...
}

fun <T> runBlocking(context: CoroutineContext = EmptyCoroutineContext, block: suspend CoroutineScope.() -> T): T

private fun main() {
    // 不指定調(diào)度器，在方法調(diào)用的線程執(zhí)行
    runBlocking {
        // 這里是協(xié)程的作用域
        Log.d("liduo", "123")
    }
}
private fun main() {
    // 指定調(diào)度器，在IO線程中執(zhí)行
    runBlocking(Dispatchers.IO) {
        // 這里是協(xié)程的作用域
        Log.d("liduo", "123")
    }
}

fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job

private fun test() {
    // 作用域為GlobalScope
    // 懶啟動，主線程執(zhí)行
    val job = GlobalScope.launch(
            context = Dispatchers.Main, 
            start = CoroutineStart.LAZY) {
        Log.d("liduo", "123")
    }
    // 啟動協(xié)程
    job.start()
}

fun <T> CoroutineScope.async(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> T
): Deferred<T>

// suspend標記
private suspend fun test(): Int {
    // 作用域為GlobalScope，返回值為Int類型，，泛型可省略，自動推斷
    val deffer = GlobalScope.async<Int> {
        Log.d("liduo", "123")
        // 延時1s
        delay(1000)
        1
    }
    // 獲取返回值
    return deffer.await()
}

private suspend fun test() {
    Log.d("liduo", "123")
}

suspend fun <T> withContext(
    context: CoroutineContext,
    block: suspend CoroutineScope.() -> T
): T

private suspend fun test() {
    // IO線程啟動并執(zhí)行，啟動模式DEFAULT
    GlobalScope.launch(Dispatchers.IO) {
        Log.d("liduo", "start")
        // 線程主切換并掛起，泛型可省略，自動推斷
        val result = withContext<String>(Dispatchers.Main) {
            // 網(wǎng)絡請求
            "json data"
        }
        // 切換回IO線程
        Log.d("liduo", result)
    }
}

inline fun <R> suspend(noinline block: suspend () -> R): suspend () -> R = block

// 返回包含當前的協(xié)程代碼的續(xù)體
val continuation = suspend {
    // 執(zhí)行協(xié)程代碼
    // 泛型可以修改需要的類型
}.createCoroutine(object : Continuation<Any> {
    override val context: CoroutineContext
        get() = EmptyCoroutineContext + Dispatchers.Main
    override fun resumeWith(result: Result<Any>) {
        // 獲取最終結果
    }
})
// 執(zhí)行續(xù)體內(nèi)容
continuation.resume(Unit)

suspend fun main() {
    // 創(chuàng)建
    val channel = Channel<Int>()
    val producer = GlobalScope.launch {
        var i = 0
        while (true){
            // 發(fā)送
            channel.send(i++)
            delay(1000)
            // channel不需要時要及時關閉
            if(i == 10)
                channel.close()
        }
    }
    // 寫法1:常規(guī)
    val consumer = GlobalScope.launch {
        while(true){
            // 接收
            val element = channel.receive()
            Log.d("liduo", "$element")
        }
    }
    // 寫法2:迭代器
    val consumer = GlobalScope.launch {
        val iterator = channel.iterator()
        while(iterator.hasNext()){
            // 接收
            val element = iterator.next()
            Log.d("liduo", "$element")
        }
    }
    // 寫法3:增強for循環(huán)
    val consumer = GlobalScope.launch {
        for(element in channel){
            Log.d("liduo", "$element")
        }
    }
    // 上面的協(xié)程由于不是懶啟動，因此創(chuàng)建完成直接就會start去執(zhí)行
    // 也就是說，代碼走到這里，上面的兩個協(xié)程已經(jīng)開始工作
    // join方法會掛起當前協(xié)程，而不是上面已經(jīng)啟動的兩個協(xié)程
    // 在Android環(huán)境中，下面兩行代碼可以不用添加
    // producer.join()
    // consumer.join()
}

fun <E> Channel(capacity: Int = RENDEZVOUS): Channel<E> =
    when (capacity) {
        RENDEZVOUS -> RendezvousChannel()
        UNLIMITED -> LinkedListChannel()
        CONFLATED -> ConflatedChannel()
        BUFFERED -> ArrayChannel(CHANNEL_DEFAULT_CAPACITY)
        else -> ArrayChannel(capacity)
    }

fun <E> CoroutineScope.produce(
    context: CoroutineContext = EmptyCoroutineContext,
    capacity: Int = 0,
    @BuilderInference block: suspend ProducerScope<E>.() -> Unit
): ReceiveChannel<E>

fun <E> CoroutineScope.actor(
    context: CoroutineContext = EmptyCoroutineContext,
    capacity: Int = 0,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    onCompletion: CompletionHandler? = null,
    block: suspend ActorScope<E>.() -> Unit
): SendChannel<E>

// 啟動協(xié)程，返回一個接收Channel
val receiveChannel: ReceiveChannel<Int> = GlobalScope.produce {
    while(true){
        delay(100)
        // 發(fā)送
        send(1)
    }
}
// 啟動協(xié)程，返回一個發(fā)送Channel
val sendChannel: SendChannel<Int> = GlobalScope.actor<Int> {
    while(true){
        // 接收
        val element = receive()
        Log.d("liduo","$element")
    }
}

fun <E> BroadcastChannel(capacity: Int): BroadcastChannel<E> = 
    when (capacity) {
        0 -> throw IllegalArgumentException("Unsupported 0 capacity for BroadcastChannel")
        UNLIMITED -> throw IllegalArgumentException("Unsupported UNLIMITED capacity for BroadcastChannel")
        CONFLATED -> ConflatedBroadcastChannel()
        BUFFERED -> ArrayBroadcastChannel(CHANNEL_DEFAULT_CAPACITY)
        else -> ArrayBroadcastChannel(capacity)
    }

// 創(chuàng)建BroadcastChannel，容量為5
val broadcastChannel = BroadcastChannel<Int>(5)
// 創(chuàng)建發(fā)送者協(xié)程
GlobalScope.launch {
    // 發(fā)送 1
    broadcastChannel.send(1)
    delay(100)
    // 發(fā)送 2
    broadcastChannel.send(2)
    // 關閉
    broadcastChannel.close()
}.join()
// 創(chuàng)建接收者1協(xié)程
GlobalScope.launch {
    // 獲取ReceiveChannel
    val receiveChannel = broadcastChannel.openSubscription()
    // 接收
    for (element in receiveChannel) {
        Log.d("receiver_1: ", "$element")
    }
}.join()
// 創(chuàng)建接收者2協(xié)程
GlobalScope.launch {
    // 獲取ReceiveChannel
    val receiveChannel = broadcastChannel.openSubscription()
    // 接收
    for (element in receiveChannel) {
        Log.d("receiver_2: ", "$element")
    }
}.join()

val channel = Channel<Int>()
val broadcastChannel = channel.broadcast(10)

suspend inline fun <R> select(crossinline builder: SelectBuilder<R>.() -> Unit): R

private suspend fun test() {
    // 創(chuàng)建一個Channel列表
    val channelList = mutableListOf<Channel<Int>>()
    // 假設其中有5個Channel
    channelList.add(Channel())
    channelList.add(Channel())
    channelList.add(Channel())
    channelList.add(Channel())
    channelList.add(Channel())
    // 調(diào)用select方法，協(xié)程掛起
    val result = select<Int> {
        // 對5個Channel進行注冊監(jiān)聽，等待接收
        channelList.forEach {
            it.onReceive
        }
    }
    // 當5個Channel中任意一個接收到消息時，select掛起恢復
    // 并將返回值賦給result
    Log.d("liduo", "$result")
}

private suspend fun test() {
    // 創(chuàng)建一個可以輸出奇數(shù)的序列，泛型可省略，自動推斷
    val singleNumber = sequence<Int> {
        val i = 0
        while (true) {
            // 在需要輸出的地方調(diào)用yield方法
            yield(2 * i - 1)
        }
    }
    // 調(diào)用迭代器，獲取序列的輸出
    singleNumber.iterator().forEach {
        Log.d("liduo", "$it")
    }
    // 獲取序列前五項，迭代輸出
    singleNumber.take(5).forEach {
        Log.d("liduo", "$it")
    }
}

private suspend fun test() {
    // 創(chuàng)建一個可以輸出奇數(shù)的序列，泛型可省略，自動推斷
    val singleNumber = sequence<Int> {
        yieldAll(listOf(1,3,5,7))
        yieldAll(listOf(9,11,13))
        yieldAll(listOf(15,17))
    }
    // 調(diào)用迭代器，獲取序列的輸出，最多為9項
    singleNumber.iterator().forEach {
        Log.d("liduo", "$it")
    }
    // 獲取序列前五項，迭代輸出
    singleNumber.take(5).forEach {
        // 1，3，5，7，9
        Log.d("liduo", "$it")
    }    
}

// 在主線程上調(diào)用
GlobalScope.launch(Dispatchers.Main) {
    // 創(chuàng)建流
    flow<Int> {
        // 掛起，輸出返回值
        emit(1)
      // 設置流執(zhí)行的線程，并消費流
    }.flowOn(Dispatchers.IO).collect {
            Log.d("liduo", "$it")
        }
}.join()

GlobalScope.launch(Dispatchers.IO) {
    val mFlow = flow<Int> {
        emit(1)
    }.flowOn(Dispatchers.Main)
    mFlow.collect { Log.d("liduo1", "$it") }
    mFlow.collect { Log.d("liduo2", "$it") }
}.join()

flow<Int> {
    emit(1)
    // 拋出異常
    throw NullPointerException()
}.catch { cause: Throwable ->
    Log.d("liduo", "${cause.message}")
}.onCompletion { cause: Throwable? ->
    Log.d("liduo", "${cause?.message}")
}

flow<Int> {
    emit(1)
    // 拋出異常
    throw NullPointerException()
}.catch { cause: Throwable ->
    Log.d("liduo", "${cause.message}")
    emit(-1)
}

// 創(chuàng)建Flow的方法
fun myFlow() = flow<Int> {
    // 生產(chǎn)過程
    emit(1)
}.onEach {
    // 消費過程
    Log.d("liduo", "$it")
}
suspend fun main() {
    // 寫法1
    GlobalScope.launch {
        // 觸發(fā)消費
        myFlow().collect()
    }.join()
    // 寫法2
    myFlow().launchIn(GlobalScope).join()
}

// 實現(xiàn)CoroutineScope接口
class MainActivity : AppCompatActivity(),CoroutineScope by MainScope() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        // 直接啟動協(xié)程
        launch {
            Log.d("liduo", "launch")
        }
    }
    override fun onDestroy() {
        super.onDestroy()
        // 取消頂級父協(xié)程
        cancel()
    }
}

public fun MainScope(): CoroutineScope = ContextScope(SupervisorJob() + Dispatchers.Main)