Brak wyjścia z goroutine w Go

Question

Podczas gdy SayHello() wykonuje się zgodnie z oczekiwaniami, goroutine nic nie drukuje.

package main 

import "fmt" 

func SayHello() { 
    for i := 0; i < 10 ; i++ { 
     fmt.Print(i, " ") 
    } 
} 

func main() { 
    SayHello() 
    go SayHello() 
} 

Answer 1

Po zakończeniu funkcji main() Twój program również się kończy. Nie czeka na zakończenie innych goroutinów.

Cytując z Go Language Specification: Program Execution:

wykonanie programu rozpoczyna się od inicjalizacji główny pakiet, a następnie wywołując funkcję main. Gdy funkcja ta powróci, program zostanie zamknięty. Nie czeka na zakończenie innych (nie main) gorutyn.

Aby uzyskać więcej informacji, zobacz this answer.

Musisz powiedzieć swojej funkcji main(), aby poczekać na zakończenie funkcji SayHello() jako goroutine. Możesz zsynchronizować je z kanałów na przykład:

func SayHello(done chan int) { 
    for i := 0; i < 10; i++ { 
     fmt.Print(i, " ") 
    } 
    if done != nil { 
     done <- 0 // Signal that we're done 
    } 
} 

func main() { 
    SayHello(nil) // Passing nil: we don't want notification here 
    done := make(chan int) 
    go SayHello(done) 
    <-done // Wait until done signal arrives 
} 

Inną alternatywą jest sygnał zakończenia zamykając kanał:

func SayHello(done chan struct{}) { 
    for i := 0; i < 10; i++ { 
     fmt.Print(i, " ") 
    } 
    if done != nil { 
     close(done) // Signal that we're done 
    } 
} 

func main() { 
    SayHello(nil) // Passing nil: we don't want notification here 
    done := make(chan struct{}) 
    go SayHello(done) 
    <-done // A receive from a closed channel returns the zero value immediately 
} 

Uwagi:

Według swoje modyfikacje/komentarz: jeśli chcesz, aby 2 działające funkcje SayHello() drukowały losowo "mieszane" numery: nie masz gwarancji, że będziesz obserwować takie zachowanie. Ponownie zobacz aforementioned answer, aby uzyskać więcej informacji. Go Memory Model gwarantuje tylko, że pewne zdarzenia zdarzają się przed innymi zdarzeniami, nie masz gwarancji, jak zostaną wykonane 2 równoczesne goroutiny.

Możesz eksperymentować z tym, ale wiedz, że wynik nie będzie deterministyczny. Najpierw trzeba włączyć wiele aktywnych goroutines być wykonany z:

runtime.GOMAXPROCS(2) 

A po drugie trzeba najpierw uruchomić SayHello() jako goroutine ponieważ aktualna kod najpierw wykonuje SayHello() w głównym goroutine i dopiero po jej zakończeniu rozpoczyna się druga jeden:

runtime.GOMAXPROCS(2) 
done := make(chan struct{}) 
go SayHello(done) // FIRST START goroutine 
SayHello(nil) // And then call SayHello() in the main goroutine 
<-done // Wait for completion 

Answer 2

Alternatywnie (aby odpowiedzieć icza'S) można użyć WaitGroup z sync pakietu i funkcji anonimowej, aby uniknąć zmieniania oryginalnego SayHello.

package main 

import (
    "fmt" 
    "sync" 
) 

func SayHello() { 
    for i := 0; i < 10; i++ { 
     fmt.Print(i, " ") 
    } 
} 

func main() { 
    SayHello() 

    var wg sync.WaitGroup 
    wg.Add(1) 

    go func() { 
     defer wg.Done() 
     SayHello() 
    }() 

    wg.Wait() 
} 

W celu wydrukowania numerów jednocześnie uruchomić każdą instrukcję drukowania w oddzielnej procedurze jak na poniższym

package main 

import (
    "fmt" 
    "math/rand" 
    "sync" 
    "time" 
) 

func main() { 
    var wg sync.WaitGroup 

    for i := 0; i < 10; i++ { 
     wg.Add(1) 
     go func(fnScopeI int) { 
      defer wg.Done() 

      // next two strings are here just to show routines work simultaneously 
      amt := time.Duration(rand.Intn(250)) 
      time.Sleep(time.Millisecond * amt) 

      fmt.Print(fnScopeI, " ") 
     }(i) 
    } 

    wg.Wait() 
}