• kotlin協程小記
• 協程的async使用
• kotlin協程異常處理之-try catch
• kotlin協程異常處理之-CoroutineExceptionHandler

一、try catch

try catch是否一定有效呢？未必，來看一下：

1、withContext

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        println("launch start")
        try {
            withContext(Dispatchers.IO) {
                // 可能拋出異常
            }
        } catch (ex: Exception) {
            println("withContext caught: ${ex.message}")
        }
        println("launch end")
    }
}

withContext是一個掛起函數，它會暫停當前協程的執行，等待傳遞進來的協程上下文切換後繼續執行。當在withContext內部發生異常時，異常會被傳遞迴到withContext函數的調用者，也就是當前協程的上一級代碼中，進而可以被try-catch塊捕獲到。

2、launch

import kotlinx.coroutines.*

fun main() = runBlocking {
    try {
        launch {
            println("launch start")
            // 可能拋出異常
            println("launch end")
        }
    } catch (ex: Exception) {
        println("launch caught: ${ex.message}")
    }
}

try {
    GlobalScope.launch {
        throw NullPointerException()
    }
} catch (e :Exception) {
    e.printStackTrace()
}

launch啟動的協程是獨立於調用它的協程之外的一個新的協程，它沒有直接的上級協程來捕獲它的異常，因此try-catch在協程外部捕獲不到協程中的異常。
事實證明，只要是launch的協程，無論是子協程還是根協程，都無法被捕獲。比如：

GlobalScope.launch {
    try {
        launch {
            Log.d("MainActivity_", "launch-> threadName->" + Thread.currentThread().name)
            throw NullPointerException()
        }
    } catch (e :Exception) {
        e.printStackTrace()
    }
}

一樣會崩潰。

如果將try catch放於內部：

import kotlinx.coroutines.*

fun main() = runBlocking {
     launch {
         try {
            // 可能拋出異常
         } catch (ex: Exception) {
            println("launch caught: ${ex.message}")
         }
         println("launch end")
	 }
}

這樣便可以捕獲得到異常了。

3、async

（1）內部async

GlobalScope.launch {
    try {
        val deferredResult: Deferred<Int> = async {
            Log.d("AsyncTest", "throw before")
            throw Exception("async function exception")
            Log.d("AsyncTest", "throw after")
        }
        deferredResult.await()
    } catch (ex: Exception) {
        Log.d("AsyncTest", "${ex.message}")
    }
}

輸出：

D/AsyncTest: throw before
D/AsyncTest: async function exception

但是程式奔潰了，可以捕獲異常，但是會崩。

（2）、將try catch放於內部：

GlobalScope.launch {
    val deferredResult: Deferred<Int> = async {
        try {
            Log.d("AsyncTest", "throw before")
            throw Exception("async function exception")
            Log.d("AsyncTest", "throw after")
        } catch (e: java.lang.Exception) {
            Log.d("AsyncTest", "${e.message}")
        }
    }
    deferredResult.await()
}

輸出：

D/AsyncTest: throw before
D/AsyncTest: async function exception

可以捕獲異常，並且程式不會崩潰。

（3）、使用GlobalScope.async

GlobalScope.launch {
    try {
        val deferredResult: Deferred<Int> = GlobalScope.async {
            Log.d("AsyncTest", "throw before")
            throw Exception("async function exception")
            Log.d("AsyncTest", "throw after")
        }
        deferredResult.await()
    } catch (ex: Exception) {
        Log.d("AsyncTest", "${ex.message}")
    }
}

輸出：

D/AsyncTest: throw before
D/AsyncTest: async function exception

可以捕獲異常，並且程式不會崩潰。

（4）、只對deferredResult.await()try catch

GlobalScope.launch {
    val deferredResult: Deferred<Int> = GlobalScope.async {
        Log.d("AsyncTest", "throw before")
        throw Exception("async function exception")
        Log.d("AsyncTest", "throw after")
    }
    try {
        deferredResult.await()
    } catch (e: Exception) {
        Log.d("AsyncTest", "${e.message}")
    }
}

輸出：

D/AsyncTest: throw before
D/AsyncTest: async function exception

可以捕獲異常，並且程式不會崩潰。

結論

1、withContext是一個掛起函數，它會暫停當前協程的執行，等待傳遞進來的協程上下文切換後繼續執行。當在withContext內部發生異常時，異常會被傳遞迴到withContext函數的調用者，也就是當前協程的上一級代碼中，進而可以被try-catch塊捕獲到。
2、launch啟動的協程是獨立於調用它的協程之外的一個新的協程，它沒有直接的上級協程來捕獲它的異常，因此try-catch在協程外部捕獲不到協程中的異常。
3、async如果啟動的是子協程，那麼代碼執行到 throw 異常的時候就拋出了異常，與是否調用await方法無關，這個異常可以用try-catch捕獲但是會引起崩潰。
4、async開啟一個根協程，在調用await方法時候會拋出異常，這個異常可以用try-catch捕獲不引起崩潰。