Goroutine to lekka funkcja wykonywana równolegle, zarządzana przez środowisko uruchomieniowe Go. Uruchomienie goroutine to nic innego jak dodanie go przed wywołaniem funkcji. Goroutines to sygnaturowa cecha współbieżności Go — znacznie tańsze niż wątki OS, dzięki czemu możesz uruchomić tysiące lub miliony.
{
fmt.Println()
}
sayHello()
{
fmt.Println()
}()
Slowo kluczowe go uruchamia funkcję na nowym goroutine i natychmiast zwraca kontrolę — kod wywołujący kontynuuje bez czekania.
OS thread: ~1–2 MB of memory each → thousands max
Goroutine: ~2 KB initial stack (grows as needed) → MILLIONS feasible
The Go runtime SCHEDULES many goroutines onto a small pool of OS threads (M:N).
Goroutines nie są wątkami OS — scheduler Go multipleksuje wiele goroutines na kilka wątków OS. To czyni je niezwykle tanimi, umożliwiając masową współbieżność (np. jeden goroutine na każde połączenie na serwerze obsługującym miliony połączeń).
func main() {
go sayHello() // ❌ main might EXIT before this goroutine runs → nothing printed
// program ends immediately
}
Kiedy main zwraca kontrolę, program się kończy — zabijając wszystkie wciąż działające goroutines. Musisz koordynować ich pracę.
var wg sync.WaitGroup
for i := 0; i < 3; i++ {
wg.Add(1) // increment the counter
go func(n int) {
defer wg.Done() // decrement when this goroutine finishes
fmt.Println("worker", n)
}(i) // pass i as an argument (avoid the loop-var capture bug)
}
wg.Wait() // BLOCK until all goroutines call Done()
sync.WaitGroup to standardowy sposób czekania na ukończenie zestawu goroutines.
ch := make(chan string)
go func() { ch <- "result" }() // send a result on the channel
msg := <-ch // receive (blocks until a value arrives)
Filozofii Go: "Nie komunikuj się dzieląc pamięć; dziel pamięć poprzez komunikację" — używaj kanałów do przesyłania danych między goroutines zamiast zmiennych wspólnych + blokad.
Goroutines są definiującą cechą Go i głównym powodem, dla którego doskonale sprawdza się w systemach współbieżnych i sieciowych.
Ich ekstremalna lekkość (kilkabajty vs megabajty dla wątków, planowane M:N na wątkami OS) sprawia, że masowa współbieżność jest praktyczna i łatwa — serwer może uruchomić goroutine dla każdego żądania czy połączenia bez obaw o zasoby, co jest trudne lub niemożliwe z wątkami OS.
Zrozumienie jak je uruchamiać (go), krytycznej potrzeby synchronizacji (main kończący pracę zabija goroutines; użyj WaitGroup do czekania) i preferencji Go dla komunikacji poprzez kanały zamiast pamięci wspólnej jest fundamentalne dla pisania poprawnego kodu współbieżnego w Go.
Goroutines (i wzorce wokół nich) są kluczowe dla propozycji wartości Go i należą do najważniejszych i najczęściej testowanych tematów w języku.