So schließen Sie Golang-Coroutine

1. Leiten Sie das Ausgangssignal über den Kanal weiter.

Der Kanal ist ein grundlegender Datentyp. Er hat drei Grundzustände: Null, offen , geschlossen.

Teilen Sie Daten über den Kanal, anstatt Daten über den gemeinsamen Speicher zu teilen. Der Hauptprozess kann über den Kanal ein Stoppsignal an jede Goroutine senden, wie folgt:

func run(done chan int) {
        for {
                select {
                case <-done:
                        fmt.Println("exiting...")
                        done <- 1
                        break
                default:
                }
 
                time.Sleep(time.Second * 1)
                fmt.Println("do something")
        }
}
 
func main() {
        c := make(chan int)
 
        go run(c)
 
        fmt.Println("wait")
        time.Sleep(time.Second * 5)
 
        c <- 1
        <-c
 
        fmt.Println("main exited")
}

2. Verwenden Sie die Wartegruppe

Normalerweise verwenden wir die Wartegruppe wie folgt :

1. Erstellen Sie eine Instanz von Waitgroup, vorausgesetzt, wir nennen sie wg.

2. Rufen Sie beim Start jeder Goroutine wg.Add(1) auf startet, kann es auch innerhalb von Goroutine aufgerufen werden. Natürlich können Sie auch wg.Add(n)

aufrufen, bevor Sie n Goroutinen erstellen. 3. Nachdem jede Goroutine ihre Aufgabe abgeschlossen hat, rufen Sie wg.Done()

auf Die Goroutine ruft wg.Wait() auf, was blockiert, bevor alle Goroutinen, die wg.Add(1) ausgeführt haben, wg.Done() aufgerufen haben. Es wird zurückgegeben, nachdem alle Goroutinen wg.Done() aufgerufen haben.

Beispiel:

type Service struct {
        // Other things
 
        ch        chan bool
        waitGroup *sync.WaitGroup
}
 
func NewService() *Service {
	s := &Service{
                // Init Other things
                ch:        make(chan bool),
                waitGroup: &sync.WaitGroup{},
	}
 
	return s
}
 
func (s *Service) Stop() {
        close(s.ch)
        s.waitGroup.Wait()
}
 
func (s *Service) Serve() {
        s.waitGroup.Add(1)
        defer s.waitGroup.Done()
 
        for {
                select {
                case <-s.ch:
                        fmt.Println("stopping...")
                        return
                default:
                }
                s.waitGroup.Add(1)
                go s.anotherServer()
	}
}
func (s *Service) anotherServer() {
        defer s.waitGroup.Done()
        for {
                select {
                case <-s.ch:
                        fmt.Println("stopping...")
                        return
                default:
                }
 
                // Do something
        }
}
 
func main() {
 
        service := NewService()
        go service.Serve()
 
        // Handle SIGINT and SIGTERM.
        ch := make(chan os.Signal)
        signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
        fmt.Println(<-ch)
 
        // Stop the service gracefully.
        service.Stop()
}

Für mehr Golang-Wissen beachten Sie bitte die Spalte Golang-Tutorial.

Das obige ist der detaillierte Inhalt vonSo schließen Sie Golang-Coroutine. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!