1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

type Counter struct {
	mu sync.Mutex     // ⚠️ 必须与数据放在一起，且不要拷贝
	n  int
}

func (c *Counter) Inc() {
	c.mu.Lock()
	defer c.mu.Unlock()   // 🔥 惯用法：加锁后立刻 defer 解锁
	c.n++
}

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 🛑 go vet 会报错的写法
type Bad struct {
	mu sync.Mutex
	n  int
}

func useBad(b Bad) { ... }        // 按值传参 → 拷贝了锁
b2 := b                          // 赋值也会拷贝

// ✅ 只用指针
func useGood(b *Bad) { ... }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

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

func (c *Cache) Get(k string) (string, bool) {
	c.mu.RLock()           // 读锁：多个读者可同时持有
	defer c.mu.RUnlock()
	v, ok := c.m[k]
	return v, ok
}

func (c *Cache) Set(k, v string) {
	c.mu.Lock()            // 写锁：独占
	defer c.mu.Unlock()
	c.m[k] = v
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

var wg sync.WaitGroup

// 传统写法（1.25 前）
for _, t := range tasks {
	wg.Add(1)
	go func() {
		defer wg.Done()
		process(t)
	}()
}
wg.Wait()

// 🆕 1.25 起：WaitGroup.Go 一行搞定
for _, t := range tasks {
	wg.Go(func() { process(t) })
}
wg.Wait()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 🛑 竞态：Add 在 goroutine 里，Wait 可能提前返回
for range 10 {
	go func() { wg.Add(1); defer wg.Done(); work() }()
}
wg.Wait()

// ✅ 正确
for range 10 {
	wg.Add(1)
	go func() { defer wg.Done(); work() }()
}
wg.Wait()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

var (
	once   sync.Once
	client *http.Client
)

func GetClient() *http.Client {
	once.Do(func() {
		client = &http.Client{Timeout: 10 * time.Second}
	})
	return client
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// OnceFunc：保证只执行一次
setup := sync.OnceFunc(func() { fmt.Print("once ") })
for range 3 { setup() }
// 输出：once

// OnceValue：保证只计算一次并缓存结果
cached := sync.OnceValue(func() int { fmt.Print("compute "); return 42 })
fmt.Println(cached(), cached())     // ⚠️ 返回值必须打印出来，否则只看到 "compute "
// 输出：compute 42 42

// OnceValues：缓存值 + 错误两个返回
load := sync.OnceValues(func() (*Config, error) { return loadConfig() })

1
2

once 
compute 42 42

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

type Queue struct {
	mu   sync.Mutex
	cond *sync.Cond
	items []int
}

func NewQueue() *Queue {
	q := &Queue{}
	q.cond = sync.NewCond(&q.mu)
	return q
}

func (q *Queue) Push(v int) {
	q.mu.Lock()
	q.items = append(q.items, v)
	q.mu.Unlock()
	q.cond.Signal()          // 唤醒一个等待者
}

func (q *Queue) Pop() int {
	q.mu.Lock()
	defer q.mu.Unlock()
	for len(q.items) == 0 {  // ⚠️ 必须用 for 而不是 if
		q.cond.Wait()        // Wait 内部会解锁 → 阻塞 → 重新加锁
	}
	v := q.items[0]
	q.items = q.items[1:]
	return v
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

var n atomic.Int64
n.Add(1)
n.Add(2)
n.Load()                   // 3
n.CompareAndSwap(3, 10)    // true
n.Store(0)
n.Swap(5)

var f atomic.Bool
f.Store(true)
f.Load()
f.CompareAndSwap(true, false)

var p atomic.Pointer[string]
s := "hello"
p.Store(&s)
*p.Load()                  // hello

// 泛型 Value（存任意类型，需类型一致）
var av atomic.Value
av.Store("first")
av.Load().(string)

1
2
3

atomic: 3 true 10
ptr: hello
value: first

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 🛑 看似安全，实际有竞态：读两个变量之间状态可能已变
type Stats struct {
	reads  atomic.Int64
	writes atomic.Int64
}

r := s.reads.Load()
w := s.writes.Load()   // 这两次 Load 之间，别的 goroutine 可能改了状态

// ✅ 需要一致性快照时，要么加锁，要么把两个值合成一个用 CAS 更新

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

取消树：一次 cancel，整棵子树倒下（但不会向上传染）

  context.Background()                    ← 根：永不取消
        │
        ├── WithCancel ──────────────────► 请求 A
        │      │
        │      ├── WithValue(traceID) ───► 带追踪信息
        │      │      │
        │      │      └── WithTimeout(3s) ► 调下游服务
        │      │
        │      └── WithCancel ───────────► 请求 A 的子任务
        │
        └── WithTimeout(30s) ────────────► 后台任务
               │
               └── WithCancel ───────────► 子任务

  ✂️ cancel() 请求 A  ──►  A 及其【所有后代】的 Done 同时关闭
  ✅ 后代取消         ──►  不影响 A、不影响兄弟节点
  ⚠️ 忘记 cancel      ──►  timer 与子树泄漏（go vet 的 lostcancel 会查）
  ⚠️ 用已取消的 ctx   ──►  下游立刻失败（优雅关闭时最容易犯）

1
2
3
4
5
6
7

ctx, cancel := context.WithCancel(context.Background())
child, childCancel := context.WithTimeout(ctx, time.Second)
defer childCancel()

cancel()               // 取消父节点
<-child.Done()
fmt.Println(child.Err(), errors.Is(child.Err(), context.Canceled))

1

child err: context canceled Is Canceled: true

1
2
3
4
5
6
7
8

switch {
case errors.Is(ctx.Err(), context.Canceled):
	// 主动取消（或父节点被取消）
case errors.Is(ctx.Err(), context.DeadlineExceeded):
	// 超时
case ctx.Err() == nil:
	// 还没结束
}

1
2
3

ctx, cancel := context.WithCancelCause(context.Background())
cancel(errors.New("自定义原因"))
fmt.Println(context.Cause(ctx), ctx.Err())

1

Cause: 自定义原因 Err: context canceled

1
2
3

// 剥离取消：日志上报、审计这类「即使请求取消也要做完」的操作
detached := context.WithoutCancel(ctx)
fmt.Println(detached.Err(), detached.Value(k{}))

1

detached Err: <nil> value: v

1
2
3

// ctx 结束时自动执行清理（比起一个 goroutine 等 <-ctx.Done() 更省）
stop := context.AfterFunc(ctx, func() { cleanup() })
fired := stop()   // 返回 false 表示已经触发过了

1

AfterFunc fired, stop() = false

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// 🛑 用内置类型作 key：任何包都能覆盖你的值
ctx = context.WithValue(ctx, "userID", 42)
ctx.Value("userID")   // 可能被别的包的同名 key 覆盖

// ✅ 用未导出的自定义类型
type userIDKey struct{}

func WithUserID(ctx context.Context, id int) context.Context {
	return context.WithValue(ctx, userIDKey{}, id)
}

func UserID(ctx context.Context) (int, bool) {
	id, ok := ctx.Value(userIDKey{}).(int)
	return id, ok
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

import "golang.org/x/sync/errgroup"

func fetchAll(ctx context.Context, urls []string) ([]string, error) {
	g, ctx := errgroup.WithContext(ctx)      // 🔥 ctx 会在任一任务失败时取消
	results := make([]string, len(urls))

	for i, u := range urls {
		g.Go(func() error {
			body, err := fetch(ctx, u)
			if err != nil {
				return fmt.Errorf("fetch %s: %w", u, err)
			}
			results[i] = body               // ✅ 每个 goroutine 写不同下标，无需加锁
			return nil
		})
	}

	if err := g.Wait(); err != nil {        // 返回第一个错误
		return nil, err
	}
	return results, nil
}

1
2
3
4
5
6
7

// 限制并发数（x/sync 0.3+）
g.SetLimit(10)      // 最多 10 个 goroutine 同时在跑

// 或显式信号量
sem := semaphore.NewWeighted(10)
if err := sem.Acquire(ctx, 1); err != nil { return err }
defer sem.Release(1)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import "golang.org/x/sync/singleflight"

var g singleflight.Group

func GetUser(ctx context.Context, id string) (*User, error) {
	v, err, _ := g.Do(id, func() (any, error) {
		return db.LoadUser(ctx, id)     // 同一 id 的并发调用只会执行一次 🔥
	})
	if err != nil {
		return nil, err
	}
	return v.(*User), nil
}