Android协程的7个重要知识点汇总

import kotlinx.coroutines.*
fun main() {
    // 创建协程
    val job = GlobalScope.launch {
        // 协程代码块
        delay(1000)
        println("Hello from Coroutine!")
    }
    // 等待协程完成
    runBlocking {
        job.join()
    }
}

import kotlinx.coroutines.*
fun main() = runBlocking {
    val job = launch {
        try {
            delay(1000)
            println("Coroutine completed.")
        } catch (e: CancellationException) {
            println("Coroutine was cancelled.")
        }
    }
    delay(500)
    job.cancel() // 取消协程
    job.join()
}

import kotlinx.coroutines.*
fun main() = runBlocking {
    val job = launch {
        try {
            throw Exception("Something went wrong")
        } catch (e: Exception) {
            println("Exception caught: ${e.message}")
        }
    }
    job.join()
}

launch(Dispatchers.IO) {
    // 在IO线程上执行协程代码，适用于网络请求和文件操作
}
launch(Dispatchers.Default) {
    // 在默认的线程池上执行协程代码，适用于CPU密集型操作
}

launch {
    val result = withContext(Dispatchers.IO) {
        // 在IO线程上执行异步操作
    }
    // 在UI线程处理结果
}

val customDispatcher = Executors.newFixedThreadPool(4).asCoroutineDispatcher()
launch(customDispatcher) {
    // 在自定义调度器上执行协程代码
}

suspend fun fetchUserData(): UserData {
    // 执行异步操作，等待数据返回
}

launch {
    val userData = fetchUserData()
    // 处理获取到的用户数据
}

launch {
    try {
        val userData = fetchUserData()
        // 处理获取到的用户数据
    } catch (e: Exception) {
        // 处理异常情况
    }
}

launch {
    try {
        val userData = fetchUserData()
        // 处理获取到的用户数据
    } catch (e: CancellationException) {
        // 协程被取消时的处理
    } catch (e: Exception) {
        // 其他异常情况
    }
}

suspend fun performMultipleTasks() = coroutineScope {
    val result1 = async { fetchFromNetwork() }
    val result2 = async { fetchFromDatabase() }
    val combinedResult = result1.await() + result2.await()
    // 处理并发任务的结果
}

class MyActivity : AppCompatActivity(), CoroutineScope by CoroutineScope(Dispatchers.Main) {
    // ...
    override fun onDestroy() {
        super.onDestroy()
        cancel() // 取消协程作用域内的所有协程
    }
}

launch {
    // 在协程作用域内启动协程
    // 该协程将继承外部作用域的上下文和调度器
}

class MyActivity : AppCompatActivity(), CoroutineScope by CoroutineScope(Dispatchers.Main) {
    // ...
    fun performMultipleTasks() = launch {
        // 在外部作用域的协程内启动协程
        launch {
            // 在内部作用域的协程内启动协程
        }
    }
}

runBlocking {
    // 在结构化并发作用域内启动协程
    launch {
        // 协程1
    }
    launch {
        // 协程2
    }
    // 等待所有协程完成后继续
}

launch {
    val result1 = async { fetchFromNetwork() }
    val result2 = async { fetchFromDatabase() }
    val combinedResult = result1.await() + result2.await()
    // 处理并发任务的结果
}

launch {
    val dataFromDatabase = async { fetchFromDatabase() }.await()
    val updatedData = async { performNetworkRequest(dataFromDatabase) }.await()
    // 处理顺序性操作的结果
}

runBlocking {
    val result = withContext(Dispatchers.IO) {
        val dataFromDatabase = async { fetchFromDatabase() }.await()
        val updatedData = async { performNetworkRequest(dataFromDatabase) }.await()
        // 更多操作...
        updatedData
    }
    // 处理组合多个协程流程的结果
}

runBlocking {
    val result = withContext(Dispatchers.IO) {
        fetchFromDatabaseAsync()
            .then { dataFromDatabase -> performNetworkRequestAsync(dataFromDatabase) }
            .then { updatedData -> performAdditionalOperationAsync(updatedData) }
            .await()
    }
    // 处理异步风格顺序性操作的结果
}

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val channel = Channel<Int>()
    launch {
        for (i in 1..5) {
            channel.send(i)
        }
        channel.close()
    }
    launch {
        for (item in channel) {
            println("Received: $item")
        }
    }
}

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val channel = Channel<Unit>()
    val job = launch {
        // 等待特定的信号
        channel.receive()
        println("Coroutine received signal.")
    }
    delay(1000)
    channel.send(Unit) // 发送信号给协程
    job.join()
}

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val producer: Job = launch {
        val channel = Channel<Int>()
        // 扇出模式
        launch {
            for (i in 1..5) {
                channel.send(i)
            }
            channel.close()
        }
        // 扇入模式
        launch {
            for (item in channel) {
                println("Received: $item")
            }
        }
    }
    producer.join()
}

import kotlinx.coroutines.*
import kotlin.coroutines.CoroutineContext
class MainActivity : AppCompatActivity() {
    private val mainScope = MainScope()
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        mainScope.launch {
            // 在UI线程中启动协程
            val result = withContext(Dispatchers.IO) {
                // 执行异步操作，例如网络请求
            }
            updateUI(result)
        }
    }
    override fun onDestroy() {
        super.onDestroy()
        mainScope.cancel() // 取消协程，避免资源泄漏
    }
    private fun updateUI(data: Any) {
        // 更新UI界面
    }
}

class MyViewModel : ViewModel() {
    fun performAsyncTask() {
        viewModelScope.launch {
            // 在UI线程中启动协程
            val result = withContext(Dispatchers.IO) {
                // 执行异步操作，例如网络请求
            }
            // 更新UI界面
        }
    }
}

class MyViewModel : ViewModel() {
    val dataLiveData: LiveData<ResultType> = liveData {
        val result = fetchData()
        emit(result)
    }
}