Kotlin协程

kotlin 1.3出来了，而协程(coroutines)也正式发布稳定版。虽然目前项目不是kotlin语言，但为了饭碗kotlin是必须的。而作为kotlin一个重要的内容，肯定要会使用的。
而协程(coroutine)要单独添加支持
在当前的项目添加依赖

dependencies {
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.0.1'
}

在项目的最外层build.gradle添加依赖

buildscript {
ext.kotlin_version = '1.3.0'
}
repository {
jcenter()
}

第一个协程程序
GlobalScope.launch { //在后台启动一个新的线程并继续（无阻塞）
delay(1000L) // delay 是一个特别的挂起函数，它不会造成线程阻塞，挂起函数只能在协程中使用）
println("World!") // 在延迟后打印输出
}
println("Hello,") // 主线程的协程将会继续等待
Thread.sleep(2000L) // 阻塞主线程2秒钟来保证 JVM 存活

运行结果：

Hello,
World!

取消协程
其实GlobalScope.launch { }是有返回值的

public fun CoroutineScope.launch(
context: CoroutineContext = EmptyCoroutineContext,
start: CoroutineStart = CoroutineStart.DEFAULT,
block: suspend CoroutineScope.() -> Unit
): Job {
val newContext = newCoroutineContext(context)
val coroutine = if (start.isLazy)
LazyStandaloneCoroutine(newContext, block) else
StandaloneCoroutine(newContext, active = true)
coroutine.start(start, coroutine, block)
return coroutine
}

可以看到会返回一个Job对象，当然了，还可以看见会有构造参数，分别是协程的上下问和调度器。
具体含义参考：协程上下文与调度器
所以在启动协程的时候，我们可以声明一个Job对象来接收它。

var job: Job? = null

job = GlobalScope.launch { //在后台启动一个新的线程并继续（无阻塞）
...
}

在需要取消的地方

job?.cancel()

取消是协作的
有时候，我们在外面将协程取消来，而协程里面是个耗时的循环，为了保证协程里面代码不会在协程取消的时候还在执行。需要加载条件，保证协程里外状态一致性

job = GlobalScope.launch { //在后台启动一个新的线程并继续（无阻塞）
while (isActive){ //携程是否取消
e(TAG, "Active")
}
try {
repeat(1000){
i ->
Log.e(TAG,"I'm sleeping $i...")
delay(500L)
}
} finally {
withContext(NonCancellable){
Log.e(TAG,"I'm running finally ")
delay(1000L)
Log.e(TAG,"And I've just delayed for 1 sec because I'm non-cancellable")
}

}

而当协程因为异常而被取消时，我们可以在finally中作资源的释放操作

超时
设置协程的超时时长

val result = withTimeoutOrNull(1300L) {
repeat(1000) { i ->
println("I'm sleeping $i ...") delay(500L) } "Done" // 在它运行得到结果之前取消它 } println("Result is$ result")

运行结果：

I'm sleeping 0 ...
I'm sleeping 1 ...
I'm sleeping 2 ...
Result is null

如果直接使用withTimeout()而不是withTimeoutOrNull()会抛出TimeoutCancellationException异常

I'm sleeping 0 ...
I'm sleeping 1 ...
I'm sleeping 2 ...
Exception in thread "main" kotlinx.coroutines.TimeoutCancellationException: Timed out waiting for 1300 ms

结合挂起函数
//挂起函数
suspend fun doSomethingOne(): Int {
delay(1000L) //假设在这里做了一些有用的事
return 22
}

suspend fun doSomethingTwo(): Int {
    delay(1000L) //假设在这里做了一些有用的事
    return 11
}

按照默认顺序调用
val TAG: String = javaClass.name

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    //默认顺序调用
    runBlocking {//显示阻塞,相当于主协程
        val time = measureTimeMillis {
            val one = doSomethingOne()
            val two = doSomethingTwo()
            e(TAG, "the answer is ${one + two}")
        }
        e(TAG, "Completed in $time ms    " + Thread.currentThread().name)
    }
}

运行结果：

the answer is 33
Completed in 2002 ms main

使用async并发
//使用async并发
runBlocking {
val time = measureTimeMillis {
val one = GlobalScope.async{ doSomethingOne() }
val two = GlobalScope.async{ doSomethingTwo() }
e(TAG,"async the answer is ${one.await() + two.await()}" ) } e(TAG,"async Completed in$ time ms " + Thread.currentThread().name)
}

显示结果：

async the answer is 33
async Completed in 1013 ms main

async概念：
async 就类似于 launch。它启动了一个单独的协程，这是一个轻量级的线程并与其它所有的协程一起并发的工作。不同之处在于 launch 返回一个 Job 并且不附带任何结果值，而 async 返回一个 Deferred —— 一个轻量级的非阻塞 future，这代表了一个将会在稍后提供结果的 promise。你可以使用 .await() 在一个延期的值上得到它的最终结果，但是 Deferred 也是一个 Job，所以如果需要的话，你可以取消它。

惰性启动async
//惰性启动async 只有结果需要被await或者start调用，协程才会被启动
runBlocking {
val time = measureTimeMillis {
val one = GlobalScope.async(start = CoroutineStart.LAZY){ doSomethingOne() }
val two = GlobalScope.async(start = CoroutineStart.LAZY){ doSomethingTwo() }
//执行一些计算
one.start()
two.start()
e(TAG,"async lazy the answer is ${one.await() + two.await()}" ) } e(TAG,"async lazy Completed in$ time ms " + Thread.currentThread().name)
}

运行结果：

async lazy the answer is 33
async lazy Completed in 1026 ms main

在协程外面调用async
/**
* async风格的函数
* 返回类型是 Deferred<Int>
* 这些函数不是挂起函数，可以在任何地方被调用。并且是异步（并发）执行
*/
fun someOneAsync() = GlobalScope.async{
doSomethingOne()
}

fun someTwoAsync() = GlobalScope.async{
    doSomethingTwo()
}

上面是async风格的函数，下面是调用

//在协程的外面调用async，注意此时没有使用runBlocking
val time = measureTimeMillis {
//在协程外面启动异步执行
val one = someOneAsync()
val two = someTwoAsync()
//但是等待结果必须调用其它的的挂起或者阻塞
//当我们等待结果的时候，这里使用runBlocking{}来阻塞主线程
runBlocking{
e(TAG,"the answer is ${one.await() + two.await()}") } } e(TAG,"Completed in$ time ms")

运行结果：

the answer is 33
Completed in 1014 ms

这种带有异步函数的编程风格仅供参考，因为这在其它编程语言中是一种受欢迎的风格。在 Kotlin 的协程中使用这种风格是强烈不推荐的
使用async的结构化并发
/**
* 结构话并发如果concurrentSum() 内部发生错误，并且抛出来异常，所有在作用域中启动的协程都将被取消
*/
suspend fun concurrentSum(): Int = coroutineScope{
val one = GlobalScope.async{ doSomethingOne() }
val two = GlobalScope.async{ doSomethingTwo() }
one.await() + two.await()
}

调用：

    //使用async的结构化并发
    runBlocking{
        val time = measureTimeMillis {
            e(TAG,"The answer is ${concurrentSum()}")
        }
        e(TAG,"Compled in $time ms")
    }

运行结果：

The answer is 33
Compled in 1013 ms

取消始终通过协程的层次结构来进行传递
fun main() = runBlocking<Unit> {
try {
failedConcurrentSum()
} catch(e: ArithmeticException) {
println("Computation failed with ArithmeticException")
}
}

suspend fun failedConcurrentSum(): Int = coroutineScope {
val one = async<Int> {
try {
delay(Long.MAX_VALUE) // 模拟一个长时间的运算
42
} finally {
println("First child was cancelled")
}
}
val two = async<Int> {
println("Second child throws an exception")
throw ArithmeticException()
}
one.await() + two.await()
}

运行结果：

Second child throws an exception
First child was cancelled
Computation failed with ArithmeticException

failedConcurrentSum()中one.await() + two.await()在安卓里面写是不被允许的，会报错。因此就直接拷贝Java代码来。的注意观察运行结果调用的顺序，当一个async作用域中有一个子协程发生异常，另外的子协程也会被取消。

好了，这里记录一些kotlin协程的一些简单使用，想要熟练和深刻还得在项目中使用才行

参考：Kotlin文档-协程
————————————————
原文链接：https://blog.csdn.net/sjdjdjdjahd/java/article/details/84771476