• Async/Await 模式
• Java裡的Future
• 使用Async/Await
• Deferring values
• Combining multiple deferred values

Async/Await 模式

計算中最大的問題之一是能夠從非同步函式返回值。如果你呼叫的函式建立了一個不同的執行緒來執行，你不能將值返回給外部函式。這是一個程式限制，因為系統不知道何時返回，並且很難線上程之間進行橋接。但是有一種方法可以通過 async/await 模式來解決這個問題。
想法很簡單：圍繞你需要的值構建一個包裝器，然後呼叫一個提供該值的函式並將其傳遞給包裝器。準備好後，可以請求它。一旦你請求了這個值，就掛起你請求的函式，直到資料出現。這種模式非常像Java裡的Futures。

Java裡的Future

建立一個Future，必須宣告一個具有 return 語句的函式；否則，會得到一個編譯時錯誤。此外，可以隨時使用 isDone() 檢查Future的狀態。如果 isDone() 返回 true，就可以使用值了。
獲取Future返回值的方式是get(),這是一個阻塞的方法，該方法可能會長時間阻塞主執行緒。

private static ExecutorService executor =
 Executors.newSingleThreadExecutor();
public static Future<Integer> parse(String input) {
 return executor.submit(() -> {
 Thread.sleep(1000)
 return Integer.parseInt(input);
 });
}
public static void main(String...args) {
 Future<Integer> parser = parse("310");
 while(!parser.isDone()) {
 // waiting to parse }
 int parsedValue = parser.get();
}
 

使用Async/Await

kotlin中的async await和java的Future模式很像。kotlin中的async返回了Deferred類比java中的Future。deferred值只是包裝了可以使用的潛在物件。一旦你準備好接收物件，你必須等待它，有效地請求資料，這些資料可能存在也可能不存在。如果資料已經提供並交付，呼叫將變成一個簡單的 get()；否則，程式碼將不得不掛起並等待資料到達包裝器。 很簡單，就好像正在建立一個 BlockingQueue 例項，它只能存放一個例項。而且，在任何時候，都可以嘗試獲取值或在等待程式碼時掛起執行code。關鍵區別在於實際上並沒有阻塞執行緒，而是暫停了程式碼。
該模式被稱為 async/await 是有原因的——因為完整的實現需要兩個函式呼叫——async() 來準備和包裝值，以及 await() 來請求使用值。

public fun <T> CoroutineScope.async(
 context: CoroutineContext = EmptyCoroutineContext,
 start: CoroutineStart = CoroutineStart.DEFAULT,
 block: suspend CoroutineScope.() -> T
): Deferred<T> {
 val newContext = newCoroutineContext(context)
 val coroutine = if (start.isLazy)
 LazyDeferredCoroutine(newContext, block) else
 DeferredCoroutine<T>(newContext, active = true)
 coroutine.start(start, coroutine, block)
 return coroutine
}

/**
* Awaits for completion of this value without blocking a thread
* and resumes when deferred computation is complete,
* returning the resulting value or throwing the
* corresponding exception if the deferred was cancelled.
*
* This suspending function is cancellable.
* If the [Job] of the current coroutine is cancelled
* or completed while this suspending function is waiting,
* this function immediately resumes with
[CancellationException].
*
* This function can be used in [select] invocation
* with [onAwait] clause.
* Use [isCompleted] to check for completion of this
* deferred value without waiting.
*/
public suspend fun await(): T

函式本身極其簡單.可以掛起整個函式或協程，而不是實際阻塞執行緒，並在值準備好後去獲取。

fun main() {
 val userId = 992

 getUserByIdFromNetwork(userId) { user ->
 println(user)
 }
}
private fun getUserByIdFromNetwork(userId: Int, onUserReady:
(User) -> Unit) {
 Thread.sleep(3000)
 onUserReady(User(userId, "Filip", "Babic"))
}
data class User(val id: Int, val name: String, val lastName:
String)

private fun getUserByIdFromNetwork(userId: Int) =
GlobalScope.async {
 Thread.sleep(3000)
 User(userId, "Filip", "Babic")
}
fun main() {
 val userId = 992
 val userData = getUserByIdFromNetwork(userId)
 println(userData.await())
}

<font size = 3 如>前所述，它建立一個協程並使用 Deferred 值對其進行包裝。通過該介面，您可以訪問該值，因為該介面公開了 await()。一旦你呼叫了 await()，掛起了函式呼叫，有效地避免了阻塞執行緒。然後等待 lambda 塊執行以使用內部儲存的值。當值準備好時，函式停止掛起，程式碼繼續正常執行

Deferring values

每個 async() 塊都返回一個 Deferred。它是驅動 Coroutines API 的核心機制，理解它的工作原理非常重要。當呼叫 async() 時，該函式返回一個 Deferred。它通過建立 DeferredCoroutine 或 LazyDeferredCoroutine 來實現。這樣的協程實現了 Continuation 介面，允許攔截執行流，並將值一直傳遞到呼叫點，就像suspendCoroutine()一樣。這類似於之前看到的Future模式的工作方式。
一旦協程建立完成，除非它的 CoroutineStart 是 CoroutineStart.LAZY，否則它會立即啟動。程式碼將開始在使用Dispatchers宣告的執行緒中執行。一旦程式碼完成執行併產生一個值，它將被儲存在內部。如果在任何時間點呼叫 await()，都將是一個掛起的呼叫，這將建立一個新的continuation和執行流，等待該值可供使用。如果它沒有準備好，該函式將不得不等待。如果已經提供了該值，就能立即獲得它。
您還可以檢查延遲值的狀態，因為它還實現了 Job 介面。可以檢查諸如 isActive 和 isCompleted 之類的標誌，以瞭解其當前的生命週期狀態。還有一些漂亮的函式，如果Job被取消，可以使用它們來接收值或異常。這些函式是 getCompleted()，它返回值 - 如果延遲值被取消，則返回異常 - 和 getCompletionExceptionOrNull()，如果Job未取消，則返回 CancellationException 或 null。使用這些函式，還可以檢查deferred values的完成狀態的詳細資訊。
所以解釋什麼是 Deferred 的一個好方法是，它是一個有結果的 Job。該Job可以並行執行，它可能會或可能不會產生結果值，並且可以取消並與其他Job連線。這提供了一個強大的 API，可以隨心所欲。可以利用deferred values的一種方法是將它們組合在一起以呼叫具有多個引數的函式。

Combining multiple deferred values

到目前為止，已經使用了一個模擬網路請求的示例，但現在是擴充套件該示例的時候了。示例中的 users.txt是一個包含 13,000 行文字的檔案。大多數行包含構建使用者所需的資訊——ID、姓名和姓氏。有些行是空的，有些沒有全部三項。這背後的想法是讀取整個檔案，解析和分割每一行，並從中建立使用者。之後，將使用使用者列表和從模擬網路呼叫中獲得的使用者來檢視該使用者是否儲存在檔案中。

private fun readUsersFromFile(filePath: String) =
            GlobalScope.async {
                println("Reading the file of users")
                delay(1000)
                File(filePath)
                        .readLines()
                        .asSequence()
                        .filter { it.isNotEmpty() }
                        .map {
                            val data = it.split(" ") // [id, name, lastName]
                            if (data.size == 3) data else emptyList()
                        }
                        .filter {
                            it.isNotEmpty()
                        }
                        .map {
                            val userId = it[0].toInt()
                            val name = it[1]
                            val lastName = it[2]
                            User(userId, name, lastName)
                        }
                        .toList()
            }

    private fun checkUserExists(user: User, users: List<User>):
            Boolean {
        return user in users
    }
	fun main() {
 val userId = 992
 GlobalScope.launch {
 val userDeferred = getUserByIdFromNetwork(userId)
 val usersFromFileDeferred = readUsersFromFile("users.txt")
 println("Finding user")
 val userStoredInFile = checkUserExists(
 userDeferred.await(), usersFromFileDeferred.await()
 )
 if (userStoredInFile) {
 println("Found user in file!")
 }
 }
 Thread.sleep(5000)
}

private suspend fun getUserByIdFromNetwork(userId: Int) =
GlobalScope.async {
 println("Retrieving user from network")
 delay(3000)
 println("Still in the coroutine")
 User(userId, "Filip", "Babic") // we simulate the network call
}
fun main() {
 GlobalScope.launch {
 val deferredUser = getUserByIdFromNetwork(130)
 println(deferredUser.await())
 }
}