从同一 channel 读取的两个 go 例程。在 done channel 关闭后，第一个 go 例程从不打印其关闭消息，而第二个 go 例程始终打印。

为什么第一个 go 例程的消息没有打印出来，方法甚至返回？

主.go

func main() {
done := make(chan bool)
c := make(chan os.Signal, 1)

cameras := client.CameraConfig()
client.DrawUserControls(cameras)

operator := client.NewOperator(cameras)
go operator.UserInputListener(done)
go operator.ParseAndExecuteUserCommand(done)

signal.Notify(c, os.Interrupt)
for range c {
    close(done)
    break
}

log.Println("Interrupt signal received. Shutting client down....")
time.Sleep(5 * time.Second)
}

客户端.go

func (o *Operator) UserInputListener(done <-chan bool) {
    reader := bufio.NewReader(os.Stdin)
    for {
        select {
        case <-done:
            log.Println("Keyboard listener shutting down.") // <-- this never prints
            return
        default:
            line, _, err := reader.ReadLine()
            if err != nil {
                log.Println(err)
            }

            data := strings.Split(string(line), "")

            id, err := strconv.Atoi(data[1])
            if err != nil {
                log.Println(err)
                continue
            }

            switch data[0] {
            case "b":
                o.Controls <- Ctrl{
                    Identifier: id,
                    Ctrl:       "run",
                }
            case "t":
                o.Controls <- Ctrl{
                    Identifier: id,
                    Ctrl:       "terminate",
                }
            case "r":
                o.Controls <- Ctrl{
                    Identifier: id,
                    Ctrl:       "record",
                }
            case "s":
                o.Controls <- Ctrl{
                    Identifier: id,
                    Ctrl:       "stop",
                }
            }
        }
    }
}

func (o *Operator) ParseAndExecuteUserCommand(done <-chan bool) {
    for {
        select {
        case <-done:
            log.Println("Command operator shutting down.")
            return
        case ctrl := <-o.Controls:
            switch ctrl.Ctrl {
            case "run":
                o.Room[ctrl.Identifier].Run()
            case "terminate":
                o.Room[ctrl.Identifier].Close()
            case "record":
                o.Room[ctrl.Identifier].Write()
            case "stop":
                o.Room[ctrl.Identifier].Stop()
            }
        }
    }
}

最佳答案

原因是因为你创建了同步 channel ，你推送了1条消息，然后你也只能读取一次。那是因为您只能从 done channel 中读取 1 个(随机)。

关闭 goroutine 的方法是使用 WaitGroup:
主要Go:

var (
    done            chan bool
)

func main() {
    cameras := client.CameraConfig()
    client.DrawUserControls(cameras)
    operator := client.NewOperator(cameras)

    done = make(chan bool, 1)
    wg := &sync.WaitGroup{}
    wg.Add(2)
    go operator.UserInputListener(done, wg)
    go operator.ParseAndExecuteUserCommand(done, wg)

    handleShutdown()
    wg.Wait()
}


func handleShutdown() {
    ch := make(chan os.Signal, 1)
    go func() {
        <-ch //wait for application terminating
        log.Println("Shutdown received.")
        close(done)
    }()
    signal.Notify(ch, os.Interrupt, syscall.SIGTERM, syscall.SIGHUP)
}

客户端.go:

func (o *Operator) UserInputListener(done <-chan bool, wg *sync.WaitGroup) {
    defer wg.Done()
    for {
        select {
        case <-done:
            log.Println("Keyboard listener shutting down.") 
            return
        ........
        }
    }
}

func (o *Operator) ParseAndExecuteUserCommand(done <-chan bool, wg *sync.WaitGroup) {
    defer wg.Done()
    for {
        select {
        case <-done:
            log.Println("Command operator shutting down.") 
            return
        ........
        }
    }
}

使用这个 link详情

关于关闭 channel `shutdown msg` 后执行例程不打印 `done`，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/45571628/