sync Source Reading — Practice Tasks¶

// counter.go
package counter

import "sync"

// Senior decision: embed the mutex by value, not pointer. `sync.Mutex`'s
// zero value is a usable unlocked mutex; a pointer would force a New()
// constructor and an extra allocation. The downside — Counter is no
// longer safe to copy — is what `go vet -copylocks` catches at build
// time. Free safety beats free convenience.
type Counter struct {
    mu sync.Mutex
    n  int
}

func (c *Counter) Inc() {
    c.mu.Lock()
    // defer Unlock is the canonical idiom even for a one-line critical
    // section. The cost is ~30 ns; the safety against panics in larger
    // critical sections is worth orders of magnitude more.
    defer c.mu.Unlock()
    c.n++
}

func (c *Counter) Value() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.n
}

// counter_test.go
package counter

import (
    "sync"
    "testing"
)

func TestCounter1MIncrements(t *testing.T) {
    for trial := 0; trial < 100; trial++ {
        var c Counter
        var wg sync.WaitGroup
        const G, N = 1000, 1000
        wg.Add(G)
        for g := 0; g < G; g++ {
            go func() {
                defer wg.Done()
                for i := 0; i < N; i++ {
                    c.Inc()
                }
            }()
        }
        wg.Wait()
        if got := c.Value(); got != G*N {
            t.Fatalf("trial %d: got %d, want %d", trial, got, G*N)
        }
    }
}

// counter_broken.go
//go:build broken

package counter

type BrokenCounter struct{ n int }

func (c *BrokenCounter) Inc()       { c.n++ }
func (c *BrokenCounter) Value() int { return c.n }

// worker.go
package worker

import "sync"

func Process(items []int) []int {
    out := make(chan int, len(items))
    var wg sync.WaitGroup
    // Senior decision: Add once with the full count, not Add(1) inside
    // the loop. Each Add takes an atomic operation; one Add(N) is N×
    // cheaper. The pattern also makes "did I Add before the go?" a
    // visible structural check, not a per-iteration discipline.
    wg.Add(len(items))
    for _, x := range items {
        x := x // local copy — pre-1.22 loop-variable hazard; explicit
        //        keeps the intent obvious for readers on older Go.
        go func() {
            defer wg.Done()
            out <- x * x
        }()
    }
    // Senior decision: close the channel AFTER Wait returns. Closing
    // inside the loop or in one of the workers would race — only the
    // last finisher knows it's last, and even that requires extra
    // coordination. Wait gives us the bright line.
    go func() {
        wg.Wait()
        close(out)
    }()

    var results []int
    for v := range out {
        results = append(results, v)
    }
    return results
}

// worker_test.go
package worker

import (
    "sort"
    "sync"
    "sync/atomic"
    "testing"
)

func TestProcessSquares(t *testing.T) {
    in := []int{1, 2, 3, 4, 5}
    got := Process(in)
    sort.Ints(got)
    want := []int{1, 4, 9, 16, 25}
    if len(got) != len(want) {
        t.Fatalf("len mismatch: got %v want %v", got, want)
    }
    for i := range got {
        if got[i] != want[i] {
            t.Fatalf("idx %d: got %d want %d", i, got[i], want[i])
        }
    }
}

// Prove Wait actually waits.
func TestWaitBlocksUntilDone(t *testing.T) {
    var done atomic.Bool
    var wg sync.WaitGroup
    wg.Add(3)
    for i := 0; i < 3; i++ {
        go func() {
            defer wg.Done()
            if done.Load() {
                t.Errorf("Done observed after Wait returned — impossible")
            }
        }()
    }
    wg.Wait()
    done.Store(true)
}

// once_global.go
package once_global

import (
    "regexp"
    "sync"
    "sync/atomic"
)

var (
    once      sync.Once
    pattern   *regexp.Regexp
    initCount atomic.Int64
)

// Senior decision: hide the Once and the global behind an accessor.
// Callers don't reach into the package; they call Pattern(). If we ever
// move from "lazy init" to "init at startup" or "init from config",
// only this function changes.
func Pattern() *regexp.Regexp {
    once.Do(func() {
        // Compile once. regexp.MustCompile is itself idiomatic for
        // "constant pattern that MUST parse"; the panic on bad input
        // would fire at startup, which is exactly when we want it to.
        pattern = regexp.MustCompile(`^[a-z]+$`)
        initCount.Add(1)
    })
    return pattern
}

// Exported for testing — production code should not depend on this.
func InitCount() int64 { return initCount.Load() }

// once_global_test.go
package once_global

import (
    "sync"
    "testing"
)

func TestOnceRunsExactlyOnce(t *testing.T) {
    const G = 1000
    var wg sync.WaitGroup
    wg.Add(G)
    for i := 0; i < G; i++ {
        go func() {
            defer wg.Done()
            p := Pattern()
            if p == nil {
                t.Errorf("Pattern returned nil")
            }
        }()
    }
    wg.Wait()
    if c := InitCount(); c != 1 {
        t.Fatalf("init ran %d times, want 1", c)
    }
}

func TestOnceStaysOnce(t *testing.T) {
    for i := 0; i < 100; i++ {
        _ = Pattern()
    }
    if c := InitCount(); c != 1 {
        t.Fatalf("init ran %d times after 100 calls, want 1", c)
    }
}

// fast_path_demo.go
package mutexnote

import "sync/atomic"

// This is a hand-rolled approximation of the sync.Mutex fast path,
// suitable only for understanding — production code should use
// sync.Mutex. We show the SAME idea (CAS 0 -> 1) so the source
// quote is concrete.
type DemoLock struct {
    state atomic.Int32
}

const (
    demoLocked int32 = 1 << iota
    demoWoken
    demoStarving
    demoWaiterShift = iota
)

func (d *DemoLock) TryLock() bool {
    // Quote from $(go env GOROOT)/src/sync/mutex.go, go1.22:
    //
    //   if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
    //       if race.Enabled { ... }
    //       return
    //   }
    //   // Slow path (outlined so that the fast path can be inlined)
    //   m.lockSlow()
    //
    // Operands:
    //   &m.state       -> pointer to packed state word (int32)
    //   0              -> EXPECTED old value: no lock held, no
    //                     waiters, not woken, not starving. The ONLY
    //                     state in which the fast path can succeed.
    //   mutexLocked    -> NEW value: bit 0 set, everything else
    //                     still zero. We just claimed the lock.
    //
    // If CompareAndSwap returns true, we own the lock and Lock
    // returns immediately — a single atomic instruction, no
    // function call beyond the inlinable wrapper, no kernel
    // involvement, no scheduler interaction. If it returns false,
    // someone else holds the lock OR there are waiters OR the
    // mutex is in starvation mode; we fall through to lockSlow.
    return d.state.CompareAndSwap(0, demoLocked)
}

func (d *DemoLock) Unlock() {
    newState := d.state.Add(-demoLocked)
    if newState != 0 {
        // Real Mutex.Unlock has slow path here to wake waiters.
        // Our demo intentionally ignores it — we only model the
        // fast path.
        panic("demo lock: contended Unlock not implemented")
    }
}

// fast_path_demo_test.go
package mutexnote

import "testing"

func TestFastPathTakesLockOnce(t *testing.T) {
    var d DemoLock
    if !d.TryLock() {
        t.Fatal("first TryLock should succeed (state was 0)")
    }
    if d.TryLock() {
        t.Fatal("second TryLock should fail (state was demoLocked)")
    }
    d.Unlock()
    if !d.TryLock() {
        t.Fatal("after Unlock, TryLock should succeed again")
    }
}

// rwmap.go
package rwmap

import "sync"

type MutexMap struct {
    mu sync.Mutex
    m  map[string]int
}

func NewMutexMap() *MutexMap { return &MutexMap{m: make(map[string]int)} }

func (s *MutexMap) Get(k string) (int, bool) {
    s.mu.Lock()
    defer s.mu.Unlock()
    v, ok := s.m[k]
    return v, ok
}

func (s *MutexMap) Set(k string, v int) {
    s.mu.Lock()
    defer s.mu.Unlock()
    s.m[k] = v
}

type RWMutexMap struct {
    mu sync.RWMutex
    m  map[string]int
}

func NewRWMutexMap() *RWMutexMap { return &RWMutexMap{m: make(map[string]int)} }

func (s *RWMutexMap) Get(k string) (int, bool) {
    s.mu.RLock()
    defer s.mu.RUnlock()
    v, ok := s.m[k]
    return v, ok
}

func (s *RWMutexMap) Set(k string, v int) {
    s.mu.Lock()
    defer s.mu.Unlock()
    s.m[k] = v
}

// rwmap_bench_test.go
package rwmap

import (
    "strconv"
    "sync/atomic"
    "testing"
)

// 10 readers per writer. We model the ratio by having each parallel
// worker do 10 Gets then 1 Set.
func BenchmarkMutex10R1W(b *testing.B) {
    s := NewMutexMap()
    for i := 0; i < 1000; i++ {
        s.Set(strconv.Itoa(i), i)
    }
    b.ResetTimer()
    var n atomic.Int64
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            i := int(n.Add(1)) % 1000
            for r := 0; r < 10; r++ {
                _, _ = s.Get(strconv.Itoa(i))
            }
            s.Set(strconv.Itoa(i), i)
        }
    })
}

func BenchmarkRWMutex10R1W(b *testing.B) {
    s := NewRWMutexMap()
    for i := 0; i < 1000; i++ {
        s.Set(strconv.Itoa(i), i)
    }
    b.ResetTimer()
    var n atomic.Int64
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            i := int(n.Add(1)) % 1000
            for r := 0; r < 10; r++ {
                _, _ = s.Get(strconv.Itoa(i))
            }
            s.Set(strconv.Itoa(i), i)
        }
    })
}

func BenchmarkMutex1R1W(b *testing.B) {
    s := NewMutexMap()
    for i := 0; i < 1000; i++ {
        s.Set(strconv.Itoa(i), i)
    }
    b.ResetTimer()
    var n atomic.Int64
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            i := int(n.Add(1)) % 1000
            _, _ = s.Get(strconv.Itoa(i))
            s.Set(strconv.Itoa(i), i)
        }
    })
}

func BenchmarkRWMutex1R1W(b *testing.B) {
    s := NewRWMutexMap()
    for i := 0; i < 1000; i++ {
        s.Set(strconv.Itoa(i), i)
    }
    b.ResetTimer()
    var n atomic.Int64
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            i := int(n.Add(1)) % 1000
            _, _ = s.Get(strconv.Itoa(i))
            s.Set(strconv.Itoa(i), i)
        }
    })
}

// hotcache.go
package hotcache

import "sync"

// Senior decision: we provide BOTH implementations behind the same
// interface so the benchmark proves the workload-dependence
// empirically. Code that doesn't measure picks whichever the author
// learned first; code that measures picks whichever wins on the
// actual workload.
type Cache interface {
    Get(k string) (int, bool)
    Set(k string, v int)
    Delete(k string)
}

type SyncMapCache struct {
    m sync.Map
}

func (c *SyncMapCache) Get(k string) (int, bool) {
    v, ok := c.m.Load(k)
    if !ok {
        return 0, false
    }
    return v.(int), true
}
func (c *SyncMapCache) Set(k string, v int) { c.m.Store(k, v) }
func (c *SyncMapCache) Delete(k string)     { c.m.Delete(k) }

type RWMapCache struct {
    mu sync.RWMutex
    m  map[string]int
}

func NewRWMapCache() *RWMapCache { return &RWMapCache{m: make(map[string]int)} }

func (c *RWMapCache) Get(k string) (int, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()
    v, ok := c.m[k]
    return v, ok
}
func (c *RWMapCache) Set(k string, v int) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.m[k] = v
}
func (c *RWMapCache) Delete(k string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    delete(c.m, k)
}

// Notes on sync.Map internals (from $(go env GOROOT)/src/sync/map.go):
//
//   type Map struct {
//       mu     Mutex          // guards `dirty` and `misses`
//       read   atomic.Pointer[readOnly]
//       dirty  map[any]*entry
//       misses int
//   }
//
//   type readOnly struct {
//       m       map[any]*entry
//       amended bool // true if dirty contains keys not in read.m
//   }
//
// Get path:
//   1. Atomically load `read`. Look up the key. If found AND value is
//      not expunged, return — NO LOCK TAKEN. This is the fast path.
//   2. If not found and `read.amended` is true, take `mu`, check
//      `dirty`, increment misses, maybe promote dirty -> read.
//
// Store path:
//   1. If key is in `read` and entry is not expunged, CAS the entry's
//      pointer atomically — NO LOCK for updates of existing keys.
//   2. Otherwise take `mu`, update `dirty`, mark `read.amended = true`.
//
// The key insight: for HOT keys (existing, frequently read, rarely
// updated), every Get is one atomic load + one map lookup. No mutex
// of any kind. That's why sync.Map demolishes RWMutex on
// read-dominant workloads with a small working set.

// hotcache_bench_test.go
package hotcache

import (
    "strconv"
    "sync/atomic"
    "testing"
)

func populate(c Cache, n int) {
    for i := 0; i < n; i++ {
        c.Set(strconv.Itoa(i), i)
    }
}

const hotKeys = 10

func bench95Read(b *testing.B, c Cache) {
    populate(c, 1000)
    b.ResetTimer()
    var n atomic.Int64
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            i := int(n.Add(1))
            if i%20 == 0 {
                // 5% writes to cold tail.
                c.Set(strconv.Itoa(100+i%900), i)
            } else {
                // 95% reads of hot set.
                _, _ = c.Get(strconv.Itoa(i % hotKeys))
            }
        }
    })
}

func Benchmark95Read_SyncMap(b *testing.B) { bench95Read(b, &SyncMapCache{}) }
func Benchmark95Read_RWMutex(b *testing.B) { bench95Read(b, NewRWMapCache()) }

func bench50_50(b *testing.B, c Cache) {
    populate(c, 1000)
    b.ResetTimer()
    var n atomic.Int64
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            i := int(n.Add(1))
            if i%2 == 0 {
                c.Set(strconv.Itoa(i%1000), i)
            } else {
                _, _ = c.Get(strconv.Itoa(i % 1000))
            }
        }
    })
}

func Benchmark50_50_SyncMap(b *testing.B) { bench50_50(b, &SyncMapCache{}) }
func Benchmark50_50_RWMutex(b *testing.B) { bench50_50(b, NewRWMapCache()) }

// bqueue.go
package bqueue

import "sync"

type BoundedQueue struct {
    mu       sync.Mutex
    notFull  *sync.Cond
    notEmpty *sync.Cond
    buf      []int
    max      int
    closed   bool
}

func New(max int) *BoundedQueue {
    if max <= 0 {
        panic("bqueue: max must be > 0")
    }
    q := &BoundedQueue{max: max}
    // Senior decision: both Conds share the SAME mutex. The lock is
    // what protects `buf`, `max`, and `closed`; the Conds are just
    // event channels. Two locks would race on the buffer state.
    q.notFull = sync.NewCond(&q.mu)
    q.notEmpty = sync.NewCond(&q.mu)
    return q
}

func (q *BoundedQueue) Push(v int) (ok bool) {
    q.mu.Lock()
    defer q.mu.Unlock()
    // for, not if — spurious wakeups are real; we MUST re-check.
    for len(q.buf) >= q.max && !q.closed {
        q.notFull.Wait()
    }
    if q.closed {
        return false
    }
    q.buf = append(q.buf, v)
    // Signal one consumer — Broadcast would wake all M of them and
    // M-1 would immediately go back to sleep. Signal is the right
    // choice when adding one item satisfies one waiter.
    q.notEmpty.Signal()
    return true
}

func (q *BoundedQueue) Pop() (int, bool) {
    q.mu.Lock()
    defer q.mu.Unlock()
    for len(q.buf) == 0 && !q.closed {
        q.notEmpty.Wait()
    }
    if len(q.buf) == 0 {
        return 0, false
    }
    v := q.buf[0]
    q.buf = q.buf[1:]
    q.notFull.Signal()
    return v, true
}

func (q *BoundedQueue) Close() {
    q.mu.Lock()
    defer q.mu.Unlock()
    q.closed = true
    // Broadcast — every blocked Push and Pop must wake up and see
    // closed=true. Signal would wake one, leaving the rest blocked
    // forever.
    q.notFull.Broadcast()
    q.notEmpty.Broadcast()
}

// bqueue_test.go
package bqueue

import (
    "sync"
    "sync/atomic"
    "testing"
)

func TestBoundedQueueProducersConsumers(t *testing.T) {
    q := New(8)
    const P, C, perP = 4, 4, 250
    var produced atomic.Int64
    var consumed atomic.Int64
    var wg sync.WaitGroup
    wg.Add(P + C)
    for p := 0; p < P; p++ {
        go func() {
            defer wg.Done()
            for i := 0; i < perP; i++ {
                if !q.Push(i) {
                    t.Errorf("Push returned false unexpectedly")
                    return
                }
                produced.Add(1)
            }
        }()
    }
    for c := 0; c < C; c++ {
        go func() {
            defer wg.Done()
            for {
                _, ok := q.Pop()
                if !ok {
                    return
                }
                if consumed.Add(1) == P*perP {
                    q.Close()
                    return
                }
            }
        }()
    }
    wg.Wait()
    if got := consumed.Load(); got != P*perP {
        t.Fatalf("consumed %d, want %d", got, P*perP)
    }
    if got := produced.Load(); got != P*perP {
        t.Fatalf("produced %d, want %d", got, P*perP)
    }
}

// bufpool.go
package bufpool

import (
    "fmt"
    "runtime"
    "sync"
)

var bufPool = sync.Pool{
    // Senior decision: New returns a *[]byte, not []byte. Putting a
    // []byte into the pool would allocate an interface header
    // every Put. The pointer form is the canonical recipe — see
    // bytes.Buffer in the stdlib (it stores a pointer to itself).
    New: func() any {
        b := make([]byte, 0, 4096)
        return &b
    },
}

func Get() *[]byte { return bufPool.Get().(*[]byte) }

func Put(b *[]byte) {
    // Senior decision: reset length but keep capacity. This is what
    // makes pooling worthwhile — the underlying array is reused; only
    // the slice header is rewritten.
    *b = (*b)[:0]
    bufPool.Put(b)
}

// Demo helper used by the test.
func TagWithFinalizer(p *[]byte, msg string) {
    runtime.SetFinalizer(p, func(_ *[]byte) {
        fmt.Println("FINALIZER:", msg)
    })
}

// bufpool_test.go
package bufpool

import (
    "runtime"
    "testing"
)

func TestPoolReuse(t *testing.T) {
    // Warm the pool with one specific buffer we can identify.
    b := Get()
    TagWithFinalizer(b, "sentinel")
    addr := &(*b)[:1][0] // first byte's address — survives across Put
    Put(b)

    // Steady state: Get should very likely return the same buffer.
    // "Very likely" because the runtime can steal from this P, GC
    // can clear the pool, etc. Empirically, in a single goroutine
    // with no GC between Put and Get, you'll see the same one.
    b2 := Get()
    addr2 := &(*b2)[:1][0]
    if addr != addr2 {
        t.Logf("pool returned a different buffer — possible if runtime stole or grew the pool")
    }
    Put(b2)
}

func TestPoolReducesAllocs(t *testing.T) {
    allocs := testing.AllocsPerRun(1000, func() {
        b := Get()
        *b = append(*b, []byte("hello, world")...)
        Put(b)
    })
    // We expect near-zero allocs on the hot path: the pool returns
    // an existing *[]byte, the append fits in capacity, the Put
    // doesn't allocate.
    if allocs > 1 {
        t.Errorf("allocs per Get/Put cycle = %v, want ~0", allocs)
    }
}

func TestPoolEvictionOnGC(t *testing.T) {
    // Pump the pool, then force two GCs. Go 1.13+ has a victim
    // cache: one GC moves items to the victim cache; the SECOND GC
    // drops them for good. So two GCs are what it takes to provoke
    // finalizers.
    for i := 0; i < 100; i++ {
        b := Get()
        Put(b)
    }
    runtime.GC()
    runtime.GC()
    // Finalizers run asynchronously — we don't assert exact timing.
    // The test exists to be observable when run with -v.
}

// onceval.go
package onceval

import (
    "sync"
    "sync/atomic"
)

// Senior decision: two implementations side-by-side. The first (Simple)
// matches the stdlib: captured variable + sync.Once. The second
// (Atomic) uses atomic.Pointer[T] so the fast path is a single atomic
// load, no Once involvement. Atomic is marginally faster on contended
// paths and demonstrates the building blocks; Simple is what you
// should ship.

func Simple[T any](f func() T) func() T {
    var (
        once sync.Once
        v    T
    )
    return func() T {
        // Once.Do's fast path is one atomic uint32 load; on subsequent
        // calls we just touch the captured variable.
        once.Do(func() {
            v = f()
        })
        return v
    }
}

func Atomic[T any](f func() T) func() T {
    var (
        once sync.Once
        p    atomic.Pointer[T]
    )
    return func() T {
        if v := p.Load(); v != nil {
            return *v
        }
        once.Do(func() {
            v := f()
            p.Store(&v)
        })
        return *p.Load()
    }
}

// onceval_test.go
package onceval

import (
    "sync"
    "sync/atomic"
    "testing"
    "time"
)

func TestOnceValueRunsOnceConcurrently(t *testing.T) {
    var calls atomic.Int64
    f := func() int {
        calls.Add(1)
        time.Sleep(10 * time.Millisecond)
        return 42
    }
    get := Simple(f)

    var wg sync.WaitGroup
    const G = 1000
    wg.Add(G)
    for i := 0; i < G; i++ {
        go func() {
            defer wg.Done()
            if got := get(); got != 42 {
                t.Errorf("got %d, want 42", got)
            }
        }()
    }
    wg.Wait()
    if c := calls.Load(); c != 1 {
        t.Fatalf("f ran %d times, want 1", c)
    }
}

func TestAtomicVariantSameSemantics(t *testing.T) {
    var calls atomic.Int64
    f := func() string {
        calls.Add(1)
        return "hello"
    }
    get := Atomic(f)
    var wg sync.WaitGroup
    const G = 1000
    wg.Add(G)
    for i := 0; i < G; i++ {
        go func() {
            defer wg.Done()
            if got := get(); got != "hello" {
                t.Errorf("got %q", got)
            }
        }()
    }
    wg.Wait()
    if c := calls.Load(); c != 1 {
        t.Fatalf("f ran %d times, want 1", c)
    }
}

func TestNoAllocsPostInit(t *testing.T) {
    get := Simple(func() int { return 7 })
    _ = get() // warm
    allocs := testing.AllocsPerRun(1000, func() {
        _ = get()
    })
    if allocs > 0 {
        t.Errorf("post-init allocs/call = %v, want 0", allocs)
    }
}

// wgrace.go
package wgrace

import (
    "sync"
    "sync/atomic"
)

// BROKEN: Add inside the goroutine.
func Broken(n int) int64 {
    var wg sync.WaitGroup
    var counter atomic.Int64
    for i := 0; i < n; i++ {
        go func() {
            wg.Add(1) // <-- WRONG. Parent may already be in Wait.
            defer wg.Done()
            counter.Add(1)
        }()
    }
    wg.Wait()
    return counter.Load()
}

// FIXED: Add BEFORE go.
func Fixed(n int) int64 {
    var wg sync.WaitGroup
    var counter atomic.Int64
    wg.Add(n) // <-- bulk Add once; cheaper and structurally correct.
    for i := 0; i < n; i++ {
        go func() {
            defer wg.Done()
            counter.Add(1)
        }()
    }
    wg.Wait()
    return counter.Load()
}

// wgrace_test.go
package wgrace

import "testing"

func TestFixedAlwaysReachesN(t *testing.T) {
    for trial := 0; trial < 100; trial++ {
        if got := Fixed(100); got != 100 {
            t.Fatalf("trial %d: Fixed got %d, want 100", trial, got)
        }
    }
}

// Demonstration test — under -race or under contention, Broken can
// produce results < 100. We don't assert "Broken is broken" in CI
// because the race is data-dependent; we just observe it.
func TestBrokenSometimesUnderCounts(t *testing.T) {
    t.Skip("demo only: run with -race -count=1000 to provoke")
    for trial := 0; trial < 1000; trial++ {
        if got := Broken(100); got != 100 {
            t.Logf("trial %d: Broken got %d (expected 100) — race observed", trial, got)
            return
        }
    }
    t.Log("Broken happened to produce 100 every trial — try -race or -cpu=1")
}