Overview and
Goroutine Basics

Time spent waiting becomes wall-clock time

// sequential — the waits pile up
a := fetch(u1)   // 100ms
b := fetch(u2)   // 100ms
c := fetch(u3)   // 100ms
// total 300ms

// concurrent — the waits overlap
for i, u := range urls {
    go func() { out[i] = fetch(u) }()
}
wg.Wait()
// total ~100ms

Where today sits in the whole series

What we cover today

Often mixed up, but different words

Same two tasks, two different pictures

One sentence from Go's creator

The model Go picked — CSP

Communicating Sequential Processes, proposed by Tony Hoare in 1978. There is only one core idea — independent processes communicate by passing messages.

Do not communicate by sharing memory; share memory by communicating

Concurrency is not free

Scattering goroutines does not make things faster. You pay the cost of complexity first.

Put go in front of a call. That is all

// create a goroutine — the go keyword
go func() {
    fmt.Println("goroutine ran")
}()

// named functions work too
go sayHello("World")

How is it different from an OS thread

Put 2KB and 1MB on the same axis

Execution order is not guaranteed

const numGoroutines = 10
wg.Add(numGoroutines)

for i := range numGoroutines {
    go func() {
        defer wg.Done()
        mu.Lock()
        order = append(order, i)
        mu.Unlock()
    }()
}
wg.Wait()
t.Logf("exec order: %v", order)

// exec order: [1 4 2 3 5 9 8 0 6 7]

When main ends, everything ends

main() runs on the main goroutine. Once it returns, the process exits regardless of whether other goroutines finished.

func TestMainExitKillsGoroutines(t *testing.T) {
    var completed atomic.Bool

    go func() {
        time.Sleep(100 * time.Millisecond)
        completed.Store(true)
    }()

    // without waiting it never completes
    assert.False(t, completed.Load())
}

How to wait — sync.WaitGroup

func TestWaitGroupSolution(t *testing.T) {
    var completed atomic.Bool
    var wg sync.WaitGroup

    wg.Add(1)
    go func() {
        defer wg.Done()
        time.Sleep(50 * time.Millisecond)
        completed.Store(true)
    }()

    wg.Wait() // block until done
    assert.True(t, completed.Load())
}

Create 10,000 and nothing happens

const numGoroutines = 10000
var counter atomic.Int64
var wg sync.WaitGroup
wg.Add(numGoroutines)

for range numGoroutines {
    go func() {
        defer wg.Done()
        counter.Add(1)
    }()
}

wg.Wait()
assert.Equal(t, int64(numGoroutines), counter.Load())

A structure in three letters — G · M · P

One trip around the loop

GOMAXPROCS — how many can run at once

It is not how many goroutines you can create; it sets how many Ps exist. The default is the CPU core count.

func TestGOMAXPROCS(t *testing.T) {
    // passing 0 returns the current value unchanged
    currentProcs := runtime.GOMAXPROCS(0)
    numCPU := runtime.NumCPU()

    t.Logf("NumCPU: %d", numCPU)           // 12
    t.Logf("GOMAXPROCS: %d", currentProcs) // 12

    runtime.GOMAXPROCS(1) // down to one P
}

All four side by side

The biggest difference is when it yields

// suspends only at suspend points
suspend fun fetchData() {
    delay(1000)  // yields here

    // CPU work without suspend
    // never yields
}

// runtime switches, no keyword
func fetchData() {
    time.Sleep(time.Second)

    // CPU-bound work too is
    // forcibly switched (Go 1.14+)
}

Function coloring — Go has no colors

suspend fun a() = b()
suspend fun b() = c()
suspend fun c() = delay(100)

// the moment c becomes suspend,
// suspend spreads up the whole chain

func a() { b() }
func b() { c() }
func c() { time.Sleep(t) }

go a()  // any func as a goroutine
a()     // or just call it

Java — closer now with virtual threads

// Platform Thread — 1:1 with an OS thread
new Thread(() -> doWork()).start();
// ~1MB stack allocated

// Virtual Thread (Java 21+) — goroutine-like
Thread.startVirtualThread(() -> doWork());

Recap — what goroutines got and did not get

A goroutine that stays alive instead of ending

It is no longer needed yet never finishes. It holds memory and is not a GC candidate, so usage keeps climbing over time.

// counting live goroutines shows it
runtime.NumGoroutine()

The leaky code, and the fixed code

leakyFunc := func() <-chan int {
    ch := make(chan int)
    go func() {
        ch <- 42 // blocks forever if nobody receives
    }()
    return ch
}

_ = leakyFunc() // returned but never used → leak!

time.Sleep(50 * time.Millisecond)
runtime.NumGoroutine() // 2 at start → 3 after the leak

safeFunc := func(ctx context.Context) <-chan int {
    ch := make(chan int, 1) // buffered → send never blocks
    go func() {
        defer close(ch)
        select {
        case ch <- 42:     // value delivered normally
        case <-ctx.Done(): // exit when context is cancelled
            return
        }
    }()
    return ch
}

ctx, cancel := context.WithCancel(context.Background())
ch := safeFunc(ctx)
cancel() // cancelling cleans the goroutine up

When you create a goroutine, create its exit path too

What to take away today

Answer these yourself

Next up — Channels in Depth