序
笔者新项目中用kotlin试水，但是协程一直没有使用，对于这个新概念，我一直是以为和Thread不分上下，顶多语法和写法上的优势，但当我真正的学习协程之后发现...真香，对于协程这个概念不能对标线程，只能对标线程池。
使用
对于kotlin 使用我推荐直接看官方教程比较好，官方文档。鉴于基本上kotlin使用协程是替代Android java代码使用，尤其是线程，线程池相关，所以从例子出发，对协程的几个概念增强理解。
Thread.sleep 和 协程delay
fun main() = runBlocking<Unit> {
println("start")
delay(5000)
println("end")
}
运行起来的确和Thread.sleep一样。但接着看下个例子
fun main() = runBlocking<Unit> {
println("start")
println(Thread.currentThread().name)
launch {
println(Thread.currentThread().name)
delay(5000)
println(Thread.currentThread().name)
println("inside")
}
println("end")
}
我在顶协程里面又开了个子协程， 输出是 start end inside ，线程都是主线程，但是结果并不是按照代码顺序输出的。而且launch 没有开线程，那么可以理解delay 和sleep 完全是两个概念，delay方法点进去会发现suspend 关键字 这是 kotlin 独有的关键字，字面意思是挂起，意思delay是挂起函数。关于挂起，在此不多展开，只用了解到挂起这个是用户态级别概念。】
关于启动协程
启动协程的方法基本都在kotlinx.coroutines.Builders.common.kt 里面 lanuch 和 async还有个奇葩的runblocking ，先说下runblocking
上面那个例子就能大概看出来runblocking的作用 主要是子协程结束 才能跳出。 只要是有子协程没结束，这个就不会结束。一般我们在项目中不会用到这个。基本会被其他的写法所代替。
lanuch
lanuch方式启动的协程会返回一个Job对象，这个可以我们用来cancel 和等待(join)等操作，这种方式启动的协程是直接启动 ，不用触发 走到即执行。这种方式是经常使用的。
fun main() = runBlocking<Unit>{
launch {
println("launch")
var job2 = launch {
delay(100)
println("launch2")
}
job2.join()
launch {
delay(10)
println("launch3")
}
}
}
async
async 是用于不同需求 需要同时返回结果，这种情况存在。
fun main() = runBlocking{
val elapsedTime = measureTimeMillis {
var task1 = async {
println("launch")
delay(1000)
"task1"
}
var task2 = async {
println("launch2")
delay(2000)
"asy"
}
task1.await() + task2.await()
}
println("$elapsedTime")
println("over")
}
关于切换线程
对于线程最重要的功能就是切换线程，对于Android来说尤为重要。许多框架都为了切换线程做简化 类似Rxjava，切换线程只需要一行代码就可以了，对于kotlin ，切换线程做了简化操作，只需要一个参数，就能指定block代码在哪个线程执行。
launch (Dispatchers.Main) {}
async (Dispatchers.IO) {}
关于异常处理
代码中必须考虑的一种情况就是 错误处理，想一下线程中的异常处理是怎样的，一层层的 catch处理，如果出现异常 可能还需要释放并发线程的资源（相互依赖的情况）。在协程中，这个也做了简化处理。总结下来就是两个情况，
一种是一损全损 ，当一个协程出现异常的时候，其他协程需要全部停止。
一种是互不影响，当一个协程出现问题的时候，其他协程依旧照常运行。
关于异常处理，要引申一个概念就是协程域。
协程中有两种协程域 一个是 coroutineScope ，异常是双向传播，子协程未捕获的异常也会向上传递给父协程 。一个是supervisorScope，这个不会 传递异常。
fun main() = runBlocking {
try{
coroutineScope {
launch {
delay(100)
println("launch1_start")
launch {
delay(200)
println("launch1_child1")
throw NullPointerException()
}
println("launch_2")
var job = launch {
delay(5000)
println("launch1_child2")
}
try {
job.join()
}catch (e:Exception) {
println("child2:$e")
}
println("launch1_end")
}
}
}catch (e:NullPointerException) {
println("$e")
}
println("over")
}
fun main() = runBlocking {
try{
supervisorScope {
launch {
println("launch1_start")
launch {
delay(200)
println("launch1_child1")
throw NullPointerException()
}
}
println("launch_2")
var job = launch {
delay(1000)
println("launch1_child2")
}
try {
println("launch_3")
job.join()
println("launch_4")
}catch (e:Exception) {
println("child2:$e")
}
println("launch1_end")
}
}catch (e:NullPointerException) {
println("$e")
}
println("over")
}
还有一点要注意的是 join 和await 的异常处理是不一样的，join不管结果 只管结不结束，await 是需要结果的。
fun main() = runBlocking {
var test1 = GlobalScope.async {
throw NullPointerException()
}
try {
test1.await()
// test1.join()
println("over")
} catch (e:Exception) {
println("e: $e")
}
}
这篇博客技术含量不高，即是给对协程不了解的同学一些认知和使用说明，一是自己对协程的复习。就这样~
