kotlin 协程方法总结

Kotlin 协程是一套强大的异步编程工具,以下是对 Kotlin 协程常用方法的总结:

1. 协程构建器

  • launch: 启动一个新的协程,不阻塞当前线程,返回一个 Job 对象。

    GlobalScope.launch {
    // 协程体
    }

  • async: 启动一个新的协程并返回一个 Deferred 对象,可以用来获取协程的结果。

    val deferred = GlobalScope.async {
    // 协程体
    "Result"
    }
    val result = deferred.await() // 获取结果

2. 协程作用域

GlobalScope: 全局作用域,不受任何生命周期限制。

  GlobalScope.launch {
      // 协程体
  }
  • CoroutineScope: 自定义作用域,可以与特定的生命周期绑定。

    val scope = CoroutineScope(Dispatchers.Main)
    scope.launch {
        // 协程体
    }
    
  • lifecycleScope (Android): 与 Activity 或 Fragment 的生命周期绑定。

    lifecycleScope.launch {
        // 协程体
    }
    
  • viewModelScope (Android): 与 ViewModel 的生命周期绑定。

    viewModelScope.launch {
        // 协程体
    }
    

3. 协程调度器

Dispatchers.Main: 主线程调度器,用于 UI 操作。

  withContext(Dispatchers.Main) {
      // UI 操作
  }
  • Dispatchers.IO: I/O 调度器,用于 I/O 操作。

    withContext(Dispatchers.IO) {
        // I/O 操作
    }
    
  • Dispatchers.Default: 默认调度器,用于 CPU 密集型任务。

    withContext(Dispatchers.Default) {
        // CPU 密集型任务
    }
    
  • Dispatchers.Unconfined: 不受限调度器,不固定在任何线程上。

    withContext(Dispatchers.Unconfined) {
        // 不受限任务
    }
    

4. 挂起函数

suspend: 标记一个函数为挂起函数,可以在协程中使用。

  suspend fun fetchData(): String {
      // 异步操作
      return "Data"
  }
  • withContext: 在指定的调度器中执行代码块,并返回结果。

    val result = withContext(Dispatchers.IO) {
        // 异步操作
        "Data"
    }
    
  • delay: 挂起当前协程一段时间,不阻塞线程。

         delay(1000) // 挂起 1 秒
    

5. 协程控制

  • Job: 表示一个协程的执行状态,可以用来取消或等待协程。

    val job = GlobalScope.launch {
    // 协程体
    }
    job.cancel() // 取消协程
    job.join() // 等待协程完成

  • CoroutineExceptionHandler: 处理协程中的未捕获异常。

    val handler = CoroutineExceptionHandler { _, exception ->
    Log.e("Coroutine", "Exception: ${exception.message}")
    }
    GlobalScope.launch(handler) {
    // 协程体
    }

6.并发控制

  • async + await: 并发执行多个任务并等待所有任务完成。

    val deferred1 = GlobalScope.async {
        // 任务 1
        "Result 1"
    }
    val deferred2 = GlobalScope.async {
        // 任务 2
        "Result 2"
    }
    val result1 = deferred1.await()
    val result2 = deferred2.await()
    
  • supervisorScope: 创建一个监督作用域,子协程的失败不会导致父协程取消。

    supervisorScope {
        val job1 = launch {
            // 任务 1
        }
        val job2 = launch {
            // 任务 2
        }
    }
    

7.测试

  • runBlocking: 用于测试协程,阻塞当前线程直到所有子协程完成。

    runBlocking {
        // 协程体
    }
    
  • TestCoroutineDispatcher: 用于单元测试的调度器。

    val testDispatcher = TestCoroutineDispatcher()
    runBlocking(testDispatcher) {
        // 协程体
    }
    

以上是 Kotlin 协程的一些常用方法和概念,希望对你有所帮助。