Advanced Sync, Profiling & Production

Overview

sync.Mutex protects a map or struct in place. sync.Once runs init once. sync.Pool recycles buffers that you clear first. Profiles tell you whether you are burning CPU, heap, or goroutines. Go 1.27.1 includes the goroutineleak profile as a general tool.

flowchart TB
  Issue["Prod issue Ready"]
  Kind["CPU or memory? Ready"]
  Cpu["CPU profile Ready"]
  Heap["Heap profile Ready"]
  Stuck["Stuck or a race? Ready"]
  Leak["Goroutine leak profile Ready"]
  Race["Race detector Ready"]
  Issue -->|continues| Kind
  Kind -->|CPU| Cpu
  Kind -->|memory| Heap
  Heap -->|continues| Stuck
  Stuck -->|stuck| Leak
  Stuck -->|race| Race

Press Run. Snippets must be self-contained — no network, files, or native modules.

The Python lock would wrap set if threads shared the dict. The Go mutex is that same bracket around the map.

Rosetta — mutex

package cache

import "sync"

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

func (c *Cache) Set(k, v string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    if c.m == nil {
        c.m = map[string]string{}
    }
    c.m[k] = v
}

const m = new Map<string, string>();
function set(k: string, v: string) {
  m.set(k, v);
}

import threading

class Cache:
    def __init__(self) -> None:
        self._mu = threading.Lock()
        self._m: dict[str, str] = {}

    def set(self, k: str, v: str) -> None:
        with self._mu:
            self._m[k] = v

Hold the mutex only around the map. Do not hold it across a network call. A TypeScript Map on one event-loop thread does not need this lock. Worker threads and Python threads do. sync.Once covers one-time setup. sync.Pool is for buffers: clear them before Put.

Rosetta — pprof

package main

import (
    "log"
    "net/http"
    _ "net/http/pprof"
)

func main() {
    go func() {
        log.Println(http.ListenAndServe("127.0.0.1:6060", nil))
    }()
    select {}
}

// go tool pprof http://127.0.0.1:6060/debug/pprof/heap

// node --inspect app.js
// Chrome DevTools, clinic, or 0x for a CPU view
const marker = "inspect";
console.log(marker);

# py-spy, cProfile, or scalene against a pid
marker = "profile"
print(marker)

The blank import registers pprof on the default mux. Binding 127.0.0.1 keeps it off other interfaces. Behind auth is the other acceptable gate. The Go 1.27 goroutineleak profile reports goroutines that are permanently blocked. Heap and CPU profiles still answer the other two questions. go test -race is the test-time partner, not a substitute.

Production checklist

• go test -race is clean on packages that share memory.
• HTTP server timeouts are set, and shutdown uses Server.Shutdown.
• Outbound calls take a context.
• Errors wrap with %w.
• pprof is not public without auth.
• Toolchain set (go 1.27 minimum + toolchain go1.27.1; pin the exact image in CI).
• cgo stays off the hot path unless a measurement says otherwise.
• Fan-out has a limit.

GOMAXPROCS defaults to the usable CPU count. Change it when a profile says the scheduler is the problem, not because a blog used a round number.

Interview Q&A

Pitfalls

• Locking, then calling the network.
• Registering pprof on the public server.
• A Pool used as a user cache.
• Raising GOMAXPROCS with no profile.

Go Deeper

• Diagnostics
• pprof
• Go 1.27 release notes