1，概述
协程是一个轻量级的线程，将调度从系统线程切换拿到用户态，在一定程度上减少了线程切换开销。
2，简单实例
导入依赖：
dependencies {
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.2"
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.4.2"
}（1）基本使用
//主协程
fun main() = runBlocking {
//开启一个新协程
val job = launch {
delay(1000)
println("task-1")
}
println("task-0")
job.join()//等待job执行完毕，如果此处不join，会退出主协程
}（2）开启多个协程
//开启10万次,
repeat(100_000){
launch {
println("task-t")
}
}（3）async
//定义挂机函数suspend，此定义后可以运行在协程中
suspend fun task1(): Int {
delay(200)
return 0
}
suspend fun task2(): Int {
delay(300)
return 1
}
//主协程
fun main() = runBlocking {
val result1 = async { task1() }
val result2 = async { task2() }
println("wait task result: ${result1.await()} ${result2.await()}")
}
（4）withContext
//主协程
fun main() = runBlocking {
//指定协程运行的线程,
//Main IO Default Unconfined 四个默认值
withContext(Dispatchers.Unconfined) {
println("Unconfined Dispatchers")
}
}（5）协程回调
job.invokeOnCompletion {
println("task-1 done!")
}3，协程通信
（1）channel
suspend fun main(){
val channel = Channel<Int>()
val producer = GlobalScope.launch {
var i = 0
while (true){
delay(100)
channel.send(i++)
}
}
val consumer = GlobalScope.launch {
while (true){
println(channel.receive())
}
}
producer.join()
consumer.join()
}上述代码中构造了两个协程producer和consumer，由于没有为它们明确指定调度器，所以它们的调度器都是默认的，在Java平台上就是基于线程池实现的Default。它们可以运行在不同的线程上，也可以运行在同一个线程上。
?（2）channel迭代
下例中，iterator.hasNext()是挂起函数，在判断是否有下一个元素的时候就需要去Channel中读取元素了。
suspend fun main() {
val channel = Channel<Int>()
val producer = GlobalScope.launch {
var i = 0
while (i <= 5) {
delay(100)
println("send before")
channel.send(i++)
println("send after")
}
//关闭通道
channel.close()
}
val consumer = GlobalScope.launch {
val iterator = channel.iterator()
while (iterator.hasNext()) {
println(iterator.next())
}
println("exit consumer")
}
producer.join()
consumer.join()
}send、receiver也是挂起函数，可以通过输出了解，
send before
send after
0
send before
send after
1
send before
send after
2
send before
send after
3
send before
send after
4
send before
send after
5
exit consumer（3）生产-消费API[实验阶段]
suspend fun main() {
//创建生产者
val receiveChannel: ReceiveChannel<Int> = GlobalScope.produce {
repeat(5) {
delay(100)
send(1)
}
}
//接收数据
GlobalScope.launch {
val iterator = receiveChannel.iterator()
while (iterator.hasNext()) {
println(iterator.next())
}
}
//创建消费者
val sendChannel: SendChannel<Int> = GlobalScope.actor {
while (true) {
println(receive())
}
}
// 发生数据
sendChannel.send(0)
}（4）BroadcastChannel
发送端和接收端在Channel中存在一对多的情形，从数据处理本身来讲，虽然有多个接收端，但是同一个元素只会被一个接收端读到。广播则不然，多个接收端不存在互斥行为。
suspend fun main() {
val broadcastChannel = BroadcastChannel<Int>(Channel.BUFFERED)
GlobalScope.launch {
List(3) {
delay(100)
broadcastChannel.send(it)
}
broadcastChannel.close()
}
List(3) {
GlobalScope.launch {
//订阅该广播channel
val receiveChannel = broadcastChannel.openSubscription()
//下列for循环，是重写了iterator方法，实质是while循环逻辑
//val iterator = iterator()
//while (iterator.hasNext()) {
// println(iterator.next())
//}
for (i in receiveChannel) {
println("[#$it] received: $i")
}
}
}.joinAll()//创建的三个协程全部join
}输出如下，三个协程输出无顺序，
[#1] received: 0
[#0] received: 0
[#2] received: 0
[#1] received: 1
[#2] received: 1
[#0] received: 1
[#1] received: 2
[#2] received: 2
[#0] received: 2除了直接创建以外，我们也可以用前面定义的普通Channel进行转换
suspend fun main() {
val channel = Channel<Int>()
val broadcast = channel.broadcast(3)
List(3) {
GlobalScope.launch {
delay(100) //注意，如果不delay，没有订阅者，send发送的信息会被丢弃
broadcast.send(it)
}
}
List(3){
GlobalScope.launch {
val receiveChannel = broadcast.openSubscription()
for (i in receiveChannel) {
println("[#$it] received: $i")
}
}
}.joinAll()
}（5）Flow
随着RxJava的流行，响应式编程模型逐步深入人心。Flow就是Kotlin协程与响应式编程模型结合的产物。
fun main() = runBlocking {
val intFlow = flow<Int> {
(1..3).forEach {
emit(it)
println("emit:" + Thread.currentThread().name)
delay(100)
}
}
GlobalScope.launch {
// 手动设置调度器
intFlow.flowOn(Dispatchers.IO).collect {
println("Thread->${Thread.currentThread().name} $it")
}
}.join()
}