Android协程高级用法大全

class mainactivity : appcompatactivity() {
    // 生命周期感知协程作用域
    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() // 真正开始执行