Kotlin协程中的启动/连接和异步/等待之间有什么区别

• launch用于启动并忘记协同程序。这就像开始一个新的线程。如果launch中的代码异常终止，那么它将像线程中的未捕获异常一样被处理——通常打印到后端JVM应用程序中的stderr并使Android应用程序崩溃。join用于等待启动的协程的完成，它不传播它的异常。然而，一个崩溃的孩子协程也会取消它的父类和相应的异常。

• async用于启动一个计算结果的协程。结果由Deferred的实例表示，你必须对它使用await。async代码中未捕获的异常存储在结果Deferred中，并且不会传递到其他任何地方，除非经过处理，否则它将被无声地丢弃。Deferred0。

我发现本指南是有用的。我将引用重要的部分。

🦄协同程序

本质上，协程是轻量级线程。

所以你可以把协程看作是一种非常有效地管理线程的方法。

🐤发射

fun main(args: Array<String>) {
launch { // launch new coroutine in background and continue
delay(1000L) // non-blocking delay for 1 second (default time unit is ms)
println("World!") // print after delay
}
println("Hello,") // main thread continues while coroutine is delayed
Thread.sleep(2000L) // block main thread for 2 seconds to keep JVM alive
}

所以launch启动一个协程，做一些事情，并立即返回一个令牌作为Job。你可以在这个Job上调用join来阻塞，直到这个launch协程完成。

fun main(args: Array<String>) = runBlocking<Unit> {
val job = launch { // launch new coroutine and keep a reference to its Job
delay(1000L)
println("World!")
}
println("Hello,")
job.join() // wait until child coroutine completes
}

🦆异步

从概念上讲，async就像launch。它启动一个单独的协程，这是一个轻量级线程，与所有其他协程并发工作。区别在于launch返回Job，不携带任何结果值，而async返回Deferred——一个轻量级的非阻塞未来，表示稍后提供结果的承诺。

因此async启动一个后台线程，执行一些操作，并立即返回一个标记作为Deferred。

fun main(args: Array<String>) = runBlocking<Unit> {
val time = measureTimeMillis {
val one = async { doSomethingUsefulOne() }
val two = async { doSomethingUsefulTwo() }
println("The answer is ${one.await() + two.await()}")
}
println("Completed in $time ms")
}

你可以对一个延迟值使用.await()来获得它的最终结果，但是Deferred也是一个Job，所以如果需要，你可以取消它。

所以Deferred实际上是一个Job。读到这获取更多详细信息。

interface Deferred<out T> : Job (source)

🦋Async默认是eager

有一个惰性选项可以使用值为CoroutineStart.LAZY的可选开始参数进行异步。它仅在某些await需要其结果或调用启动函数时才启动协程。

launch和async用于启动新的协程。但是，他们以不同的方式来执行。

我想展示一个非常基本的例子，这将帮助你很容易地理解差异

1. 发射

    class MainActivity : AppCompatActivity() {


override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)


btnCount.setOnClickListener {
pgBar.visibility = View.VISIBLE
CoroutineScope(Dispatchers.Main).launch {
val currentMillis = System.currentTimeMillis()
val retVal1 = downloadTask1()
val retVal2 = downloadTask2()
val retVal3 = downloadTask3()
Toast.makeText(applicationContext, "All tasks downloaded! ${retVal1}, ${retVal2}, ${retVal3} in ${(System.currentTimeMillis() - currentMillis)/1000} seconds", Toast.LENGTH_LONG).show();
pgBar.visibility = View.GONE
}
}


// Task 1 will take 5 seconds to complete download
private suspend fun downloadTask1() : String {
kotlinx.coroutines.delay(5000);
return "Complete";
}


// Task 1 will take 8 seconds to complete download
private suspend fun downloadTask2() : Int {
kotlinx.coroutines.delay(8000);
return 100;
}


// Task 1 will take 5 seconds to complete download
private suspend fun downloadTask3() : Float {
kotlinx.coroutines.delay(5000);
return 4.0f;
}
}

在这个例子中，我的代码下载3个数据点击btnCount按钮，并显示pgBar进度条，直到所有下载完成。有3个suspend函数downloadTask1()， downloadTask2()和downloadTask3()用于下载数据。为了模拟它，我在这些函数中使用了delay()。这些函数分别等待5 seconds， 8 seconds和5 seconds。

因为我们已经使用launch来启动这些挂起函数，所以launch将执行它们顺序(一)。这意味着，downloadTask2()将在downloadTask1()完成后启动，而downloadTask3()将仅在downloadTask2()完成后启动。

正如在输出截图Toast中，完成所有3个下载的总执行时间将导致5秒+ 8秒+ 5秒= 18秒和launch

2. 异步

正如我们所看到的，launch使所有3个任务都执行sequentially。完成所有任务的时间为18 seconds。

如果这些任务是独立的，并且不需要其他任务的计算结果，我们可以让它们运行concurrently。它们将同时启动并在后台并发运行。这可以用async来完成。

async返回一个Deffered<T>类型的实例，其中T是挂起函数返回的数据类型。例如,

• downloadTask1()将返回Deferred<String>作为String函数的返回类型
• downloadTask2()将返回Deferred<Int>，因为Int是函数的返回类型
• downloadTask3()将返回Deferred<Float>，因为Float是函数的返回类型

我们可以使用类型为Deferred<T>的async返回对象来获取类型为T的返回值。这可以通过await()调用来完成。查看下面的示例代码

        btnCount.setOnClickListener {
pgBar.visibility = View.VISIBLE


CoroutineScope(Dispatchers.Main).launch {
val currentMillis = System.currentTimeMillis()
val retVal1 = async(Dispatchers.IO) { downloadTask1() }
val retVal2 = async(Dispatchers.IO) { downloadTask2() }
val retVal3 = async(Dispatchers.IO) { downloadTask3() }


Toast.makeText(applicationContext, "All tasks downloaded! ${retVal1.await()}, ${retVal2.await()}, ${retVal3.await()} in ${(System.currentTimeMillis() - currentMillis)/1000} seconds", Toast.LENGTH_LONG).show();
pgBar.visibility = View.GONE
}

这样，我们就同时启动了所有3个任务。因此，我要完成的总执行时间将仅为8 seconds，这是downloadTask2()的时间，因为它是所有3个任务中最大的。你可以在下面的Toast message截图中看到这一点

< >强启动< / >强返回一个作业

< >强异步< / >强返回一个结果(被延迟的任务)

launch和join用于等待作业完成。它只是挂起调用join()的协程，同时让当前线程空闲地做其他工作(比如执行另一个协程)。

async用于计算一些结果。它创建了一个协程，并将其未来的结果作为Deferred的实现返回。当产生的延迟被取消时，正在运行的协程也被取消。

考虑一个返回字符串值的异步方法。如果async方法没有使用await，它将返回一个Deferred字符串，但如果使用await，结果将是一个字符串

async和launch的关键区别:
Deferred在协程完成执行后返回类型为T的特定值，而Job则不会。 < / em >