协程(Coroutine-轻量级线程)的使用

一般我们需要异步操作的时候，都是通过多线程来实现的，但是线程的创建和开启是个耗性能的操作，开少量的线程没有问题，可是线程多了就有问题了，而且线程还会有各种数据同步的问题。
协程作为一个轻量级的线程，可以完美解决这些问题。你试下开100万个线程？不死机我吃电脑。但是你开100万个协程，那是分分钟的事。
这里只说android和kotlin中的使用。

添加依赖

// kotlin 版本
ext.kotlin_version = '1.3.41'

// repository 
jcenter()

// 依赖
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.0-RC2'

GlobalScope.launch

fun main() {
    GlobalScope.launch {
        println("我是一个协程")
        delay(1000)
        println("我不会打印，因为主线程已经退出了")
    }
    // 和上面的代码并行执行
    Thread.sleep(500)
    println("主线程退出了")
}

输出：
我是一个协程
主线程退出了

runBlocking

fun main() {
    runBlocking {
        launch {
            println("协程开始")
            delay(1000)
            println("协程结束")
        }
    }
    // 会阻塞等待 runBlocking 中的代码执行完毕
    Thread.sleep(500)
    println("主线程退出了")
}

输出：
协程开始
协程结束
主线程退出了

suspend

fun main() {
    runBlocking {
        println("开始")
        launch {
            test()
        }
        println("结束")
    }
}

suspend fun test() {
    delay(1000L)
    println("我是suspend方法打印的")
}

输出：
开始
结束
我是suspend方法打印的

Job

fun main() {
    runBlocking {
        println("开始")
        val job = launch {
            delay(1000L)
            println("in launch")
        }
        job.join()
        println("结束")
    }
}

输出：
开始
in launch
结束

cancelAndJoin

Job.cancel 实际上是抛出异常，会直接中断执行。

fun main() {
    runBlocking {
        println("开始")
        val job = launch {
            try {
                var i = 1
                while (isActive) {
                    print(i++)
                    delay(500L)
                }
            } finally {
                println("\n异常退出")
            }
        }
        delay(1300L)
        job.cancelAndJoin()// cancel实质上是抛出异常，所以会直接停止，而不会等到delay完后再停止
        println("结束")
    }
}

输出：
开始
123
异常退出
结束

withTimeout

Timeout实际上也是抛出异常。

fun main() {
    runBlocking {
        println("开始")
        try {
            val result = withTimeout(1300) {
                repeat(10) {
                    print(it)
                    delay(500)
                }
                "正常完成，没有Timeout"
            }
            println("\n结束 result=$result")
        } catch (e: TimeoutCancellationException) {
            println("\n结束 Timeout了")
        }
    }
}

输出：
开始
012
结束 Timeout了

Channel

Channel相当于BlockingQueue

fun main() {
    runBlocking {
        println("开始")
        val channel = Channel<Int>()
        launch {
            for (x in 1..5) channel.send(x * x)
            channel.close()
        }
        for (y in channel) print("$y ")
        println("\n结束")
    }
}

输出：
开始
1 4 9 16 25
结束

async、await

fun main() {
    runBlocking {
        println("开始")
        val d = async {
            println("async start...")
            delay(1000)
            println("async end")
            999
        }
        println("d=${d.await()}")
        println("结束")
    }
}

如果想要 async 不自行执行，加上 CoroutineStart.LAZY 即可，然后 async 将会等待调用 start 或者 await 后才会执行，如下：

fun main() {
    runBlocking {
        println("开始")
        val d = async(start = CoroutineStart.LAZY) {
            println("async start...")
            delay(1000)
            println("async end")
            999
        }
        d.start()
        println("d=${d.await()}")
        println("结束")
    }
}

输出：
开始
async start…
async end
d=999
结束

真正执行线程

fun main() {
    runBlocking {
        // 默认执行在当前线程
        launch {
            println("launch\t\t\t\t\t" + Thread.currentThread().name)
        }

        // 默认执行在工作线程
        GlobalScope.launch {
            println("GlobalScope.launch\t\t" + Thread.currentThread().name)
        }

        // 默认执行在工作线程
        launch(Dispatchers.Default) {
            println("Dispatchers.Default\t\t" + Thread.currentThread().name)
        }

        // 默认执行在工作线程
        launch(Dispatchers.IO) {
            println("Dispatchers.IO\t\t\t" + Thread.currentThread().name)
        }

        // 不限制的，可能执行在任何线程，甚至里面的不同行代码也会执行在不同的线程
        launch(Dispatchers.Unconfined) {
            println("Dispatchers.Unconfined\t" + Thread.currentThread().name)
        }

        // 只有android中才能用main
//        launch(Dispatchers.Main) {
//            println("Dispatchers.Main\t\t" + Thread.currentThread().name)
//        }
    }
}

输出：
GlobalScope.launch DefaultDispatcher-worker-1
Dispatchers.Default DefaultDispatcher-worker-3
Dispatchers.IO DefaultDispatcher-worker-3
Dispatchers.Unconfined main
launch main

官方文档

https://kotlinlang.org/docs/reference/coroutines/coroutines-guide.html
https://github.com/Kotlin/kotlinx.coroutines