Question

我试图弄清楚关闭通道后是否可以重新打开通道。

测试用例：

我的频道中有一些东西
我想覆盖它们，因此我需要提前关闭通道
我想在频道中添加更多内容并再次进行遍历

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

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

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

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

main.go

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!

以下示例使用Sleep()，并且可以作为围棋场snippet

运行

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，也许是this is what you're looking for？

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)
}

我可以重新打开一个封闭的频道吗？

2 个答案: