Kotlin Channel 管道

已于 2023-10-20 15:31:35 修改
阅读量1.6k 收藏 2
点赞数 1
分类专栏： # Kotlin 协程 文章标签： Kotlin 协程 Channel
于 2022-03-31 16:28:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_14876133/article/details/123876616
版权

文章目录

Kotlin Channel 管道

概述

  • Kotlin 协程中的挂起函数、async 每次只能返回一个结果。
  • 需要返回多个结果，比如聊天软件接收消息、GPS定位实时返回坐标这类场景，使用 Kotlin 协程中的Channel 更适合。
  • Channel 就是一个管道，管道的一端是发送方，另一端是接收方，管道本身可以用来传输数据，可以 发送-接收 多个数据。
  • Channel 是热数据流，不管有没有接收方，发送方都会工作。

在这里插入图片描述

源码和参数

public fun <E> Channel(
    capacity: Int = RENDEZVOUS,
    onBufferOverflow: BufferOverflow = BufferOverflow.SUSPEND,
    onUndeliveredElement: ((E) -> Unit)? = null
): Channel<E> { }

Channel() 是一个顶层函数。该函数有三个参数：

参数一：capacity

代表管道的容量。

  • Channel.RENDEZVOUS：默认值，表示容量为0，发送后可以立即接收的模式。
  • Channel.UNLIMITED：无限容量。
  • Channel.CONFLATED：表示容量为1，新数据会替代旧数据。
  • Channel.BUFFERED：表示具有一定的缓存容量，默认情况下是64，具体容量可以设置VM参数 kotlinx.coroutines.channels.defaultBuffe。

参数二：onBufferOverflow

当管道指定容量后，如果管道的容量满了时，Channel 的应对策略。

  • BufferOverflow.SUSPEND：默认值，当管道的容量满了后，如果发送方还再继续发送，就会挂起当前的send() 方法，等管道有空闲位置后再恢复。send() 这是一个挂起函数。
  • BufferOverflow.DROP_OLDEST：丢弃最旧的数据，然后发送新数据。
  • BufferOverflow.DROP_LATEST：丢弃最新的数据，管道的内容维持不变。

在这里插入图片描述

参数三：onUndeliveredElement

异常处理回调，管道中的数据没有被成功接收时，就会回调这个函数。

注意

Channel 是一种协程资源，使用完后，一定要调用 close() 方法及时关闭，否则程序不会停止，造成资源浪费。

使用

capacity = Channel.RENDEZVOUS 也就是默认值

fun main() = runBlocking {
    val channel = Channel<Int>()
    launch {
        (1..3).forEach {
            println("send: $it")
            channel.send(it)
        }
        channel.close() //主动关闭
    }
    launch {
        for (i in channel) {
            println("receive: $i")
        }
    }
    println("结束！")
}

/*
输出信息：
结束！
send: 1
receive: 1
send: 2
send: 3
receive: 2
receive: 3
 */

说明：发送方和接收方是交替执行的。

capacity = UNLIMITED

fun main() = runBlocking {
    val channel = Channel<Int>(capacity = UNLIMITED)
    launch {
        (1..3).forEach {
            println("send: $it")
            channel.send(it)
        }
        channel.close()
    }
    launch {
        for (i in channel) {
            println("receive: $i")
        }
    }
    println("end")
}

/*
输出信息：
end
send: 1
send: 2
send: 3
receive: 1
receive: 2
receive: 3
 */

说明：当 capacity = UNLIMITED 时，表示 Channel 的容量是无限大的，所以发送方可以一直往管道里发送数据，等数据发送完后，接收方才开始接收。

capacity = CONFLATED

fun main() = runBlocking {
    val channel = Channel<Int>(capacity = CONFLATED)
    launch {
        (1..3).forEach {
            println("send: $it")
            channel.send(it)
        }
        channel.close()
    }
    launch {
        for (i in channel) {
            println("receive: $i")
        }
    }
    println("end")
}

/*
输出信息：
end
send: 1
send: 2
send: 3
receive: 3
 */

说明：当 capacity = CONFLATED 时，表示发送方会一直发送数据，但是接收方永远只会接收最后一条数据。

capacity = BUFFERED

fun main() = runBlocking {
    val channel = Channel<Int>(capacity = BUFFERED)
    launch {
        (1..3).forEach {
            println("send: $it")
            channel.send(it)
        }
        channel.close()
    }
    launch {
        for (i in channel) {
            println("receive: $i")
        }
    }
    println("结束！")
}

/*
输出信息：
结束！
send: 1
send: 2
send: 3
receive: 1
receive: 2
receive: 3
 */

说明：capacity = BUFFERED与capacity = UNLIMITED效果基本一样。

onBufferOverflow = BufferOverflow.SUSPEND 也就是默认值

fun main() = runBlocking {
    val channel = Channel<Int>(capacity = 1, onBufferOverflow = BufferOverflow.SUSPEND)
    launch {
        (1..3).forEach {
            println("send: $it")
            channel.send(it)
        }
        channel.close()
    }
    println("结束！")
}

/*
输出信息：
结束！
send: 1
send: 2 被挂起了，程序停在这里
 */

说明：当Channel的容量满了后，send() 方法会被挂起。

onBufferOverflow = BufferOverflow.DROP_OLDEST

fun main() = runBlocking {
    val channel = Channel<Int>(capacity = 1, onBufferOverflow = BufferOverflow.DROP_OLDEST)
    launch {
        (1..3).forEach {
            println("send: $it")
            channel.send(it)
        }
        channel.close()
    }
    launch {
        for (i in channel) {
            println("receive: $i")
        }
    }
    println("结束！")
}

/*
输出信息：
结束！
send: 1
send: 2
send: 3
receive: 3
 */

说明：效果与 capacity = CONFLATED 基本一样，会丢弃最旧的数据。

onBufferOverflow = BufferOverflow.DROP_LATEST

fun main() = runBlocking {
    val channel = Channel<Int>(capacity = 1, onBufferOverflow = BufferOverflow.DROP_LATEST)
    launch {
        (1..3).forEach {
            println("send: $it")
            channel.send(it)
        }
        channel.close()
    }
    launch {
        for (i in channel) {
            println("receive: $i")
        }
    }
    println("结束！")
}

/*
输出信息：
结束！
send: 1
send: 2
send: 3
receive: 1
 */

说明：Channel 容量满了后，会丢弃后续发送的数据。

onUndeliveredElement

fun main() = runBlocking {
    val channel = Channel<Int>(capacity = Channel.CONFLATED) {
        println("onUndeliveredElement: $it")
    }
    launch {
        (1..3).forEach {
            println("send: $it")
            channel.send(it)
        }
        channel.close()
    }
    launch {
        for (i in channel) {
            println("receive: $i")
        }
    }
    println("结束！")
}

/*
输出信息：
结束！
send: 1
send: 2
onUndeliveredElement: 1
send: 3
onUndeliveredElement: 2
receive: 3
 */

说明：丢弃的数据会被onUndeliveredElement接收到。

推荐 produce 高阶函数

如果忘记调用 close() 方法，会导致程序一直运行无法停止，产生很严重的问题。

Kotlin 提供了另一种创建 Channel 的方式，推荐使用 produce{} 高阶函数。使用 produce 以后不用再调用 close() 方法了，因为 produce 内部已经帮我们处理了，会自动调用 close() 方法。

fun main() = runBlocking {
    val channel: ReceiveChannel<Int> = produce {
        (1..3).forEach {
            println("send: $it")
            send(it)
        }
    }
    launch {
        // 3，接收数据
        for (i in channel) {
            println("Receive: $i")
        }
    }
    println("end")
}

/*
输出信息：
end
send: 1
Receive: 1
send: 2
send: 3
Receive: 2
Receive: 3
 */

receive()

可以使用 receive() 接收数据，但是直接使用 receive() 是很容易出现问题的，如下：

fun main() = runBlocking {
    val channel: ReceiveChannel<Int> = produce {
        (1..3).forEach {
            send(it)
        }
    }

    // 调用4次receive()
    println(channel.receive())
    println(channel.receive())
    println(channel.receive())
    println(channel.receive())

    println("end")
}

/*
输出结果：
1
2
3
Exception in thread "main" kotlinx.coroutines.channels.ClosedReceiveChannelException: Channel was closed
*/

fun main() = runBlocking {
    val channel = Channel<Int>()
    launch {
        (1..3).forEach {
            channel.send(it)
        }
    }

    // 调用4次receive()
    println(channel.receive())
    println(channel.receive())
    println(channel.receive())
    println(channel.receive()) //永远挂起

    println("end")
}

/*
输出结果：
1
2
3
*/

isClosedForReceive 和 isClosedForSend

  • 对于发送方，可以使用 isClosedForSend 来判断当前的 Channel 是否关闭。
  • 对于接收方，可以使用 isClosedForReceive 来判断当前的 Channel 是否关闭。

但是，当你为管道指定了 capacity 以后，以上的判断方式将会变得不可靠。原因是目前的 1.6.0 版本的协程库，运行这样的代码会崩溃 。

因此最好不要用 channel.receive() ，即使配合 isClosedForReceive 这个判断条件，我们直接调用 channel.receive() 仍然是一件非常危险的事情！

fun main() = runBlocking {
    // 发送方：
    val channel: ReceiveChannel<Int> = produce {
        (1..3).forEach {
            send(it)
            println("send: $it")
        }
    }

    // 接收方：
    // 使用while循环判断isClosedForReceive
    while (!channel.isClosedForReceive) {
        val i = channel.receive()
        println("receive: $i")
    }

    println("end")
}

/*
输出信息：
Send 1
Receive 1
Receive 2
Send 2
Send 3
Receive 3
end
*/

推荐 consumeEach 高阶函数

推荐使用 consumeEach 高阶函数接收数据，替代for循环。

fun main() = runBlocking {
    val channel: ReceiveChannel<Int> = produce {
        (1..3).forEach {
            println("send: $it")
            send(it)
        }
    }
    channel.consumeEach {
        println("receive: $it")
    }
    println("end")
}

/*
输出信息：
end
send: 1
Receive: 1
send: 2
send: 3
Receive: 2
Receive: 3
 */

Channel 是热流

Channel 是热流，指的是“不管有没有接收方，发送方都会工作”的模式。

fun main() = runBlocking {
    // 只发送不接受
    val channel = produce<Int>(capacity = 10) {
        (1..3).forEach {
            send(it)
            println("send: $it")
        }
    }

    println("end")
}

/*
输出结果：
end
Send 1
Send 2
Send 3
*/

说明：没有接收方时，Channel 依然会发送数据。

fun main() = runBlocking {
    val channel = produce<Int>(capacity = 0) {
        (1..3).forEach {
            println("Before send $it")
            send(it)
            println("Send $it")
        }
    }

    println("end")
}

/*
输出结果：
end
Before send 1
挂起程序一直停在这里
*/

说明：将 capacity 设置为0后，程序一直停着无法退出，这是因为 send() 方法是一个挂起函数，当 Channel 容量满了就会挂起。

xiangxiongfly915
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
kotlin
03-12
kotlin
kotlin学习kotlin学习
08-16
kotlin学习kotlin学习
channel-sdk-kotlin
04-11
通道API的Kotlin SDK
Kotlin 入门教程指南
08-31
内容共4M大小，供大家学习使用
Kotlin协程Channel使用
duncan891101的专栏
12-29 1406
一、Channel 1、定义 Flow是冷流，本质上可以说是一个单线程操作，只有开始收集时，上流代码才会启动；而Channel是一个并发安全的队列，可以用来连接不同的协程，实现不同协程之间的通信。   2、基本使用 runBlocking { val channel = Channel<Int>() GlobalScope.launch(Dispatchers.IO) { channel.send(10) delay(1000)
Golang channle （管道）基本介绍、快速入门
小楼一夜听春雨，深巷明朝卖杏花
12-06 3732
为什么需要channel？前面使用全局变量加锁同步来解决goroutine的通讯，但不完美1)主线程在等待所有goroutine全部完成的时间很难确定，我们这里设置10秒，仅仅是估算。2)如果主线程休眠时间长了，会加长等待时间，如果等待时间短了，可能还有goroutine处于工作状态，这时也会随主线程的退出而销毁3)通过全局变量加锁同步来实现通讯，也并不利用多个协程对全局变量的读写操作。4)上面种种分析都在呼唤一个新的通讯机制-channelimport ("fmt""sync"
Kotlin-协程Coroutines-Channels
huyuchaoheaven的专栏
03-09 448
Deferred Channels
Android Kotlin协程间的通信Channel介绍
Vaccae的博客
05-09 1967
学更好的别人，做更好的自己。——《微卡智享》本文长度为2399字，预计阅读7分钟前言使用Kotlin做Android项目时，肯定少不了使用协程，而在协程的使用中，少不了要在不同的协程中传递数据，而Kotlin中的Channel，就是专门用来处理协程之间的通信，今天这篇就是来看看Channel的用法。Channel简介微卡智享channel用于协程间的通信, 允许我们在不同...
王学岗Kotlin协程(五)————Channel通道-多路复用-并发安全
qczg_wxg的博客
11-22 2588
使用chanel进行通信 @Test fun `test know channel`() = runBlocking<Unit> { val channel = Channel<Int>() //生产者 val producer = GlobalScope.launch { var i = 0 while (true) { delay(1000)
Kotlin 协程与 Channel（通道）
WriteBug001的博客
07-20 1260
简介Kotlin 中的 Channel（通道）是一种协程间通信的机制，用于在协程之间传递数据。它提供了一种有序、线程安全的方式，让生产者和消费者之间进行异步数据传输。Channel 这个管道的其中一端，是发送方；管道的另一端是接收方。而管道本身，则可以用来传输数据。send()receive()close()itelement在上述示例中，创建了一个对象用于传递整数数据。通过launch函数创建了两个协程，一个用于发送数据，另一个用于接收数据。在发送者协程中，使用send()
Kotlin Channel 发送接收代码执行Xmind版流程图
06-05
Kotlin Channel 发送接收代码执行流程图
Kotlin Channel 热流
feather(猎羽)
08-17 460
2、select 是一个用于多路选择的结构，可以同时等待多个挂起函数或通道的操作完成。它类似于 switch 或 if-else 的多路分支语句，但是它是用于协程的异步操作。produce(capacity = 100)，会增加缓冲区，只要没有放满send不会再阻塞。如果消费完了 isClosedForReceive == true， 否则就是false。1、select: 择优选择数据，谁先返回用谁的。3、select可以用于上游，也可以用于下游。1、广播给所有消费者，多个地方可以接收到。
Android channel 协程之间的通讯
丿灬安之若死
09-03 374
Channel实际上是一个并发安全的队列，它可以用来链接携程，实现不同携程的通信。那么会按照接受者的时间来吐出来元素。如果消费者接受时间比较慢。先全部添加，然后在慢慢取出来。
【深入理解Kotlin协程】协程中的Channel和Flow & 协程中的线程安全问题
川峰的博客
11-15 1887
Channel 实际上就是 个并发安全的队列，它可以用来连接协程，实现不同协程的通信，代码如代码清单所示 上述代码 构造了两个协程 producer 和 consumer, 没有为它们明确指定调度器，所以它们都是采用默认调度器，在 Java 平台上就是基于线程池实现的 Default。 它们可以运行在不同的线程上，也可以运行在同一个线程上，具体执行流程如图 6-2 所示。 producer 每隔 1s 向 Channel 发送 1 个数，consumer 一直读取 channel 来获取这个数字并打印，显
Flow、SharedFlow、StateFlow 傻傻分不清楚
不近视的猫的博客
08-19 1697
SharedFlow 就是观察者模式的一个具体实现，可以对观察者进行注册，当被观察者发生改变的时候，就会通知观察者，同时，SharedFlow 还可以存储之前的变化，即当 SharedFlow 变化后，才有观察者注册，这时观察者仍然能够收到之前的变化。其实，这也很容易理解，因为 delay 的时候，该协程都阻塞了，emit 是不会执行到，而当 delay 之后，collect 都执行完成，这时再 emit，自然也不会再执行 collect 里面的代码。关于 Flow 的说明以及使用，可以参考。...
Kotlin协程Channel浅析
wayne214的博客
11-23 1568
示例代码 使用Channel创建了一组int类型的数据流，通过send发送数据，并通过for循环取出channel中的数据，最后channel是一种协程资源，使用结束后应该及时调用close方法关闭，以免浪费不必要的资源。可以看到上述代码中并没有 取channel中的数据，但是发送的代码正常执行了，这种“不管有没有接收方，发送方都会工作”的模式，就是我们将其认定为“热”的原因。Kotlin协程中的Channel用于处理多个数据组合的流，随用随取，时刻准备着，就像自来水一样，打开开关就有水了。
Android SharedFlow详解
赵彦军
12-13 8308
文章目录什么是SharedFlow实战默认无粘性 什么是SharedFlow SharedFlow 是一个接口，继承 Flow 在使用是，一般使用 MutableSharedFlow SharedFlow 有如下特点： 1、是热数据流 ，及时没有接收者，也会发射数据 2、SharedFlow 是 StateFlow 的可配置性极高的泛化数据流。 3、可以有多个接收器，一个数据可以被多个接收 实战 class MainActivity : AppCompatActivity() { priva
kotlin--Channel、多路复用、并发安全
aruba的博客
09-06 491
一、Channel Channel相较于Flow，Flow是冷流，本质上可以说是一个单线程操作，只有开始收集时，上流代码才会启动，而Channel是一个并发安全的队列，可以用来连接不同的协程，实现不同协程之间的通信 1.Channel的使用 创建一个Channel对象，在不同协程中调用其send和receive函数 fun `test channel`() = runBlocking {...
Kotlin协程-Channel基础
且听真言
10-13 1288
Channel 是一个管道。Channel分为接收方和发送方，发送方发送数据，接收方接收数据。通过Log可以发现@coroutine#3接收、@coroutine#2发送。Channel可以跨越不同的协程进行通信。在 @coroutine#1当中创建的 Channel，然后分别在 @coroutine#2、@coroutine#3 当中使用 Channel 来传递数据。可以发现：上面的例子中通过泛型设置Channel中传递的数据类型是Int，又在协程中调用send方法，把数据发送到管道里。
serialization kotlin
最新发布
03-27
在Kotlin中，序列化是指将对象转换为字节流的过程，以便可以在网络上传输或者保存到文件中。Kotlin提供了一个内置的序列化框架，即Kotlin Serialization。下面是关于Kotlin Serialization的介绍： 1. Kotlin Serialization是什么？ Kotlin Serialization是Kotlin官方提供的一种轻量级的序列化框架，用于将Kotlin对象转换为字节流，以便进行传输或持久化存储。 2. 如何使用Kotlin Serialization？ 使用Kotlin Serialization，你需要在你的Kotlin类上添加`@Serializable`注解，并且在属性上添加`@SerialName`注解来指定序列化后的字段名。然后，你可以使用`Json.encodeToString()`方法将对象序列化为JSON字符串，或使用`Json.decodeFromString()`方法将JSON字符串反序列化为对象。 3. Kotlin Serialization的特性有哪些？ Kotlin Serialization支持以下特性： - 支持枚举类的序列化和反序列化 - 支持泛型类型的序列化和反序列化

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值