A blog about programming, Web development, Open Source, Linux and DevOps.

Go - Goroutines

A goroutine is a lightweight thread managed by the Go runtime.

Create a Goroutine

When a program starts a main goroutine calls the main function, new goroutines are created with the go statement.

// Regular function call.
// Call the function `f` and wait for it to return.
// Create a new goroutine that calls `f` and don't wait for it to return.
// When the function terminates, its goroutine also terminates and the values
// returned by the function are ignored.
go f()
// The function value and parameters are evaluated in the calling goroutine
// and the execution of the function happens in a new goroutine.
go doSomething(x, y, z)
// Create a goroutine with a closure (anonymous function).
go func() {
// Code to execute concurrently

Goroutines run in the same address space, so access to shared memory must be synchronized.

Wait for Goroutines

A sync.WaitGroup can be used to wait for goroutines to complete their work.

import "sync"
// Declare a `WaitGroup` variable.
// No need to initialize it, the zero value is useful.
var wg sync.WaitGroup
// The main goroutine calls `Add` to set the number of goroutines to wait for.
// Each goroutine calls `Done` when finished.
go func() {
defer wg.Done()
// Block until all the goroutines have finished.


package main
import (
func main() {
var wg sync.WaitGroup
// Create 10 goroutines and wait for them to complete.
for i := 0; i < 10; i++ {
// The `Add` method is called before creating the goroutine.
wg.Add(1) // Increment the WaitGroup counter
go func(i int) {
defer wg.Done() // Decrement the counter when the goroutine completes
// Wait for all the goroutines to complete.
wg.Wait() // Block until the counter becomes 0