Ich möchte, dass mein Routinearbeiter geht ProcessToDo() im Code unten), um zu warten, bis alle in der Warteschlange befindlichen Vorgänge verarbeitet wurden, bevor der Computer heruntergefahren wird.

Die Worker-Routine verfügt über einen (gepufferten) "zu erledigenden" Kanal, über den die Arbeit an sie gesendet wird. Und es hat einen "Fertig" -Kanal, der es anweist, das Herunterfahren zu starten. Die Dokumentation besagt, dass die Auswahl auf den Kanälen einen "Pseudozufallswert" auswählt, wenn mehr als eine Auswahl getroffen wird ... was bedeutet, dass das Herunterfahren (Zurückkehren) ausgelöst wird, bevor die gesamte gepufferte Arbeit abgeschlossen ist.

Im folgenden Codebeispiel sollen alle 20 Nachrichten gedruckt werden ...

package main

import (
    "time"
    "fmt"
)


func ProcessToDo(done chan struct{}, todo chan string) {
    for {
        select {
        case work, ok := <-todo:
            if !ok {
                fmt.Printf("Shutting down ProcessToDo - todo channel closed!\n")
                return
            }
            fmt.Printf("todo: %q\n", work)
            time.Sleep(100 * time.Millisecond)
        case _, ok := <-done:
            if ok {
                fmt.Printf("Shutting down ProcessToDo - done message received!\n")
            } else {
                fmt.Printf("Shutting down ProcessToDo - done channel closed!\n")
            }
            close(todo)
            return
        }
    }
}

func main() {

    done := make(chan struct{})
    todo := make(chan string, 100)

    go ProcessToDo(done, todo)

    for i := 0; i < 20; i++ {
        todo <- fmt.Sprintf("Message %02d", i)
    }

    fmt.Println("*** all messages queued ***")
    time.Sleep(1 * time.Second)
    close(done)
    time.Sleep(4 * time.Second)
}