En goroutine er en lettvekts, samtidig utførende funksjon administrert av Go-kjøretiden. Det er så enkelt som å sette go foran et funktjonskall. Goroutines er Gos signatur-samkjøringsfunksjon — langt billigere enn OS-tråder, slik at du kan kjøre tusenvis eller millioner.
{
fmt.Println()
}
sayHello()
{
fmt.Println()
}()
go-nøkkelordet starter funksjonen på en ny goroutine og returnerer umiddelbart — den kallende koden fortsetter uten å vente.
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 er ikke OS-tråder — Go-planleggeren multiplekserer mange goroutines på noen få OS-tråder. Dette gjør dem ekstraordinært billige, noe som muliggjør massiv samkjøring (f.eks. en goroutine per tilkobling i en server som håndterer millioner av tilkoblinger).
func main() {
go sayHello() // ❌ main might EXIT before this goroutine runs → nothing printed
// program ends immediately
}
Når main returnerer, avsluttes programmet — og dreper eventuelle fortsatt kjørende goroutines. Du må koordinere.
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 er standardmåten å vente på at et sett med goroutines blir fullført.
ch := make(chan string)
go func() { ch <- "result" }() // send a result on the channel
msg := <-ch // receive (blocks until a value arrives)
Go-filosofien: "Ikke kommuniser ved å dele minne; del minne ved å kommunisere" — bruk kanaler for å sende data mellom goroutines i stedet for delte variabler + låser.
Goroutines er Gos definisjonskarakteristikk og hovedgrunnen til at det utmerker seg ved samtidige, nettverkbaserte systemer.
Deres ekstreme letthet (kilobytes versus megabytes for tråder, planlagt M:N på OS-tråder) gjør massiv samkjøring praktisk og enkel — en server kan spawne en goroutine per forespørsel eller tilkobling uten ressursbekymringer, noe som er vanskelig eller umulig med OS-tråder.
Å forstå hvordan du starter dem (go), det kritiske behovet for synkronisering (main som avsluttes dreper goroutines; bruk WaitGroup for å vente), og Gos preferanse for kommunisering via kanaler fremfor delt minne, er grunnleggende for å skrive korrekt samtidi Go.
Goroutines (og mønstrene rundt dem) er sentrale for Gos verdierklæring og blant de viktigste og hyppigst testede emnene i språket.