前言
Kotlin是一种在Java虚拟机上运行的静态类型编程语言，被称之为Android世界的Swift，在GoogleI/O2017中，Google宣布Kotlin成为Android官方开发语言
CoroutineScope
当我们创建一个协程的时候，都会需要一个CoroutineScope，它是协程的作用域，我们一般使用它的launch函数以及async函数去进行协程的创建
public fun CoroutineScope.launch(
context: CoroutineContext = EmptyCoroutineContext,
start: CoroutineStart = CoroutineStart.DEFAULT,
block: suspend CoroutineScope.() -> Unit
): Job {
val newContext = newCoroutineContext(context)
val coroutine = if (start.isLazy)
LazyStandaloneCoroutine(newContext, block) else
StandaloneCoroutine(newContext, active = true)
coroutine.start(start, coroutine, block)
return coroutine
}
在 Kotlin中的协程 - CoroutineContext 中我们了解到了，在launch函数中 具有传递上下文的功能，从而生成了Job链让协程之间结构化，并且我们的CoroutineContext也是定义在CoroutineScope当中的
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 [Job] instance for advanced usages.
*
* By convention, should contain an instance of a [job][Job] to enforce structured concurrency.
*/
public val coroutineContext: CoroutineContext
}
常用函数
launch 启动一个协程代码块
async 返回值Deferred，表示一个延期返回的结果
coroutineContext 获取当前的coroutineContext
cancel 取消掉当前Scope所对应的协程
launch函数
launch通常用来创建一个协程，它是CoroutineScope的函数
public fun CoroutineScope.launch(
context: CoroutineContext = EmptyCoroutineContext,
start: CoroutineStart = CoroutineStart.DEFAULT,
block: suspend CoroutineScope.() -> Unit
): Job {
val newContext = newCoroutineContext(context)
val coroutine = if (start.isLazy)
LazyStandaloneCoroutine(newContext, block) else
StandaloneCoroutine(newContext, active = true)
coroutine.start(start, coroutine, block)
return coroutine
}
这个函数主要做了以下几件事情:
- 将传入的
context与当前Scope的context进行运算，生成一个运算之后的context，通过newCoroutineContext函数，这个Context并不是最终协程的Context，而是它的父Context
2.如果是非lazy模式下创建一个Job，它是StandaloneCoroutine的对象，并且在父类AbstractCoroutine中将创建的Job与上面生成的context在进行plus运算，最后才会生成此协程的Context对象
public final override val context: CoroutineContext = parentContext + this
3.然后在start中，将当前协程的Job对象指定为Parent的Job，形成了父子关联，这个操作是在JobSupport的initParentJobInternal函数中实现
internal fun initParentJobInternal(parent: Job?) {
val handle = parent.attachChild(this)
parentHandle = handle
}
整个过程中 Scope的工作，就是将Context进行传递，使协程之间存在父子结构化，使取消事件和异常行为进行关联
取消协程
Scope中也有函数可以对协程进行取消
val scope = object : CoroutineScope {
override val coroutineContext: CoroutineContext = Job()
}
//通过Scope创建一个协程
val job = scope.launch() {
Log.e("Mike", "parent job start ${this.coroutineContext[Job]}")
//通过同样的Scope创建一个协程
val chindJob = scope.launch() {
Log.e("Mike", "child job start ${this.coroutineContext[Job]}")
delay(5000)
Log.e("Mike", "child job end ${this.coroutineContext[Job]}")
}
delay(4000)
Log.e("Mike", "parent job end ${this.coroutineContext[Job]}")
}
Thread.sleep(1000)
job.cancel()
打印结果
parent job start
child job start
五秒后
child job end
上面的代码中，虽然内部的协程时在外部协程中进行创建的，但是内部协程并无法通过Job去进行取消，原因就在于并没有使用到传递的CoroutineScope，使两个Job之间没有结构化关系，所以互不影响
//job.cancel()
scope.cancel()
换成scope中的cancel就可以正常的取消，因为两个协程的Job均是Scope中Job的Child
val job = scope.launch() {
val chindJob = launch() {
delay(5000)
}
delay(4000)
}
Thread.sleep(1000)
job.cancel()
这时候Job之间使用CoroutineScope传递的Context，使Job之间有了关联，所以可以一起取消
MainScope与GlobalScope
GlobalScope中是一个EmptyCoroutineContext,其中并没有Job对象，所以也无法通过GlobalScope去取消关联的协程，所以它是进程级别的Scope
public object GlobalScope : CoroutineScope {
/**
* Returns [EmptyCoroutineContext].
*/
override val coroutineContext: CoroutineContext
get() = EmptyCoroutineContext
}
因为Scope也是通过Job去取消的
public fun CoroutineScope.cancel(cause: CancellationException? = null) {
val job = coroutineContext[Job] ?: error("Scope cannot be cancelled because it does not have a job: $this")
job.cancel(cause)
}
MianScope是由SupervisorJob和主线程调度组成的
public fun MainScope(): CoroutineScope = ContextScope(SupervisorJob() + Dispatchers.Main)
表明是无法被Cancel掉的
private class SupervisorJobImpl(parent: Job?) : JobImpl(parent) {
override fun childCancelled(cause: Throwable): Boolean = false
}
val scope = object : CoroutineScope {
override val coroutineContext: CoroutineContext = Job()
}
scope.launch {
val response = async {
delay(5000)
"response data"
}.await()
Log.e("Mike", "async end")
MainScope().launch {
Log.e("Mike", "MainScope launch ")
}
}
MainScope().cancel()
}
打印结果
5秒后
async end
MainScope launch
欢迎关注Mike的简书
Android 知识整理
