序

笔者新项目中用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")
    }

}

这篇博客技术含量不高，即是给对协程不了解的同学一些认知和使用说明，一是自己对协程的复习。就这样~