我可以重新打开已关闭的频道吗？

Question

我想知道关闭频道后是否可以重新打开它。

测试用例：

1. 我有一个频道，里面有一些东西
2. 我想覆盖它们，因此我需要提前关闭通道
3. 我想在通道中放入更多内容并再次迭代它

go func() {
    queue <- "1"
    queue <- "2"
    close(queue)
}()

for i := range queue {
    go func(i string) {
        fmt.Println("From queue: ", i)
    }(i)
}

go func() {
    open(queue)
    queue <- "3"
    queue <- "4"
    close(queue)
}()

for i := range queue {
    go func(i string) {
        fmt.Println("From queue: ", i)
    }(i)
}

• 当然open不存在。我怎样才能在 Go 中实现我需要的东西？
• 我不想使用睡眠功能

Answer 1

我想覆盖它们，因此我需要提前关闭通道

不，不需要关闭通道。当另一个项目通过通道推送时，它将恢复迭代。

以下代码接受控制台输入并将其推送到通道：

主程序

package main

import (
    "log"
    "bufio"
    "os"
    "fmt"
)

func process(c chan string) {
    for s := range c {
        log.Println("processed", s)
    }
}

func main() {
    c := make(chan string, 10)
    go process(c)

    // get from console and process
    reader := bufio.NewReader(os.Stdin)
    fmt.Println("INPUT STUFF. TYPE #quit TO EXIT.")
    for {
        input, _, _ := reader.ReadLine()
        if string(input) == "#quit" {
            break
        }
        c <- string(input)
    }

    log.Println("BYE!")
}

输出

INPUT STUFF. TYPE #quit TO EXIT.
hello
2018/10/23 10:43:52 processed hello
world
2018/10/23 10:43:54 processed world
#quit
2018/10/23 10:43:57 BYE!

下面的示例使用并可作为 Go Playground代码片段Sleep()运行

package main

import (
    "log"
    "time"
)

func process(c chan string) {
    for s := range c {
        log.Println("processed", s)
    }
}

func main() {
    c := make(chan string, 10)

    go process(c)

    // push some data
    c <- "barry allen"
    c <- "iris west"

    time.Sleep(time.Second * 2)

    // push more data
    c <- "joe west"
    c <- "caitlin snow"

    time.Sleep(time.Second * 3)
}

输出

2009/11/10 23:00:00 processed barry allen
2009/11/10 23:00:00 processed iris west
2009/11/10 23:00:02 processed joe west
2009/11/10 23:00:02 processed caitlin snow

希望这可以帮助。干杯，

Answer 2

您无法重新打开关闭的频道，但您可以channel在频道上发送，也许这就是您正在寻找的？

package main

import (
    "fmt"
    "time"
)

func main() {
    queue := make(chan chan int)
    defer close(queue)

    go func() { // reader
        for {
            ch := <-queue
            for i := range ch {
                fmt.Println(i)
            }
            fmt.Println("Done with this channel")
        }
    }()

    go func() { // writer-1
        ch := make(chan int)
        defer close(ch)
        queue <- ch
        ch <- 4
        ch <- 2
    }()

    go func() { // writer-2
        ch := make(chan int)
        defer close(ch)
        queue <- ch
        ch <- 4
        ch <- 20
    }()
    time.Sleep(time.Second)
}