上一节主要介绍了协程的一些基本概念，以及协程编写代码的优势。这一节将通过一些代码，讲解协程的基本语法以及使用。

Hello World

协程是可挂起计算的一个实例，它在概念上类似于线程，因为它需要运行一段与其余代码并发工作的代码。但是，协程不绑定到任何特定线程。它可以在一个线程中暂停执行，在另一个线程中恢复执行。

可以将协程视为轻量级线程，但是有许多重要的差异使得它们在实际生活中的用法与线程非常不同。

在展示具体代码之前，通过上面两段再进一步明确一下协程的概念，避免在使用过程中与线程进行混淆。

fun main() = runBlocking {  //协程作用域
	launch { //启动一个新协程并执行
  	delay(1000L) //非阻塞，延迟1s
    print("World")
  }
  print("Hello ")  //主协程
}

执行代码，打印结果如下：

Hello World

接下来详细分析一下以上这段代码:

runBlocking 是一个协程构建器，它连接了非协程函数方法main()与runBlocking{内部的协程…}大括号内的代码。

launch 是一个协程构建器，它与其余代码并发地启动一个新的协程，继续独立工作。这也就是为什么Hello首先被打印出来的原因。

delay 是一个挂起函数，它在特定的时间内挂起协程。挂起协程并不会阻塞底层线程，而是允许其他协程在其代码中运行，并且使用底层线程。

注意：launch 只能声明在协程作用域内部，如果移除runBlocking那么launch就会报错。runBlocking通过名称意味着运行它的线程(在本例中是主线程)在调用期间被阻塞，直到所有在runBlocking{…}执行完成。我们经常会看到runBlocking在应用程序的最顶层像这样使用，而很少在真正的代码中使用，因为线程是昂贵的资源，阻塞它们是低效的，并且通常也是不需要的。

结构化并发

协程遵循结构化并发的原则，这意味着新的协程只能在特定的CoroutineScope中启动，这限定了协程的生命周期。

上面的例子通过runBlocking建立了相应的作用域，这就是为什么前面的例子，延迟一秒打印World后才退出。

在实际的应用程序中，我们会启动许多协程。那么结构化并发会带来哪些好处呢？

1. 确保了所有子协程不会丢失和泄漏；
2. 外部作用域在所有子协程完成之前，它不能完成；
3. 确保上报代码中的任何错误，并且永远不会丢失。

suspend

把launch {.....} 内部的代码抽取到一个独立的方法，这个时候需要在方法前面添加suspend关键字，代码如下：

fun main() = runBlocking {
	launch { printWorld() }
  print("Hello ")
}

suspend fun printWorld() {
	delay(1000L)
  print("World")
}

suspend functions(挂起函数)可以像普通函数一样在协程内部使用，不同的是它们可以使用其他挂起函数(如本例中的delay)来挂起协程。

协程作用域

除了由不同构建器提供的协同程序作用域之外，还可以使用coroutineScope声明自己的作用域。它创建一个协程作用域，直到所有启动的子程序都完成才完成。

runBlocking和coroutineScope对比

相同：都等待自己的主体及其所有子协程完成。

不同：runBlocking方法阻塞当前线程等待，而coroutineScope只是挂起，释放底层线程以用于其他用途。

由于这个区别，runBlocking是一个常规函数，而coroutineScope是一个挂起函数。

使用coroutineScope改造上面的Hello World代码，如下：

fun main() = runBlocking {
	printHelloWorld()
}

suspend fun printHelloWorld() = coroutineScope {
	launch {
  	delay(1000L)
    print("World")
  }
  print("Hello ")
}

执行结果：

Hello World

并发

coroutineScope可以被任何suspend方法内部使用，以执行多个并发操作。看一下如下代码：

fun main() = runBlocking {
	printHelloWorld()
  println("Done")
}
suspend fun printHelloWorld() = coroutineScope {
	launch {
  	delay(2000L)
    println("World2")
  }
  launch {
  	delay(1000L)
    println("World1")
  }
  println("Hello ")
}

先打印Hello，两段launch{ ... }代码同时执行，首先打印World1，接着打印World2，等printHelloWorld函数执行完成，才继续回到runBlocking{ ... }，最后打印Done。

执行结果如下，与预期一致。

Hello
World1
World2
Done

job

启动协程构建器返回一个Job对象，该对象是已启动协程的句柄，可用于显式等待其完成。

先展示一段代码，如下：

val job = launch {
	delay(1000L)
  print("World")
}
print("Hello ")
job.join()
println("Done")

执行结果：

Hello World
Done

使用join函数将协程插入，等到协程执行完成，才打印Done。

轻量级

协程比JVM线程的资源密集型更低。如果使用线程时耗尽JVM可用内存的代码，可以使用协程替换，而不会触及资源限制。例如，下面的代码启动100000个不同的协程，每个协程等待5秒，然后打印一个句点('.')，而消耗的内存很少。

fun main() = runBlocking {
	repeat(100000) {
    launch {
    	delay(5000L)
      print(".")
    }
  }
}

如果我们把这段代码替换为使用线程，即启动100000个不同的线程，会消耗大量的内存，同时很大概率会抛出OOM错误。