class MainActivity : AppCompatActivity() {
    // 生命周期感知協(xié)程作用域
    private val scope = lifecycleScope
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        scope.launch {
            val data = fetchData()
            updateUI(data)
        }
    }
}

private val customScope = CoroutineScope(Dispatchers.IO + SupervisorJob())

val result1 = async { fetchData1() }.await()
val result2 = async { fetchData2() }.await()
val finalResult = combine(result1, result2)

val deferred1 = async { fetchData1() }
val deferred2 = async { fetchData2() }
val result1 = deferred1.await()
val result2 = deferred2.await()

val results = awaitAll(
    async { fetchData1() },
    async { fetchData2() },
    async { fetchData3() }
)

scope.launch {
    try {
        val result = fetchData()
    } catch (e: IOException) {
        handleError(e)
    }
}

val handler = CoroutineExceptionHandler { _, exception ->
    Log.e("Coroutine", "Caught $exception")
}
scope.launch(handler) {
    val result = fetchData()
}

val supervisor = SupervisorJob()
val scope = CoroutineScope(Dispatchers.IO + supervisor)

scope.launch(Dispatchers.IO) {
    val data = fetchData()
    withContext(Dispatchers.Main) {
        updateUI(data)
    }
}

try {
    withTimeout(3000L) {
        fetchData()
    }
} catch (e: TimeoutCancellationException) {
    Log.e("Coroutine", "Timeout")
}

val job = scope.launch {
    fetchData()
}
job.cancel() // 立即取消

for (i in 1..1000) {
    if (!isActive) break
    doWork()
}

val channel = Channel<Int>()
scope.launch {
    for (i in 1..5) channel.send(i)
    channel.close()
}
scope.launch {
    for (i in channel) {
        println(i)
    }
}

fun fetchNumbers(): Flow<Int> = flow {
    for (i in 1..5) {
        delay(100)
        emit(i)
    }
}
scope.launch {
    fetchNumbers()
        .map { it * 2 }
        .filter { it > 5 }
        .collect { println(it) }
}

val flow1 = flow { emit(fetchData1()) }
val flow2 = flow { emit(fetchData2()) }
flow1.combine(flow2) { d1, d2 -> d1 + d2 }
    .collect { println(it) }

val deferred = async(start = CoroutineStart.LAZY) { fetchData() }
deferred.await() // 真正開始執(zhí)行