影响性能：等待多个通道
来源：stackoverflow
时间：2024-03-08 09:33:24 156浏览 收藏
IT行业相对于一般传统行业，发展更新速度更快，一旦停止了学习，很快就会被行业所淘汰。所以我们需要踏踏实实的不断学习，精进自己的技术，尤其是初学者。今天golang学习网给大家整理了《影响性能：等待多个通道》，聊聊，我们一起来看看吧！
问题内容
我今天发现了一些让我有点困惑的东西，我想由社区运行它，看看我是否遗漏了一些东西，或者可能只是设计得很糟糕。
用例：我有一个输入通道，我想要一个 go 例程来等待该通道上的值。如果上下文被取消，则退出。或者，如果等待输入一段时间而没有收到输入，也可以运行回调。
我从这样的代码开始：
func myroutine(ctx context.context, c <-chan int, callbackinterval *time.duration, callback func() error) {
var timeoutchan <-chan time.time
var timer *time.timer
if callbackinterval != nil {
// if we have a callback interval set, create a timer for it
timer = time.newtimer(*callbackinterval)
timeoutchan = timer.c
} else {
// if we don't have a callback interval set, create
// a channel that will never provide a value.
timeoutchan = make(<-chan time.time, 0)
}
for {
select {
// handle context cancellation
case <-ctx.done():
return
// handle timeouts
case <-timeoutchan:
callback()
// handle a value in the channel
case v, ok := <-c:
if !ok {
// channel is closed, exit out
return
}
// do something with v
fmt.println(v)
}
// reset the timeout timer, if there is one
if timer != nil {
if !timer.stop() {
// see documentation for timer.stop() for why this is needed
<-timer.c
}
// reset the timer
timer.reset(*callbackinterval)
timeoutchan = timer.c
}
}
}
这个设计看起来不错，因为（据我所知）没有办法在 select 中拥有条件 case （我认为 reflect 是可能的，但这通常非常慢），所以不要有两个不同的 selects （一个在需要计时器时带计时器，一个不带计时器）和一个 if 在它们之间进行选择，我只是做了一个 select ，其中如果不需要计时器，计时器通道永远不会提供值。保持干燥。
但后来我开始想知道这对性能的影响。当我们不使用计时器时，在 select 中拥有这个永远不会获取值的额外通道（代替计时器通道）会减慢应用程序的速度吗？
所以，我决定做一些测试来比较。
package main
import (
"context"
"fmt"
"reflect"
"time"
)
func preparechan() chan int {
var count int = 10000000
c := make(chan int, count)
for i := 0; i < count; i++ {
c <- i
}
close(c)
return c
}
func onechan() int64 {
c := preparechan()
foundval := true
start := time.now()
for {
select {
case _, foundval = <-c:
break
}
if !foundval {
break
}
}
ms := time.since(start).milliseconds()
fmt.printf("1 chan - standard: %dms\n", ms)
return ms
}
func twochan() int64 {
c := preparechan()
neverchan1 := make(chan struct{}, 0)
foundval := true
start := time.now()
for {
select {
case _, foundval = <-c:
break
case <-neverchan1:
break
}
if !foundval {
break
}
}
ms := time.since(start).milliseconds()
fmt.printf("2 chan - standard: %dms\n", ms)
return ms
}
func threechan() int64 {
c := preparechan()
neverchan1 := make(chan struct{}, 0)
neverchan2 := make(chan struct{}, 0)
foundval := true
start := time.now()
for {
select {
case _, foundval = <-c:
break
case <-neverchan1:
break
case <-neverchan2:
break
}
if !foundval {
break
}
}
ms := time.since(start).milliseconds()
fmt.printf("3 chan - standard: %dms\n", ms)
return ms
}
func fourchan() int64 {
c := preparechan()
neverchan1 := make(chan struct{}, 0)
neverchan2 := make(chan struct{}, 0)
neverchan3 := make(chan struct{}, 0)
foundval := true
start := time.now()
for {
select {
case _, foundval = <-c:
break
case <-neverchan1:
break
case <-neverchan2:
break
case <-neverchan3:
break
}
if !foundval {
break
}
}
ms := time.since(start).milliseconds()
fmt.printf("4 chan - standard: %dms\n", ms)
return ms
}
func onechanreflect() int64 {
c := reflect.valueof(preparechan())
branches := []reflect.selectcase{
{dir: reflect.selectrecv, chan: c, send: reflect.value{}},
}
start := time.now()
for {
_, _, recvok := reflect.select(branches)
if !recvok {
break
}
}
ms := time.since(start).milliseconds()
fmt.printf("1 chan - reflect: %dms\n", ms)
return ms
}
func twochanreflect() int64 {
c := reflect.valueof(preparechan())
neverchan1 := reflect.valueof(make(chan struct{}, 0))
branches := []reflect.selectcase{
{dir: reflect.selectrecv, chan: c, send: reflect.value{}},
{dir: reflect.selectrecv, chan: neverchan1, send: reflect.value{}},
}
start := time.now()
for {
_, _, recvok := reflect.select(branches)
if !recvok {
break
}
}
ms := time.since(start).milliseconds()
fmt.printf("2 chan - reflect: %dms\n", ms)
return ms
}
func threechanreflect() int64 {
c := reflect.valueof(preparechan())
neverchan1 := reflect.valueof(make(chan struct{}, 0))
neverchan2 := reflect.valueof(make(chan struct{}, 0))
branches := []reflect.selectcase{
{dir: reflect.selectrecv, chan: c, send: reflect.value{}},
{dir: reflect.selectrecv, chan: neverchan1, send: reflect.value{}},
{dir: reflect.selectrecv, chan: neverchan2, send: reflect.value{}},
}
start := time.now()
for {
_, _, recvok := reflect.select(branches)
if !recvok {
break
}
}
ms := time.since(start).milliseconds()
fmt.printf("3 chan - reflect: %dms\n", ms)
return ms
}
func fourchanreflect() int64 {
c := reflect.valueof(preparechan())
neverchan1 := reflect.valueof(make(chan struct{}, 0))
neverchan2 := reflect.valueof(make(chan struct{}, 0))
neverchan3 := reflect.valueof(make(chan struct{}, 0))
branches := []reflect.selectcase{
{dir: reflect.selectrecv, chan: c, send: reflect.value{}},
{dir: reflect.selectrecv, chan: neverchan1, send: reflect.value{}},
{dir: reflect.selectrecv, chan: neverchan2, send: reflect.value{}},
{dir: reflect.selectrecv, chan: neverchan3, send: reflect.value{}},
}
start := time.now()
for {
_, _, recvok := reflect.select(branches)
if !recvok {
break
}
}
ms := time.since(start).milliseconds()
fmt.printf("4 chan - reflect: %dms\n", ms)
return ms
}
func main() {
onechan()
onechanreflect()
twochan()
twochanreflect()
threechan()
threechanreflect()
fourchan()
fourchanreflect()
}
结果：
1 chan - standard: 169ms 1 chan - reflect: 1017ms 2 chan - standard: 460ms 2 chan - reflect: 1593ms 3 chan - standard: 682ms 3 chan - reflect: 2041ms 4 chan - standard: 950ms 4 chan - reflect: 2423ms
它随通道数量线性缩放。事后看来，我认为这是有道理的，因为它必须执行快速循环来轮询每个通道以查看它是否具有值？正如预期的那样，使用 reflect 要慢得多。
无论如何，我的问题是：
这个结果会让其他人感到惊讶吗？我原以为它将使用基于中断的设计，无论
select中的通道数量如何，它都可以保持相同的性能，因为它不需要轮询每个通道。鉴于我试图解决的原始问题（
select中的“可选”情况），最佳/首选设计是什么？答案是否只是有两个不同的select，一个带计时器，一个不带计时器？当我有 2 或 3 个条件/可选计时器来处理各种事情时，这会变得非常混乱。
编辑：
@brits 建议使用 nil 通道来“从不返回值”，而不是初始化通道，即使用 var neverchan1 chan struct{} 而不是 neverchan1 := make(chan struct{}, 0)。以下是新的性能结果：
1 Chan - Standard: 221ms 1 Chan - Reflect: 1639ms 2 Chan - Standard: 362ms 2 Chan - Reflect: 2544ms 3 Chan - Standard: 376ms 3 Chan - Reflect: 3359ms 4 Chan - Standard: 394ms 4 Chan - Reflect: 4123ms
仍然存在影响，最明显的是从 select 中的一个通道变为两个通道，但在第二个通道之后，性能影响比初始化通道小得多。
仍然想知道这是否是最好的解决方案......
正确答案
根据评论，将 select 与“通道从不提供值”的通道一起使用的替代方法是使用 nil 通道 ("never ready for communication")。将 neverchan1 := make(chan struct{}, 0) 替换为 var neverchan1 chan struct{} （或 neverchan1 := chan struct{}(nil)），如下例所示：
func twochan() int64 {
c := preparechan()
var neverchan1 chan struct{} // was neverchan1 := make(chan struct{}, 0)
foundval := true
start := time.now()
for {
select {
case _, foundval = <-c:
break
case <-neverchan1:
break
}
if !foundval {
break
}
}
ms := time.since(start).milliseconds()
fmt.printf("2 chan - standard: %dms\n", ms)
return ms
}
这显着缩小了差距（使用 4 通道版本，因为差异更大 - 我的机器比你的慢一点）：
4 Chan - Standard: 1281ms 4 Chan - Nil: 394ms
是最好的解决方案
没有；但这可能会涉及一些汇编程序！您可以做很多事情可能对此进行改进（here 是一些非常粗略的示例）；然而，它们的有效性将取决于一系列因素（现实生活与设计的测试用例性能通常存在显着差异）。
此时我会问“优化此功能会对整个应用程序产生什么影响？”；除非节省一些 ns 会产生重大影响（即提高利润！）我建议在此停止，直到您：
- 已确认存在需要解决的问题
- 可以在现实场景中使用profile代码（而且，一般来说，我觉得"readability beats speed"）。
今天关于《影响性能：等待多个通道》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！
声明：本文转载于：stackoverflow 如有侵犯，请联系study_golang@163.com删除
相关阅读
更多>
-
502 收藏
-
502 收藏
-
501 收藏
-
501 收藏
-
501 收藏
最新阅读
更多>
-
139 收藏
-
204 收藏
-
325 收藏
-
477 收藏
-
486 收藏
-
439 收藏
-
357 收藏
-
352 收藏
-
101 收藏
-
440 收藏
-
212 收藏
-
143 收藏
课程推荐
更多>
-
- 前端进阶之JavaScript设计模式
- 设计模式是开发人员在软件开发过程中面临一般问题时的解决方案，代表了最佳的实践。本课程的主打内容包括JS常见设计模式以及具体应用场景，打造一站式知识长龙服务，适合有JS基础的同学学习。
- 立即学习 542次学习
-
- GO语言核心编程课程
- 本课程采用真实案例，全面具体可落地，从理论到实践，一步一步将GO核心编程技术、编程思想、底层实现融会贯通，使学习者贴近时代脉搏，做IT互联网时代的弄潮儿。
- 立即学习 508次学习
-
- 简单聊聊mysql8与网络通信
- 如有问题加微信：Le-studyg；在课程中，我们将首先介绍MySQL8的新特性，包括性能优化、安全增强、新数据类型等，帮助学生快速熟悉MySQL8的最新功能。接着，我们将深入解析MySQL的网络通信机制，包括协议、连接管理、数据传输等，让
- 立即学习 497次学习
-
- JavaScript正则表达式基础与实战
- 在任何一门编程语言中,正则表达式,都是一项重要的知识,它提供了高效的字符串匹配与捕获机制,可以极大的简化程序设计。
- 立即学习 487次学习
-
- 从零制作响应式网站—Grid布局
- 本系列教程将展示从零制作一个假想的网络科技公司官网，分为导航，轮播，关于我们，成功案例，服务流程，团队介绍，数据部分，公司动态，底部信息等内容区块。网站整体采用CSSGrid布局，支持响应式，有流畅过渡和展现动画。
- 立即学习 484次学习