根据官方文档分析Kotlin协程的作用

协程的作用

我们先来看看kotlin 官方中文的详细文档
官方描述：协程通过将复杂性放入库来简化异步编程。程序的逻辑可以在协程中顺序地表达，而底层库会为我们解决其异步性。该库可以将用户代码的相关部分包装为回调、订阅相关事件、在不同线程（甚至不同机器）上调度执行，而代码则保持如同顺序执行一样简单。

协程最大的作用就是切换线程。Rxjava也可以线程切换，所以协程与Rxjava切换线程类似的，Rxjava切换是线程，而Kotlin的协程与Rxjava是不同的，协程和线程又有不同的，一个协程是一块块，每一块都有一个上下文Context，通过上下文做桥接来切换。

比如：有A线程和B线程，有三个代码块C1、C2、C3，这些代码块在执行时，在那个线程（A线程或B线程）上切换呢，那么就由协程去控制了，如A线程执行C1、C2代码块，B线程执行C3代码块。执行的单元以协程上下文Context，这么一块一块为单位来切换的。

可以简单地理解为，协程封装好一块块的代码在线程上执行，如封装好的一块块执行单元C1、C2在A线程上，如果要切换到B线程上，那么C1或C2的结果就以条件参数方式传入到C3中在B线程上执行。

协程的使用

1、添加依赖

//协程相关的核心库
implementation ‘org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.2’
implementation ‘org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.2’
2、创建协程

在 kotlin 里面提供了大量的高阶函数，kotlin 中 GlobalScope 类提供了几个携程构造函数。
runBlocking - 不是 GlobalScope 的 API，可以独立使用，区别是 runBlocking 里面的 delay 会阻塞线程，而 launch 创建的不会。
launch- 创建协程。
async - 创建带返回值的协程，返回的是 Deferred 类。
withContext - 不创建新的协程，在指定协程上运行代码块。

kotlin 在 1.3 之后要求协程必须由 CoroutineScope 创建，CoroutineScope 不阻塞当前线程，在后台创建一个新协程，也可以指定协程调度器。

3、runBlocking:T

class MainActivity : AppCompatActivity(){
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
tv_name.text = “learning kotlin”

Log.e("lu","主线程——${Thread.currentThread().name}_id_${Thread.currentThread().id}")
test()
Log.e("lu","协程执行结束。")

}
private fun test() = runBlocking {
//循环10次
repeat(10){
Log.e(“lu”,“协程执行$it——${Thread.currentThread().name}id${Thread.currentThread().id}”)
//挂起2秒
delay(2000)
}
}
}
打印的结果
E/lu: 主线程——main_id_1
E/lu: 协程执行0——main_id_1
E/lu: 协程执行1——main_id_1
E/lu: 协程执行2——main_id_1
E/lu: 协程执行3——main_id_1
E/lu: 协程执行4——main_id_1
E/lu: 协程执行5——main_id_1
E/lu: 协程执行6——main_id_1
E/lu: 协程执行7——main_id_1
E/lu: 协程执行8——main_id_1
E/lu: 协程执行9——main_id_1
E/lu: 协程执行结束。
得出结论：
runBlocking启动的协程任务会阻断当前线程，直到该协程执行结束。当协程执行结束之后，页面才会被显示出来。

4、launch:Job

class MainActivity : AppCompatActivity(){
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
tv_name.text = “learning kotlin”
​
Log.e(“lu”,“主线程——KaTeX parse error: Expected group after '_' at position 33: …read().name}_id_̲{Thread.currentThread().id}”)
// test()
var job = GlobalScope.launch {
//挂起5秒
delay(5_000)
Log.e(“lu”,“协程执行——KaTeX parse error: Expected group after '_' at position 33: …read().name}_id_̲{Thread.currentThread().id}”)
}
Log.e(“lu”,“主线程执行结束。”)

//另一种写法 指定调度器
Log.e(“lu”,“主线程——KaTeX parse error: Expected group after '_' at position 33: …read().name}_id_̲{Thread.currentThread().id}”)
// test()
var job = GlobalScope.launch(Dispatchers.Unconfined) {
//挂起5秒
delay(5_000)
Log.e(“lu”,“协程执行——KaTeX parse error: Expected group after '_' at position 33: …read().name}_id_̲{Thread.currentThread().id}”)
}
Log.e(“lu”,“主线程执行结束。”)

}
}
打印的结果
E/lu: 主线程——main_id_1
E/lu: 主线程执行结束。
E/GED: Failed to get GED Log Buf, err(0)
E/lu: 协程执行——DefaultDispatcher-worker-1_id_2664
launch:Job是最常用的用于启动协程的方式，它最终返回一个Job类型的对象，这个对象实际上是一个接口，它包涵了许多我们常用的函数和变量。

//Job中的常用方法
job.isActive//是否激活
job.isCancelled//是否取消
job.isCompleted//是否完成
job.start()//启动协程，除了LAZY模式，协程都不需要手动启动
job.cancel()//调用取消函数，取消一个协程
job.join()//阻塞,直到某个协程执行完毕
job.cancelAndJoin()//等待协程执行完毕，然后再取消
得出结论:
从执行结果看出，launch不会阻断主线程。

5、async

class MainActivity : AppCompatActivity(){
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
tv_name.text = “learning kotlin”
GlobalScope.launch {
var result1 = GlobalScope.async {
getResult1()
}
var result2 = GlobalScope.async {
getResult2()
}

   var result = result1.await()+result2.await();
   Log.e("lu","result——${result}")

}
}

private suspend fun getResult1():String{
delay(3_000)
return “返回结果1”
}
private suspend fun getResult2():String{
delay(3_000)
return “返回结果2”
}
}
打印的结果
E/lu: result——返回结果1返回结果2
E/lu: 执行时间 3 秒
async跟launch的用法基本一样，区别在于：async的返回值类型是Deferred，将最后一个封装成了该对象。async可以支持并发，此时一般都跟await一起使用。

得出结论:
async是不阻塞线程的,也就是说getResult1和getResult2是同时进行的，所以获取到result的时间是3s，而不是6s。

async 返回的是 Deferred 类型，Deferred 继承自 Job 接口，Job有的它都有，增加了一个方法 await ，这个方法接收的是 async 闭包中返回的值，async 的特点是不会阻塞当前线程，但会阻塞所在协程，也就是挂起。

注意：async 并不会阻塞线程，只是阻塞锁调用的协程。

作者：陈祥_
链接：https://www.jianshu.com/p/835fa7029a10