影响性能：等待多个通道

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 要慢得多。

无论如何，我的问题是：

1. 这个结果会让其他人感到惊讶吗？我原以为它将使用基于中断的设计，无论 select 中的通道数量如何，它都可以保持相同的性能，因为它不需要轮询每个通道。

2. 鉴于我试图解决的原始问题（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学习网公众号！