“Go 并发编程：处理超时情况的非阻塞通道”

本篇文章向大家介绍《“Go 并发编程：处理超时情况的非阻塞通道”》，主要包括，具有一定的参考价值，需要的朋友可以参考一下。

我阅读了这篇关于如何从多个 conns 获取数据的博客，并尝试尝试一下以了解其工作原理。

func Query(conns []int) string {
    ch := make(chan string)

    go func() {

        for m := range ch {
        log.Println("message => ",m)
        }   

    }()

    for i, conn := range conns {
        go func(c int,loop int) {
            log.Println("start", loop) 

            select {
            case ch <- get(conn,loop):
                log.Println("got", loop)  
            default:
                log.Println("skipped", loop)
            }

            log.Println("exited", loop)
        }(conn,i)
    }


    log.Println("wait")
    time.Sleep(5 * time.Second)
    
    return "done"
}

func get(i int, loop int) string {
   log.Println("process", loop)
   return fmt.Sprintf("return loop %d", loop)
}

如果我在 select 块内注释 default case，它将打印所有消息（预期输出）。

但是，如果我使用非阻塞通道而不注释掉 default 情况，则该通道仅打印一条消息（其他通道将打印“跳过”日志消息）。我不明白为什么传入的消息会出现默认情况。所有消息是否都有可能进入默认情况？我认为所有消息都会被打印，因为 get 函数立即返回。

这是 go 演示的链接

解决方案

1. 在代码上运行 go vet，您会注意到它抛出警告 loop 变量 conn 由 func literal 捕获，因为您使用了 conn 而不是传递的参数，即 c。所以我在我的代码中修复了这个问题。但这与您的问题正交。
2. 让我们了解一下 select 的工作原理（go-tour-5、go-tour-6）：

* a select blocks until one of its cases can run, then it executes that case. 
it chooses one at random if multiple are ready.

* the default case in a select is run if no other case is ready.

因此，如果您使用 select 时没有将其包含在 for 循环中（例如 select { ... }），它可以随机选择任何情况，因为多个情况已准备就绪，或者可能选择默认值，因为其他情况尚未准备好准备好。 select 会阻塞，直到其中一种情况（包括默认情况）可以运行，然后退出。但是，如果您将其包含在 for 循环中（例如 for { select { ... } }）并修改您的实现，那么您可以运行 select 直到它遇到您希望它遇到的情况。当它发生时，goroutine 就会生成并退出。

所以你的想法基本上是一个误解。每次运行都会给出不同的结果（有时也相同）；没有保证，因为如果多个情况已准备好，则 select 可以选择任何情况，或者如果情况未准备好，则使用 default 情况。

尝试一下这个程序并了解我更改的部分：

package main

import (
    "fmt"
    "log"
    "time"
)

func query(conns []int) string {
    ch := make(chan string)

    // receiver
    go func() {
        for m := range ch {
            log.println("message: ", m)
        }
    }()

    // sender
    for i, conn := range conns {
        go func(c, loop int) {
            log.println("start: ", loop)
            for {
                select {
                case ch <- get(c, loop):
                    log.println("got: ", loop)
                    log.println("exited: ", loop)
                    return
                default:
                    log.println("skipped: ", loop)
                }
            }
        }(conn, i)
    }

    log.println("wait")
    time.sleep(5 * time.second)

    return "done"
}

func get(i, loop int) string {
    log.println("process: ", loop)
    return fmt.sprintf("return loop: %d", loop)
}

func main() {
    res := query([]int{1, 2, 3})
    fmt.println(res)
}

Go Playground Link

其中一次运行的输出：

2020/08/03 00:50:31 wait
2020/08/03 00:50:31 start:  0
2020/08/03 00:50:31 process:  0
2020/08/03 00:50:31 got:  0
2020/08/03 00:50:31 exited:  0
2020/08/03 00:50:31 start:  1
2020/08/03 00:50:31 process:  1
2020/08/03 00:50:31 skipped:  1
2020/08/03 00:50:31 process:  1
2020/08/03 00:50:31 skipped:  1
2020/08/03 00:50:31 process:  1
2020/08/03 00:50:31 skipped:  1
2020/08/03 00:50:31 start:  2
2020/08/03 00:50:31 process:  2
2020/08/03 00:50:31 skipped:  2
2020/08/03 00:50:31 process:  2
2020/08/03 00:50:31 skipped:  2
2020/08/03 00:50:31 process:  2
2020/08/03 00:50:31 skipped:  2
2020/08/03 00:50:31 process:  2
2020/08/03 00:50:31 skipped:  2
2020/08/03 00:50:31 process:  2
2020/08/03 00:50:31 skipped:  2
2020/08/03 00:50:31 process:  2
2020/08/03 00:50:31 skipped:  2
2020/08/03 00:50:31 process:  1
2020/08/03 00:50:31 skipped:  1
2020/08/03 00:50:31 process:  1
2020/08/03 00:50:31 skipped:  1
2020/08/03 00:50:31 process:  1
2020/08/03 00:50:31 skipped:  1
2020/08/03 00:50:31 process:  1
2020/08/03 00:50:31 skipped:  1
2020/08/03 00:50:31 process:  1
2020/08/03 00:50:31 message:  return loop: 0
2020/08/03 00:50:31 process:  2
2020/08/03 00:50:31 got:  2
2020/08/03 00:50:31 exited:  2
2020/08/03 00:50:31 message:  return loop: 2
2020/08/03 00:50:31 skipped:  1
2020/08/03 00:50:31 process:  1
2020/08/03 00:50:31 got:  1
2020/08/03 00:50:31 exited:  1
2020/08/03 00:50:31 message:  return loop: 1
done

请注意，我收到了接收者 goroutine 收到的所有 return loop 消息。

编辑： 我们可以看到 goroutine 多次使用了默认情况，这表明通道必须被阻塞（情况尚未准备好）。这是因为通道没有缓冲。

因此 ch := make(chan string) 可以修改为非阻塞，使其成为缓冲通道。这是 Go Playground 上改进版本的链接。

package main

import (
    "fmt"
    "log"
    "time"
)

func query(conns []int) string {
    // buffered channel with a size of 3
    ch := make(chan string, 3)

    // receiver
    go func() {
        for m := range ch {
            log.println("message: ", m)
        }
    }()

    // sender
    for i, conn := range conns {
        go func(c, loop int) {
            log.println("start: ", loop)
            for {
                select {
                case ch <- get(c, loop):
                    log.println("got: ", loop)
                    log.println("exited: ", loop)
                    return
                default:
                    log.println("skipped: ", loop)
                }
            }
        }(conn, i)
    }

    log.println("wait")
    time.sleep(5 * time.second)

    return "done"
}

func get(i, loop int) string {
    log.println("process: ", loop)
    return fmt.sprintf("return loop: %d", loop)
}

func main() {
    res := query([]int{1, 2, 3})
    fmt.println(res)
}

其中一次运行的输出：

2009/11/10 23:00:00 wait
2009/11/10 23:00:00 start:  0
2009/11/10 23:00:00 process:  0
2009/11/10 23:00:00 got:  0
2009/11/10 23:00:00 exited:  0
2009/11/10 23:00:00 start:  1
2009/11/10 23:00:00 process:  1
2009/11/10 23:00:00 got:  1
2009/11/10 23:00:00 exited:  1
2009/11/10 23:00:00 start:  2
2009/11/10 23:00:00 process:  2
2009/11/10 23:00:00 got:  2
2009/11/10 23:00:00 exited:  2
2009/11/10 23:00:00 message:  return loop: 0
2009/11/10 23:00:00 message:  return loop: 1
2009/11/10 23:00:00 message:  return loop: 2
done

本篇关于《“Go 并发编程：处理超时情况的非阻塞通道”》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注golang学习网公众号！