public interface CoroutineScope {/*** The context of this scope.* Context is encapsulated by the scope and used for implementation of coroutine builders that are extensions on the scope.* Accessing this property in general code is not recommended for any purposes except accessing the [Job] instance for advanced usages.** By convention, should contain an instance of a [job][Job] to enforce structured concurrency.*/public val coroutineContext: CoroutineContext
}

val LifecycleOwner.lifecycleScope: LifecycleCoroutineScopeget() = lifecycle.coroutineScopeval Lifecycle.coroutineScope: LifecycleCoroutineScopeget() {while (true) {val existing = mInternalScopeRef.get() as LifecycleCoroutineScopeImpl?if (existing != null) {return existing}val newScope = LifecycleCoroutineScopeImpl(this,SupervisorJob() + Dispatchers.Main.immediate)if (mInternalScopeRef.compareAndSet(null, newScope)) {newScope.register()return newScope}}}

internal class LifecycleCoroutineScopeImpl(override val lifecycle: Lifecycle,override val coroutineContext: CoroutineContext
) : LifecycleCoroutineScope(), LifecycleEventObserver {init {// in case we are initialized on a non-main thread, make a best effort check before// we return the scope. This is not sync but if developer is launching on a non-main// dispatcher, they cannot be 100% sure anyways.if (lifecycle.currentState == Lifecycle.State.DESTROYED) {coroutineContext.cancel()}}fun register() {// TODO use Main.Immediate once it is graduated out of experimental.launch(Dispatchers.Main) {if (lifecycle.currentState >= Lifecycle.State.INITIALIZED) {lifecycle.addObserver(this@LifecycleCoroutineScopeImpl)} else {coroutineContext.cancel()}}}override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {if (lifecycle.currentState <= Lifecycle.State.DESTROYED) {lifecycle.removeObserver(this)coroutineContext.cancel()}}

coroutineContext.cancel()

public fun CoroutineContext.cancel(): Unit {this[Job]?.cancel()
}

lifecycleScope.launchWhenCreated {  }
lifecycleScope.launchWhenStarted {  }
lifecycleScope.launchWhenResumed {  }

 class MyActivity : AppCompatActivity(), CoroutineScope {lateinit var job: Joboverride val coroutineContext: CoroutineContextget() = Dispatchers.Main + joboverride fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)job = Job()}override fun onDestroy() {super.onDestroy()job.cancel() // Cancel job on activity destroy. After destroy all children jobs will be cancelled automatically}/** Note how coroutine builders are scoped: if activity is destroyed or any of the launched coroutines* in this method throws an exception, then all nested coroutines are cancelled.*/fun loadDataFromUI() = launch { // <- extension on current activity, launched in the main threadval ioData = async(Dispatchers.IO) { // <- extension on launch scope, launched in IO dispatcher// blocking I/O operation}// do something else concurrently with I/Oval data = ioData.await() // wait for result of I/Odraw(data) // can draw in the main thread}}

lifecycleScope.launch {
}

public fun Job(parent: Job? = null): Job = JobImpl(parent)

public val isActive: Boolean
public val isCompleted: Boolean
public val isCancelled: Boolean

while (job.isActive) {
// 协程运行中
}

public fun CoroutineScope.launch(context: CoroutineContext = EmptyCoroutineContext,start: CoroutineStart = CoroutineStart.DEFAULT,block: suspend CoroutineScope.() -> Unit
): Job {...
}

                                        wait children+-----+ start  +--------+ complete   +-------------+  finish  +-----------+| New | -----> | Active | ---------> | Completing  | -------> | Completed |+-----+        +--------+            +-------------+          +-----------+|  cancel / fail       ||     +----------------+|     |V     V+------------+                           finish  +-----------+| Cancelling | --------------------------------> | Cancelled |+------------+                                   +-----------+

val newScope = LifecycleCoroutineScopeImpl(this,SupervisorJob() + Dispatchers.Main
)

fun main() = runBlocking {val supervisor = SupervisorJob()with(CoroutineScope(coroutineContext + supervisor)) {// 启动第一个子作业——这个示例将会忽略它的异常（不要在实践中这么做！）val firstChild = launch(CoroutineExceptionHandler { _, _ ->  }) {println("The first child is failing")throw AssertionError("The first child is cancelled")}// 启动第二个子作业val secondChild = launch {firstChild.join()// 取消了第一个子作业且没有传播给第二个子作业println("The first child is cancelled: ${firstChild.isCancelled}, but the second one is still active")try {delay(Long.MAX_VALUE)} finally {// 但是取消了监督的传播println("The second child is cancelled because the supervisor was cancelled")}}// 等待直到第一个子作业失败且执行完成firstChild.join()println("Cancelling the supervisor")supervisor.cancel()secondChild.join()}
}

public fun invokeOnCompletion(handler: CompletionHandler): DisposableHandlepublic typealias CompletionHandler = (cause: Throwable?) -> Unit

public suspend fun join()