Kotlin 协程 CoroutineScope

协程定义：

19年官方是这样说的：协程是轻量级的线程，协程就是 Kotlin 提供的一套线程封装的 API；

现在官方是这样说的：协程是一种并发设计模式；

协程作用：

1.处理耗时任务；

2.保证主线程的安全；

3.简化异步执行的代码，解决并发问题，让「协作式多任务」实现起来更加方便。

使用协程，同样可以像 Rx 那样有效地消除回调地狱，不过无论是设计理念，还是代码风格，两者是有很大区别的，协程在写法上和普通的顺序代码类似。

协程特点：

轻量：您可以在单个线程上运行多个协程，因为协程支持挂起，不会使正在运行协程的线程阻塞。挂起比阻塞节省内存，且支持多个并行操作。

内存泄漏更少：使用结构化并发机制在一个作用域内执行多项操作。

内置取消支持：取消功能会自动通过正在运行的协程层次结构传播。

协程使用： 

1.lauch

lauch用于在协程作用域中异步启动一个新的协程，调用该方法不会阻塞线程。

CoroutineScope(Dispatchers.IO).launch {
	// 启动一个非阻塞线程的协程
}

2.suspend

suspend是协程的关键字，每一个被suspend修饰的方法都必须在另一个suspend函数或者Coroutine协程程序中进行调用。 

3.coroutineScope

coroutineScope是一个挂起函数，每一个被suspend修饰的方法都必须在另一个suspend函数或者Coroutine协程程序中进行调用。

CoroutineScope(Dispatchers.IO).launch {
	coroutineScope {
		// 启动一个非阻塞线程的协程
	}
}

runBlocking {
	coroutineScope {
		// 启动一个非阻塞线程的协程
	}
}

4.runBlocking

runBlocking会阻塞当前线程，而coroutineScope不会阻塞所在的线程，它会挂起所在的协程直至其内部任务(包括子协程)执行完成。

runBlocking {
	// 启动一个阻塞线程的协程
}

5.dispatcher

dispatcher 协程调度器，可以控制协程代码块在UI线程还是子线程中执行；

6.async

1）在概念上，async 就类似于 launch。它启动了一个单独的协程与其它所有的协程一起并发的工作。不同之处在于 launch 返回一个 Job 并且不附带任何结果值，而 async 返回一个 Deferred接口指向的对象，使用 Deferred.await()在一个延期的值上得到它的最终结果，同时Deferred 也是一个 Job，所以如果需要的话，可以使用Deferred.cancel()取消它。

CoroutineScope(Dispatchers.IO).launch {
	val api1Deferred = async { api1() }
	val api2Deferred = async { api2() }
	val api3Deferred = async { api3() }
	println("api*****1")
	val result1 = api1Deferred.await()
    println("api*****2")
}

suspend fun api1(): String {
	delay(2500) // 模拟耗时操作
	println("api1")
	return "api1"
}

suspend fun api2(): String {
	delay(2000) // 模拟耗时操作
	println("api2")
	return "api2"
}

suspend fun api3(): String {
	delay(1500) // 模拟耗时操作
	println("api3")
	return "api3"
}

输出结果： 

结论：

async启动的所有协程是一起并发工作的，async不是挂起函数，所以不会挂起launch创建的协程，所以先输出api*****1，再api3、api2、api1，但执行到api1Deferred.await()时，会挂起协程，等待async { api1() }执行完返回结果后，再执行协程后续的函数，所以最后输出api*****2，因为await()是挂起函数。

public suspend fun await(): T

2）案例：有4个耗时方法，方法名api1，api2，api3，api4；要求方法api1先执行，返回String "api1"，然后将结果"api1"作为参数，并发执行方法api2和方法api3，由于api3 delay(1500)，api2 delay(2000)，所以api3会先执行完并输出结果，然后api2再执行完并输出结果，最后将结果"api2"，api3"作为参数，执行方法api4。

CoroutineScope(Dispatchers.IO).launch {
	val api1Deferred = async { api1() }
	println("api*****1")
	val result1 = api1Deferred.await()
	println("api1:$result1") // 等待 api1 方法执行完成并输出结果
	val api2Deferred = async { api2(result1) }
	val api3Deferred = async { api3(result1) }
	val result2 = api2Deferred.await()
	println("api2:$result2")
	val result3 = api3Deferred.await()
	println("api3:$result3")
	println(api4(result2, result3))
}

suspend fun api1(): String {
	delay(3000) // 模拟耗时操作
	println("api1")
	return "api1"
}

suspend fun api2(v: String): String {
	delay(2000) // 模拟耗时操作
	println("api2")
	return "api2:$v"
}

suspend fun api3(v: String): String {
	delay(1500) // 模拟耗时操作
	println("api3")
	return "api3:$v"
}

suspend fun api4(v: String, v2: String): String {
	delay(500) // 模拟耗时操作
	return "api4:$v$v2"
}

输出结果：  

注：async是并行的，如果使用await()的话，await()是挂起函数，会挂起协程，等待async { api1() }执行完返回结果后，再执行协程后续的函数。

7. withContext

withContext 与 async 都可以返回耗时任务的执行结果。多个 withContext 任务是串行（顺序执行）的， 且withContext 可直接返回耗时任务的结果。 而多个 async 任务是并行的。

public suspend fun <T> withContext()

因为withContext()是挂起函数，执行后，会挂起协程，等待withContext内部函数执行完后，再执行withContext函数后面的函数。

CoroutineScope(Dispatchers.IO).launch {
	val result1 = withContext(Dispatchers.IO) {
		api1()
	}
	println("api*****1")
	println("api1:$result1") // 等待 api1 方法执行完成并输出结果
	val result2 = withContext(Dispatchers.IO) {
		api2(result1)
	}
	println("api2:$result2")
	val result3 = withContext(Dispatchers.IO) {
		api3(result1)
	}
	println("api3:$result3")
	val result4 = withContext(Dispatchers.IO) {
		api4(result2, result3)
	}
	println(result4)
}

suspend fun api1(): String {
	delay(3000) // 模拟耗时操作
	println("api1")
	return "api1"
}

suspend fun api2(v: String): String {
	delay(2000) // 模拟耗时操作
	println("api2")
	return "api2:$v"
}

suspend fun api3(v: String): String {
	delay(1500) // 模拟耗时操作
	println("api3")
	return "api3:$v"
}

suspend fun api4(v: String, v2: String): String {
	delay(500) // 模拟耗时操作
	return "api4:$v$v2"
}

输出结果：