A goroutine is a lightweight, concurrently-executing function managed by the Go runtime. Launching one is as simple as putting go before a function call. Goroutines are Go's signature concurrency feature — far cheaper than OS threads, so you can run thousands or millions.
{
fmt.Println()
}
sayHello()
{
fmt.Println()
}()
The go keyword starts the function on a new goroutine and returns immediately — the calling code continues without waiting.
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 are not OS threads — the Go scheduler multiplexes many goroutines onto a few OS threads. This makes them extraordinarily cheap, enabling massive concurrency (e.g. one goroutine per connection in a server handling millions of connections).
func main() {
go sayHello() // ❌ main might EXIT before this goroutine runs → nothing printed
// program ends immediately
}
When main returns, the program ends — killing any still-running goroutines. You need to coordinate.
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 is the standard way to wait for a set of goroutines to complete.
ch := make(chan string)
go func() { ch <- "result" }() // send a result on the channel
msg := <-ch // receive (blocks until a value arrives)
The Go philosophy: "Don't communicate by sharing memory; share memory by communicating" — use channels to pass data between goroutines rather than shared variables + locks.
Goroutines are Go's defining feature and the main reason it excels at concurrent, networked systems.
Their extreme lightness (kilobytes vs megabytes for threads, scheduled M:N onto OS threads) makes massive concurrency practical and easy — a server can spawn a goroutine per request or connection without resource concerns, which is hard or impossible with OS threads.
Understanding how to launch them (go), the critical need to synchronize (main exiting kills goroutines; use WaitGroup to wait), and Go's preference for communicating via channels over shared memory is fundamental to writing correct concurrent Go.
Goroutines (and the patterns around them) are central to Go's value proposition and among the most important and frequently-tested topics in the language.