kotlin協(xié)程的啟動模式 (枚舉類CoroutineStart)
CoroutineStart.DEFAULT
*Default——根據(jù)協(xié)程的上下文立即調(diào)度協(xié)程執(zhí)行早歇。* *如果coroutine上下文的[CoroutineDispatcher]從[CoroutineDispatcher]返回' true '膀曾。和大多數(shù)調(diào)度程序一樣，
isdispatchrequired]
*函數(shù)的作用是:然后將協(xié)調(diào)程序代碼分派給以后執(zhí)行冻晤，而調(diào)用協(xié)調(diào)程序構(gòu)建器的代碼將繼續(xù)執(zhí)行。
* *注意[調(diào)度員腋逆。unrestricted總是從它的[CoroutineDispatcher]返回' false '慕嚷。函數(shù)，因此使用[Dispatchers啟動一個協(xié)程非迹。默認情況下unrestricted和使用un分派是一樣的环鲤。
* *如果coroutine [Job]在有機會開始執(zhí)行之前就被取消了，那么它根本不會開始它的
*執(zhí)行憎兽，而是會在異常情況下完成冷离。協(xié)調(diào)程序在掛起點的可取消性取決于
*掛起函數(shù)的特定實現(xiàn)細節(jié)。使用
[suspend endcancellablecoroutine]實現(xiàn)可取消的掛起函數(shù)纯命。
CoroutineStart.LAZY
只有在需要時才懶洋洋地啟動協(xié)同程序西剥。
*
*有關(guān)詳細信息，請參閱相應(yīng)的協(xié)程構(gòu)建器的文檔
*(如[發(fā)射][CoroutineScope亿汞。發(fā)射]和[異步][CoroutineScope.async])瞭空。
*
*如果coroutine [Job]在有機會開始執(zhí)行之前就被取消了，那么它將不會開始執(zhí)行
*完全執(zhí)行疗我，但會在例外情況下完成咆畏。
CoroutineStart.ATOMIC 1.3.31以前試驗階段
自動(即。吴裤，以不可取消的方式)根據(jù)協(xié)程的上下文安排協(xié)程的執(zhí)行旧找。
*這類似于[默認值]，但是協(xié)程在開始執(zhí)行之前不能被取消嚼摩。
*
*協(xié)調(diào)程序在暫停點的可取消性取決于特定的實現(xiàn)細節(jié)
*暫停函數(shù)钦讳，如[默認]矿瘦。
CoroutineStart.UNDISPATCHED 1.3.31以前試驗階段
立即執(zhí)行協(xié)程，直到它的第一個掛起點_in current thread_愿卒，就像
*協(xié)同程序使用[dispatcher . unrestricted]啟動缚去。但是，當協(xié)程從暫停狀態(tài)恢復(fù)時
*根據(jù)上下文中的[CoroutineDispatcher]進行調(diào)度琼开。
*
*這與[ATOMIC]類似易结，在某種意義上，協(xié)程開始執(zhí)行柜候，即使它已經(jīng)被取消搞动，
但是不同的是，它開始在同一個線程中執(zhí)行渣刷。
*
*協(xié)調(diào)程序在暫停點的可取消性取決于特定的實現(xiàn)細節(jié)
*暫停函數(shù)鹦肿，如[默認]。
*
** *注意:這是一個實驗性的api辅柴。在未來使用這種模式時箩溃，協(xié)程的執(zhí)行語義可能會發(fā)生變化。
job.join() 等待job執(zhí)行完, 再執(zhí)行后面的代碼
CoroutineStar.DEFAULT模式(如果啟動之前cancel, 協(xié)程里面的代碼執(zhí)行不到)
fun main() = runBlocking {
val job: Job = GlobalScope.launch(start = CoroutineStart.DEFAULT) {
println("1")
delay(1000L)
println("2")
}
// job.start()
// job.join()
println("3")
delay(2000L)//為了保證結(jié)果都能打印, 因為外面的協(xié)程1, 不會等待里面的協(xié)程2執(zhí)行完.
}
打印結(jié)果, 不加delay(2000L)時:
3
1
打印結(jié)果, 加上delay(2000L)時:
3
1
2
CoroutineStart.LAZY模式
fun main() = runBlocking {//協(xié)程1
val job: Job = GlobalScope.launch(start = CoroutineStart.LAZY) {//協(xié)程2
println("1")
delay(1000L)
println("2")
}
job.start()
job.join() //等待job執(zhí)行完, 再執(zhí)行后面的代碼
println("3")
}
打印結(jié)果如下:
1
2
3
Deferred
private suspend fun test2() {
val deferred1 = GlobalScope.async<Int>(start = CoroutineStart.LAZY) {
delay(1000L)
println("計算")
2
}
val deferred2 = GlobalScope.async<Int>(start = CoroutineStart.LAZY) {
delay(1000L)
println("計算2")
3
}
val num = deferred1.await() + deferred2.await()//等待deferred1和deferred2兩個協(xié)程執(zhí)行完
println(num)
}
CoroutineStart.DEFAULT和CoroutineStart.ATOMIC區(qū)別
suspend fun test3() {
val job = GlobalScope.launch (start = CoroutineStart.DEFAULT){
println("1")
delay(1000L)
println("2")
}
//默認模式 如果執(zhí)行之前被取消, 里面的內(nèi)容可能執(zhí)行不到
job.cancel()
println("3")
val job2 = GlobalScope.launch (start = CoroutineStart.ATOMIC){
println("4")
//第一個掛起點
delay(1000L)
println("5")
}
//自動模式 如果只要執(zhí)行了, 在第一個掛起點取消才會生效, 也就是4一定會被打印
job2.cancel()
println("6")
}
CoroutineStart.UNDISPATCHERED模式
fun main() = runBlocking<Unit> {
test4()
}
suspend fun test4() {
//默認和父協(xié)程在同一個線程
val job = GlobalScope.launch(start = CoroutineStart.UNDISPATCHED){
println("1")
delay(1000)
println("2")
}
println("5")
//等待job執(zhí)行完成, 再執(zhí)行后面的邏輯
job.join()
}
協(xié)程的調(diào)度
協(xié)程調(diào)度器類型
2019-06-02 at 1.58 PM.png
協(xié)程調(diào)度器實際上是一個協(xié)程攔截器
2019-06-02 at 1.51 PM.png
自定義ContinuationInterceptor和Continuation
fun log(str:String){
println("${Thread.currentThread().name}, $str")
}
suspend fun main() {
val job = GlobalScope.launch(MyContinuationInterceptor() + CoroutineName("HelloWorld")) {
log("1")
delay(1000L)
log("2")
}
job.join()
}
class MyContinuationInterceptor : ContinuationInterceptor {
//ContinuationInterceptor 是ContinuationInterceptor類中的伴生對象
override val key: CoroutineContext.Key<*> = ContinuationInterceptor
override fun <T> interceptContinuation(continuation: Continuation<T>): Continuation<T> {
return MyContinuation(continuation)
}
}
class MyContinuation<T>(private val continuation: Continuation<T>) : Continuation<T> {
override val context: CoroutineContext = continuation.context
private val executor = Executors.newSingleThreadExecutor{ it ->
Thread(it, "MyThreadExecutor").also { it.isDaemon = true }
}
override fun resumeWith(result: Result<T>) {
executor.submit {
log("Before...")
continuation.resumeWith(result)
log("After...")
}
}
}
打印結(jié)果:
MyThreadExecutor, Before...
MyThreadExecutor, 1
MyThreadExecutor, After...
MyThreadExecutor, Before...
MyThreadExecutor, 2
MyThreadExecutor, After...
協(xié)程的異常處理
協(xié)程的異常處理
fun main() = runBlocking<Unit> {
test11()
test22()
test33()
}
private suspend fun test33() {
GlobalScope.launch {
val job = launch {
val num = 3 / 0 //此處發(fā)生了異常, 導(dǎo)致父協(xié)程被取消, 從而引起job.join()觸發(fā)已經(jīng)被取消異常
delay(1000L)
}
try {
job.join()
} catch (e: Exception) {//已經(jīng)被取消異常
println("test33: $e.localizedMessage")
}
}.join()
}
private suspend fun test22() {
val deferred = GlobalScope.async {//async自己會捕獲內(nèi)部的異常
val num = 2 / 0
delay(1000L)
3
}
try {
val i = deferred.await()
} catch (e: Exception) {
println("test22: $e.localizedMessage")
}
}
private suspend fun test11() {
val job = GlobalScope.launch(CoroutineExceptionHandler { _, throwable ->
println("test11: $throwable.localizedMessage")
}) {//launch 自己不會捕獲內(nèi)部異常
val num = 3 / 0
delay(1000L)
}
job.join()
}
協(xié)程的異常處理2
val demo = Demo1()
fun main() = runBlocking<Unit> {
demo.test()
}
class Demo1 {
fun test() = runBlocking {
GlobalScope.launch(CoroutineExceptionHandler { _, throwable ->
println("#1 ${throwable.localizedMessage}")
}) {
println("1")
val job = launch(CoroutineExceptionHandler { _, throwable ->
println("#2 ${throwable.localizedMessage}")
}) {
println("2")
val num = 2 / 0
println("2 after...")
}
println("3")
job.join()
println("4")
}.join()
}
}
打印結(jié)果:
1
3
2
#1 / by zero
異常被父協(xié)程捕獲, 異常層層向上傳遞
使用suspervisorScope{}包裹子協(xié)程, 子協(xié)程自己捕獲異常
val demo = Demo1()
fun main() = runBlocking<Unit> {
demo.test2()
}
class Demo1 {
fun test2() = runBlocking {
GlobalScope.launch(CoroutineExceptionHandler { _, throwable ->
println("#1 ${throwable.localizedMessage}")
}) {
println("1")
supervisorScope {//不想外部傳遞異常, 但是外部父協(xié)程可以取消此\job
val job = launch(CoroutineExceptionHandler { _, throwable ->
println("#2 ${throwable.localizedMessage}")
}) {
println("2")
val num = 2 / 0
println("2 after...")
}
}
println("3")
}.join()
}
}
打印結(jié)果:
1
2
#2 / by zero
3
coroutineScope{}繼承外部協(xié)程上下文環(huán)境
val demo = Demo1()
fun main() = runBlocking<Unit> {
demo.test3()
}
fun test3() = runBlocking {
GlobalScope.launch(CoroutineExceptionHandler { _, throwable ->
println("#1 ${throwable.localizedMessage}")
}) {
println("1")
test4()
println("3")
}.join()
}
private suspend fun test4(){//繼承外部協(xié)程環(huán)境
coroutineScope {
val job = launch(CoroutineExceptionHandler { _, throwable ->
println("#2 ${throwable.localizedMessage}")
}) {
println("2")
val num = 2 / 0
println("2 after...")
}
}
}
打印結(jié)果:
1
2
#1 / by zero
協(xié)程作用域與異常傳播
2019-06-02 at 8.24 PM.png
異常捕獲處理機制
2019-06-02 at 8.30 PM.png
協(xié)程的取消
使用協(xié)程封裝Retrofit請求數(shù)據(jù)
private fun test3() {
GlobalScope.launch {
val json = getResult("/adult/user/logon", mutableMapOf("mobile" to "18795455272", "valid_code" to "8158"))
Log.e("test:: ", json)//打印結(jié)果
}
}
private suspend fun getResult(url: String, params: MutableMap<String, String>): String =
suspendCancellableCoroutine<String> { continuation ->
val call = RetrofitUtils.getApiService().post(url, params)
//失敗取消請求
continuation.invokeOnCancellation { call.cancel() }
call.enqueue(object : retrofit2.Callback<JsonObject> {
override fun onFailure(call: Call<JsonObject>, t: Throwable) {
continuation.resumeWithException(t)
}
override fun onResponse(call: Call<JsonObject>, response: Response<JsonObject>) {
if (response.isSuccessful) {
response.body()?.toString()?.let { continuation.resume(it) }
?: continuation.resumeWithException(NullPointerException("json is null"))
} else {
continuation.resumeWith(Result.failure(HttpException(response)))
}
}
})
}
