1、什么是协程
协程和线程类似，可以简单的理解为一个轻量级的线程。线程是比较重量级的，它需要依靠操作系统来实现线程的切换，而协程的切换是通过编程语言层面进行控制的，大大提高了并发编程的运行效率。
2、协程的基本使用
现在面临的问题是如何开启协程，开启协程的方式有很多种：
2.1、方式一 GlobalScope.launch
GlobalScope.launch { }
这样我们就成功的开启了一个协程，传递给launch函数的lambda表达式中的代码就运行在协程的环境中了。
GlobalScope.launch创建的是一个顶层协程，相当于创建了一个子线程。下面我们在协程域中打印看下是否是子线程：
fun main() {
GlobalScope.launch {
println("ThreadName is ${Thread.currentThread().name}")
}
Thread.sleep(100)
println("ThreadName is ${Thread.currentThread().name}")
}
输出结果如下：
ThreadName is DefaultDispatcher-worker-2 @coroutine#1
ThreadName is main
可见通过GlobalScope.launch创建协程相当于开启了一个子线程。
2.2、方式二 runBlocking
runBlocking {
println("ThreadName is ${Thread.currentThread().name}")
}
输出结果为：ThreadName is main @coroutine#1，可见通过runBlocking开启协程域并没没有创建线程，依然在主线程中。
再来看下下面代码：
fun main() {
runBlocking {
println("create coroutine start")
delay(4000)
println("create coroutine end")
}
println("run on MainThread")
}
通过运行结果你会发现在协程域中的代码块未执行完成之前，是无法打印run on MainThread，这就说明runBlocking创建的协程是会阻塞其所在的线程的。
delay()函数
我们在代码块中加入了一个delay()函数，它的作用就是使其所在协程暂时挂起，延迟指定时间后再执行协程域内下面的代码，但是它并不会阻塞线程的执行，所以也不会影响其他协程的运行。注意：它只能在协程域中或挂起函数中调用。
2.3、方式三 launch
上面介绍的两种创建协程的方法都是可以在任意地方调用的，但是launch函数只能在协程域下调用，它是用于创建子协程的。子协程的特点是：如果外层作用域的协程结束了，该作用域下的子协程也会全部结束。
fun main() {
runBlocking {
launch {
println("launch1")
delay(100)
println("launch1 end")
}
launch {
println("launch2")
delay(100)
println("launch2 end")
}
}
}
这里使用launch创建了两个子协程，运行结果如下：
launch1
launch2
launch1 end
launch2 end
可以看到两个子协程的日志是交替打印的，说明它们确实像多线程那样并发运行的。然而这两个子协程却是在同一个线程中的，只是由编程语言来决定协程间的切换，无须操作系统进行调度，所以协程实现的并发效率高于线程。
但是当launch中的逻辑比较复杂时，我们可能需要将其中的代码抽取出一个个方法，但是这些方法并不在协程的作用域内了，那我们怎么在这些方法中调用像delay()这样的挂起函数呢？
Kotlin中提供了关键suspend来修饰定义挂起函数。
suspend fun printDot(){
println(".")
delay(100)
}
这样我们就定义了一个挂起函数了，由于delay()可以在协程作用域中或挂起函数中调用，所以我们就可以在其中调用delay()了。
虽然suspend能将一个函数声明成挂起函数，但是无法提供协程作用域，所以我们无法在挂起函数中调用launch函数创建子协程。
2.4、方式四 coroutineScope
coroutineScope { }也是一个挂起函数，它的特点是：继承外部的协程作用域并创建一个子作用域(并没有创建子协程，不同于launch)，借助这个特性我们就可以给任意挂起函数提供协程作用域了。示例写法如下：
suspend fun printDot() = coroutineScope {
launch {
println(".")
delay(1000)
}
}
另外coroutineScope 函数可以保证其作用域内的所有代码和子协程在全部执行完之前，会阻塞当前协程。我们来看如下示例代码：
fun main() {
runBlocking {
launch {
println("launch1 start")
coroutineScope {
for (i in 1 until 10)
println("$i")
}
println("launch1 end")
}
}
}
输出如下：
launch1 start
1
2
3
4
5
6
7
8
9
launch1 end
可以看出，coroutineScope函数确实将当前协程阻塞住了。
2.5、方式五 CoroutineScope.launch
前面我们学习了如下四种方式创建协程作用域：
- GlobalScope.launch{}:可以在任意地方调用，在主线程中创建的协程作用域其实是运行在子线程中的。
- runBlocking{}:可以在任意地方调用，会阻塞线程，因此只建议在测试环境中使用。
- launch{}：只能在协程作用域中。
- coroutineScope{}：只能在挂起函数或者协程作用域中，会阻塞当前协程。
如果我们使用协程去发起网络请求，在接口未响应之前我们关闭了页面，此时应该在页面关闭时取消网络请求或者不进行回调。那么协程如何取消呢？
GlobalScope.launch{}和runBlocking{}函数都返回Job对象，我们可以利用Job.cancel()进行协程的取消。
var job:Job?=null
btn_start_coroutine.setOnClickListener {
job = GlobalScope.launch {
delay(5000)
if (job?.isActive == true)
Log.e(tag, "Global.launch")
}
}
override fun onDestroy() {
super.onDestroy()
job?.cancel()
}
从上面代码可以看出job?.cancel()并不是真正取消协程，只是给协程设置一个标志位，我们可以通过job?.isActive进行判断协程是否处于运行状态，进而控制协程作用域中代码的运行。
如果我们使用GlobalScope.launch{}创建多个协程，那么在页面关闭时我们就需要多次调用job.cancel()进行协程的取消。这样还是很难管理的，下面看下如何进行统一管理协程：
val job = Job()
val scope = CoroutineScope(job)
scope.launch {
delay(5000)
Log.e(tag, "scope.launch")
}
在上面代码中，我们创建一个Job对象，并调用CoroutineScope(job)函数，该函数返回一个CoroutineScope对象，有了这个对象我们就能使用CoroutineScope.launch{}创建协程了，使用这个对象创建的所有协程都是关联到刚才我们创建的job对象的作用域下，这样我们就能使用job.cancel()取消所有协程。
2.6、方式六 async
细心的你肯定发现了上面五种方式是无法获取执行结果的，如果想获取协程的执行结果，就需要使用async{}函数了，下面看下具体使用。
job = Job()
val scope = CoroutineScope(job!!)
scope.launch {
val result = async {
5 + 10
}.await()
Log.e(tag,"result is $result")
}
async{}函数只能运行在协程作用域中，其返回的是Deferred对象，如果我们想获取协程的执行结果，就需要调用Deferred.await()方法即可。不过需要注意的是await()在async {}中代码块未执行完成之前会阻塞所在协程执行。如果一个协程作用域下有多个async{}，如果我们在async{}后直接调用await()，这样就会导致多个async{}是串行的，效率低下。我们可以在使用到结果时再调用await()来达到并行的效果。
job = Job()
val scope = CoroutineScope(job!!)
scope.launch {
val result1 = async {
1 + 1
}
val result2 = async {
2 + 2
}
Log.e(tag, "result is ${result1.await() + result2.await()}")
}
2.7、方式七 withContext
withContext函数只能在协程作用域或挂起函数中调用，它其实是async{}.await()的另一种表现形式。withContext调用时在其中的代码块未执行完成前也会阻塞所在的协程。
job = Job()
val scope = CoroutineScope(job!!)
scope.launch {
val result = withContext(Dispatchers.Default) {
5 + 5
}
Log.e(tag, "result is $result")
}
可以看到我们在调用withContext()函数时，强制要求我们指定了一个线程参数，下面我们具体讲解下线程参数。
3、线程参数
线程参数主要有如下3个可选项：
- Dispatchers.Default：使用它会开启一个子线程，并且会使用一种低并发的线程策略。
- Dispatchers.IO：使用它同样会开启一个子线程，并且会使用一种高并发的线程策略，当你要执行的代码大多数时间都是在等待和阻塞，就需要使用该线程参数。
- Dispatchers.Main：并不会开启一个线程，而是在主线程中执行。
上面我们所学的协程构造方法中，只有coroutineScope { }函数除外，都可以指定线程参数，只不过withContext是强制指定的。
4、使用协程简化回调
我们在请求网络获取异步网络数据时，一般是使用回调的方式来实现的，而回调一般都是通过创建匿名内部类来实现的。
HttpUtils.sendRequest(address,object:DataCallBack{
override fun onFinish(respone:String){
}
override fun onError(e:Exception){
}
})
在多次请求网络数据时就需要多次创建匿名内部类，我们可以是用挂起函数suspendCoroutine来解决这个问题。suspendCoroutine函数是一个挂起函数，必须在协程作用域或挂起函数中调用，它接收一个Lamdba表达式，主要作用是将当前协程挂起，并执行Lambda表达式中的代码块。Lambda表达式的参数列表上会传入一个Continuation对象，可以调用其resume()方法或者resumeWithException()让协程恢复运行。
suspend fun request(address: String): String = suspendCoroutine {
sendRequest(address, object : DataCallback {
override fun onFinish(response: String) {
it.resume(response)
}
override fun onError(e: Exception) {
it.resumeWithException(e)
}
})
}
从上面代码可以看出使用suspendCoroutine{}进行网络请求其内部还是需要创建匿名内部类来实现回调，只不过在调用sendRequest()时在编码上省略了这个操作。
try {
val response = request("http://www.baidu.com")
} catch (e: Exception) {
//对异常的处理
}
request函数是一个挂起函数，当调用该函数时，协程就会被挂起，当等待网络请求成功或失败，协程才会恢复运行。这样即使不使用回调的写法，我们也能获取异步请求网络的数据，而如果请求失败，则会直接进入catch语句中。
