Kotlin协程之通道-多路复用-并发安全

认识通道

Channel实际上是一个并发安全的队列，它可以用来连接协程，实现不同协程的通信。

fun testKnowChannel() = runBlocking {
    val channel = Channel() //默认通道缓存容量为 0
        //生产者
        val producer = GlobalScope.launch {
            var i = 0
            while(true){
                delay(1000)
                channel.send(++i)
                println("send $i")
            }
        }
    // 消费者
    val consumer = GlobalScope.launch {
        while(true){
//            delay(2000)
            val element = channel.receive()
            println("receive $element")
        }
    }
    joinAll(producer,consumer)
}

通道缓存是0，会发送一个消费一个，如果消费的比较慢，发送方会将send挂起等到消费完了再继续

Channel的容量

Channel实际上就是一个队列，队列中一定存在缓冲区，那么一旦这个缓冲区满了，并且也一直没有调用receive并取走函数，send就需要挂起，故意让接受端的节奏放慢，发现send总是会挂起，知道receive之后才继续往下执行

迭代Channel

Channel本身确实像序列，所以我们在读取的时候可以直接取一个Channel的iterator

fun testIterateChannel() = runBlocking {
    val channel = Channel(Channel.UNLIMITED)
    //生产者
    val producer = GlobalScope.launch {
       for(i in 1..5){
           channel.send(i * i)
           println("send ${i * i}")
       }
    }
    // 消费者
    val consumer = GlobalScope.launch {
//        val iterator = channel.iterator()
//        while(iterator.hasNext()){
//            val element= iterator.hasNext()
//            println("receive $element")
//            delay(2000)
//        }
        for(element in channel) {
            println("receive $element")
            delay(2000)
        }
    }
    joinAll(producer,consumer)
}

设置通道大小后会将5个结果一下子发送出来，消费者会慢慢进行消费

produce与actor

构造生产者与消费者的便捷方法
我们可以通过produce方法启动一个生产者协程，并返回一个ReceiveChannel，其他协程可以用这个Channel来接受数据了，反过来，我们可以用actor启动一个消费者协程

fun testProduceActorChannel() = runBlocking {
//    val receiveChannel = GlobalScope.produce { //生产者
//        repeat(100){
//            delay(1000)
//            send(it)
//        }
//    }
//    val consumer = GlobalScope.launch { // 消费者
//        for(i in receiveChannel) {
//            println("receive $i")
//        }
//    }
//    consumer.join()

    val sendChannel = GlobalScope.actor { // 消费者
        while(true){
            val element = receive()
            println("receive $element")
        }
    }

    val produce = GlobalScope.launch { // 生产者
        for(i in 0..3) {
            sendChannel.send(i)
        }
    }
    produce.join()

}

Channel的关闭

produce和actor返回Channel都会随着对应的协程执行完毕而关闭，也是这样，Channel才被称为热数据流
对于一个Channel，如果我们调用了它的close，它会立即停止接受新元素，也就是说它的isCloseForSend会立即返回true。而由于Channel缓冲区的存在，这时候可能还有一些元素没有被处理完，因此要等所有元素都被读取后isClosedForReceive才会返回true
Channel的生命周期最好由主导仿来维护，建议由主导的一方实现关闭

fun testCloseChannel() = runBlocking {
    val channel = Channel(3)

    val produce = GlobalScope.launch { // 生产者
        List(3) {
            channel.send(it)
            println("send $it")
        }
        channel.close()
        println("""
               -CloseForSend:${channel.isClosedForSend} -CloseForReceive:${channel.isClosedForReceive}
            """.trimIndent())
    }

    val consumer = GlobalScope.launch { // 消费者
        for(element in channel) {
            println("receive: $element")
        }
        println("""
               -CloseForSend:${channel.isClosedForSend} -CloseForReceive:${channel.isClosedForReceive}
            """.trimIndent())
    }
    joinAll(produce,consumer)
}

BroadcaseChannel

发送端和接收端在Channel中存在一对多的情况，从数据本身来讲，虽然有多个接受端，但是同一个元素只会被一个接收端读到。广播则不然，多个接收端不存在互斥的行为。

fun testBroadcastChannel() = runBlocking {
    val broadcast = BroadcastChannel(Channel.BUFFERED)
//    val channel = Channel()
//    val broadcast = channel.broadcast(10)// 可以进行转换
    val produce = GlobalScope.launch { // 生产者
        List(3) {
            delay(100)
            broadcast.send(it)
            println("send $it")
        }
        broadcast.close()
    }
    List(3){
        GlobalScope.launch { // 消费者
            val receiveChannel = broadcast.openSubscription()
            for(element in receiveChannel) {
                println("[$it] receive: $element")
            }
        }
    }.joinAll()
}

多路复用

数据通信系统或者计算机网络系统中，传输媒体的带宽或容量往往会大于传输单一信号的需求，为了有效地利用通信线路，希望一个信道同时传输多路信号，这就是所谓的多路复用技术（Multiplexing）

复用多个await

两个API分别从网络和本地缓存中获取数据期望哪个先返回就先用哪个做展示

fun CoroutineScope.getUserFromLocal() = async(Dispatchers.IO) {
    // 模拟读取本地数据
    delay(1000)
    "getUserFromLocal"
}

fun CoroutineScope.getUserFromNetwork() = async(Dispatchers.IO) {
    // 模拟读取网络数据
    delay(500)
    "getUserFromNetwork"
}

fun testSelectAwait() = runBlocking {
    GlobalScope.launch {
        val userFromLocal = getUserFromLocal()
        val userFromNetwork = getUserFromNetwork()
        val select = select {
            userFromLocal.onAwait { it }
            userFromNetwork.onAwait { it }
        }
        println(select)
    }.join()
}

复用多个Channel

跟await类似，会接收到最快的那个Channel消息

fun testSelectChannel() = runBlocking {
    val channels = listOf(Channel(), Channel())
    GlobalScope.launch {
        delay(100)
        channels[0].send(200)
    }
    GlobalScope.launch {
        delay(50)
        channels[1].send(300)
    }
    val result = select {
        channels.forEach {
            it.onReceive { it }
        }
    }
    println(result)
    delay(1000)
}

SelectCause

所有能够被select的事件都是SelectClauseN类型

SelectCause0：对应事件没有返回值，例如join，那么onJoin就是SelectCauseN，使用时，onJoin的参数是一个无参函数
SelectCause1：对应事件有返回值，例如onAwait，onReceive
SelectCause2：对应事件有返回值，此外还要一个额外参数，例如Channel.onSend，一个参数为Channel数据类型的值，一个为发送成功时的回调

如果我们想要确认挂起函数是否支持select，只需要查看其是否存在对应的SelectClauseN类型可回调即可

fun testChannelSendSelect() = runBlocking {
    val channels = listOf(Channel(), Channel())
    launch {
        select {
            launch {
                delay(100)
                channels[0].onSend(0) {
                    println("onSend 0")
                }
            }

            launch {
                delay(50)
                channels[1].onSend(1) {
                    println("onSend 1")
                }
            }
        }
    }

    GlobalScope.launch {
        println(channels[0].receive())
    }

    GlobalScope.launch {
        println(channels[1].receive())
    }
    
}

使用Flow实现多路复用

fun testFlowMerge() = runBlocking {
    listOf(::getInfoForLocal1, ::getInfoForLocal2)
        .map { function ->
            function.call()
        }.map { deferred ->
            flow { emit(deferred.await()) }
        }.merge()
        .collect {
            println(it)
        }
}

并发安全

在Java平台上的kotlin协程实现避免不了并发调度的问题，因此线程安全值得留意

fun `testSyncSafe1`() = runBlocking {
    var count = 0;
    List(1000) {
        GlobalScope.launch { count++ }
    }.joinAll()

    println(count)
}

以上输出的结果肯定都是小于1000的，不是原子性的操作是线程不安全的

Java是提供的线程安全类

fun `test sync safe2`() = runBlocking {
    var count = AtomicInteger(0);
    List(1000) {
        GlobalScope.launch { count.incrementAndGet() }
    }

    println(count.get())
}

协程的并发工具

除了我们在线程中常用的解决并发问题外，协程框架也提供了一些并发安全的工具

Channel:并发安全的消息通道
Mutex：轻量级锁，它的lock和unlock从语义上与线程锁比较类似，之所以轻量是因为它在获取不到锁时不会阻塞线程，而是挂起等待锁的释放

fun testSyncMutex() = runBlocking {
    var count = 0;
    val mutex = Mutex()
    List(1000) {
        GlobalScope.launch {
            mutex.withLock {
                count++
            }
        }
    }.joinAll()

    println(count)
}

Semaphore:轻量级信号量，信号量可以有多个，协程在获取信号量后即可执行并发操作。当Semaphore的参数为1时，等价于Mutex

fun testSyncSemaphore() = runBlocking {
    var count = 0;
    val semaphore = Semaphore(1)
    List(1000) {
        GlobalScope.launch {
            semaphore.withPermit {
                count++
            }
        }
    }.joinAll()

    println(count)
}

我们也可以避免访问外部变量，基于参数作运算，通过返回值提供运算结果

fun testSyncAvoid`() = runBlocking {
    var count = 0;
    count += List(1000) {
        GlobalScope.async {
            1
        }
    }.map {
        it.await()
    }.sum()

    println(count)
}

Kotlin协程之通道-多路复用-并发安全

认识通道

Channel的容量

迭代Channel

produce与actor

Channel的关闭

BroadcaseChannel

多路复用

复用多个await

复用多个Channel

SelectCause

使用Flow实现多路复用

并发安全

协程的并发工具

你可能感兴趣的:(Kotlin协程之通道-多路复用-并发安全)