Android-重学kotlin(协程基础)新学习总结

• isActive：判断协程是否处于活跃状态
• isCompleted：判断协程是否已完成（正常结束或异常结束）
• isCancelled：判断协程是否已被取消

操作协程状态：

可以通过job.cancel()方法取消协程，也可以使用withTimeout等快捷函数设置超时。

当一个协程在另一个协程的作用域内启动时，它们会建立父子关系。父协程会等待所有子协程完成后才会结束。

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        try {
            println("协程启动，开始执行长时间任务")
            repeat(1000) { i ->
                println("正在执行任务 $i")
                delay(500)
            }
        } finally {
            // 即使协程被取消，finally块中的代码也会执行
            println("协程被取消，执行清理工作")
        }
    }

    delay(1600) // 等待一段时间后取消协程
    println("准备取消协程")
    job.cancel()
    println("已调用取消方法，Job状态: active=${job.isActive}, completed=${job.isCompleted}, cancelled=${job.isCancelled}")
    job.join() // 等待协程彻底完成（包括finally块）
    println("协程最终状态: active=${job.isActive}, completed=${job.isCompleted}, cancelled=${job.isCancelled}")
}




import kotlinx.coroutines.*

fun main() = runBlocking {
    val parentJob = launch {
        println("父协程启动")
        
        val childJob1 = launch {
            println("子协程1启动")
            delay(2000)
            println("子协程1完成")
        }
        
        val childJob2 = launch {
            println("子协程2启动")
            delay(1000)
            println("子协程2完成")
        }
        
        println("父协程继续执行其他任务")
        delay(500)
        println("父协程即将结束")
    }

    println("主线程等待父协程完成")
    parentJob.join()
    println("父协程完成，主线程继续执行")
}

结构化并发的本质是：协程的生命周期与创建它的作用域绑定。这种绑定通过 Job 的父子关系实现，主要规则如下：

1. 父子关系的建立：

   • 在一个协程作用域内启动的子协程，会自动成为该作用域协程的子 Job。
   • 父 Job 会等待所有子 Job 完成后才能结束。
   • 父 Job 被取消时，所有子 Job 会被递归取消。

2. 生命周期管理：

   • 完成规则：父 Job 只有在所有子 Job 成功完成后才算完成。
   • 取消规则：父 Job 被取消或异常结束时，所有子 Job 会被立即取消。

3. 异常传播：

   • 默认情况下，子 Job 的异常会导致父 Job 取消，进而取消所有其他子 Job（类似 coroutineScope 的行为）。

并行任务：同时加载多个数据源

suspend fun loadUserData(): UserData = coroutineScope {
    // 并行启动两个异步任务
    val userDeferred = async { apiService.getUser() }
    val settingsDeferred = async { apiService.getSettings() }
    
    // 等待所有任务完成并组合结果
    UserData(
        user = userDeferred.await(),
        settings = settingsDeferred.await()
    )
}

独立任务：互不影响的并行操作

lifecycleScope.launch {
    supervisorScope {
        // 这些任务独立运行，一个失败不会影响其他
        launch { loadImage() }
        launch { loadText() }
        launch { loadComments() }
    }
}

5.Job的继承（Deferred）

        在 Kotlin 协程中，Deferred<T> 是 Job 的子接口，代表一个异步计算的结果，而 await() 方法则用于获取这个结果。

await() 是 Deferred<T> 的核心方法，主要功能：

• 挂起协程：调用 await() 会挂起当前协程，直到 Deferred 完成（成功或失败）。
• 返回结果：如果 Deferred 成功完成，返回计算结果 T。
• 传播异常：如果 Deferred 因异常取消，await() 会抛出相同的异常。

await() 的工作原理

await() 的核心逻辑可以简化为以下步骤：

1. 检查状态：

   1. 如果 Deferred 已完成（成功或失败），直接返回结果或抛出异常。
   2. 如果 Deferred 未完成，挂起当前协程。

2. 注册回调：

   1. 将当前协程的续体（Continuation）注册到 Deferred 的完成回调中。

3. 恢复执行：

   1. 当 Deferred 完成时（无论是正常结束还是异常取消），触发回调，恢复挂起的协程。
   2. 如果成功，将结果传递给续体；如果失败，抛出异常。

6.SupervisorJob

public
fun
SupervisorJob(parent:
Job?
=
null)
:
CompletableJob





















=
SupervisorJobImpl(parent)
public
interface
CompletableJob
:
Job
{




public
fun
complete():
Boolean




public
fun
completeExceptionally(exception:
Throwable):
Boolean
}

//
代码段3
val
user
=
getUserInfo()
val
friendList
=
getFriendList(user)
val
feedList
=
getFeedList(friendList)