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

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

您无法重新打开已关闭的频道，但您可以在频道上发送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)
}

Answer 2

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

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

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

ma​​in.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() 并且可作为 Go Playground 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 3

虽然您无法重新打开通道，但可以创建一个新通道并分配给变量。先前关闭的通道将被垃圾收集。在这种情况下，我重用了 queue 变量，但您也可以创建一个新的 queue2 变量并将其传递给 goroutine。

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    ctx := context.Background()
    ctx, cancel := context.WithCancel(ctx)
    queue := make(chan int)
    go printFormat(nil, queue)
    queue <- 1
    queue <- 2
    close(queue)
    // fake some actions in between
    time.Sleep(2 * time.Second)
    queue = make(chan int)
    go printFormat(cancel, queue)
    queue <- 3
    queue <- 4
    close(queue)
    <-ctx.Done()
}

func printFormat(c context.CancelFunc, q chan int) {
    for i := range q {
        fmt.Printf("Data %d \n", i)
    }
    if c != nil {
        c()
    }
}