Go

The Go scheduler: M:N threading

Go uses an M:N scheduler (M goroutines on N OS threads). The scheduler has three entities: G (goroutine), M (machine = OS thread), and P (processor = scheduling context, capped at GOMAXPROCS). Each P has a local run queue of goroutines. The scheduler uses work stealing: when a P's local queue is empty, it steals goroutines from other Ps. Goroutines are preempted at function call sites (cooperative) and since Go 1.14, asynchronously (full preemption via signals). This means a tight CPU loop is preemptible — no goroutine can starve others.

select statement: multiplexing channels

The select statement is like a switch for channels — it blocks until one of its cases can proceed, then executes that case. If multiple cases are ready simultaneously, one is chosen uniformly at random. select with a default case is non-blocking.

package main

import (
    "fmt"
    "time"
)

func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)

    go func() { time.Sleep(1 * time.Second); ch1 <- "one" }()
    go func() { time.Sleep(2 * time.Second); ch2 <- "two" }()

    // Receive from whichever channel is ready first
    for i := 0; i < 2; i++ {
        select {
        case msg := <-ch1:
            fmt.Println("Received from ch1:", msg)
        case msg := <-ch2:
            fmt.Println("Received from ch2:", msg)
        }
    }

    // Timeout pattern using select + time.After
    ch := make(chan int)
    select {
    case v := <-ch:
        fmt.Println("Received:", v)
    case <-time.After(500 * time.Millisecond):
        fmt.Println("Timed out")
    }
}

Generics (Go 1.18+)

Go added generics in version 1.18 (March 2022). Type parameters use square brackets: func Map[T, U any](s []T, f func(T) U) []U. Type constraints are interfaces that specify allowed types — the built-in any constraint accepts all types; comparable accepts types that support ==. The golang.org/x/exp/slices and golang.org/x/exp/maps packages (now in standard library as of Go 1.21) use generics extensively.

package main

import "fmt"

// Generic function — T must be comparable (supports ==)
func Contains[T comparable](s []T, val T) bool {
    for _, v := range s {
        if v == val { return true }
    }
    return false
}

// Generic Map function
func Map[T, U any](s []T, f func(T) U) []U {
    result := make([]U, len(s))
    for i, v := range s { result[i] = f(v) }
    return result
}

// Type constraint: only numeric types
type Number interface {
    ~int | ~int32 | ~int64 | ~float32 | ~float64
}

func Sum[T Number](s []T) T {
    var total T
    for _, v := range s { total += v }
    return total
}

func main() {
    fmt.Println(Contains([]string{"a","b","c"}, "b"))  // true
    fmt.Println(Map([]int{1,2,3}, func(x int) int { return x*x })) // [1 4 9]
    fmt.Println(Sum([]float64{1.1, 2.2, 3.3}))         // 6.6
}

Context: cancellation and deadlines

The context package propagates cancellation signals and deadlines through a call chain. Every server handler receives a context.Context as its first argument. When a request is cancelled (client disconnects, timeout exceeded), the context is cancelled, and all goroutines doing work for that request can check ctx.Done() to stop early. This prevents goroutine leaks — a common source of memory issues in Go servers.

package main

import (
    "context"
    "fmt"
    "time"
)

func doWork(ctx context.Context) error {
    select {
    case <-time.After(2 * time.Second):
        fmt.Println("Work done")
        return nil
    case <-ctx.Done():
        return ctx.Err()   // context.DeadlineExceeded or Canceled
    }
}

func main() {
    // Timeout context — auto-cancels after 1 second
    ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
    defer cancel()

    if err := doWork(ctx); err != nil {
        fmt.Println("Error:", err)   // Error: context deadline exceeded
    }
}

The Go memory model

The Go memory model (go.dev/ref/mem, revised 2022) defines when a goroutine is guaranteed to observe the effects of a write by another goroutine. The model is based on the happens-before relation. Key rules: (1) a send on a channel happens before the corresponding receive; (2) a receive from an unbuffered channel happens before the send on that channel completes; (3) the closing of a channel happens before a receive that returns a zero value; (4) sync.Mutex lock/unlock happens before the next lock. The 2022 revision aligned Go's model with the C11/C++11 memory model terminology, clarifying that data races produce undefined behaviour — not just unpredictable values.

Escape analysis and heap allocation

The Go compiler performs escape analysis to determine whether variables can be stack-allocated or must escape to the heap. If a local variable's address is taken and returned from the function (or stored somewhere that outlives the function), it escapes to the heap. Stack allocation is cheap (just move the stack pointer); heap allocation requires GC tracking. Use go build -gcflags="-m" to see escape analysis decisions. Understanding escape analysis helps avoid unnecessary heap allocations in hot paths.

Go 1.21+ standard library additions and toolchain

Go 1.21 (August 2023) added the slices and maps packages to the standard library (generic sort, search, equal, clone). Go 1.22 (February 2024) fixed loop variable capture in goroutines — a longstanding footgun where all goroutines in a for loop shared the same loop variable. Go 1.26 added range over functions (iterators). The Go toolchain is self-hosting — Go is compiled by Go. The reference compiler is gc (part of the Go distribution); gccgo (GCC frontend) and TinyGo (embedded/WASM) are alternative implementations.