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

//go:noinline
func heapReturn() *Point { return &Point{1, 2} }   // 返回给调用方

//go:noinline
func stackLocal() int {
	p := &Point{3, 4}      // 只在函数内用
	return p.X + p.Y
}

//go:noinline
func toInterface(v any) { _ = v }                   // 装箱

//go:noinline
func closureCapture() func() int {
	n := 42
	return func() int { return n }                   // 被返回的闭包捕获
}

1
2
3
4
5

$ go build -gcflags="-m -l" .
./escape.go:8:35: &Point{...} escapes to heap          ← heapReturn
./escape.go:12:7: &Point{...} does not escape          ← stackLocal 🔥
./escape.go:17:18: v does not escape                   ← 编译器证明装箱参数不逃逸
./escape.go:22:9: func literal escapes to heap         ← 闭包本身

1
2
3

$ go build -gcflags="-m" ./...             # 逃逸摘要 + 内联决策
$ go build -gcflags="-m -m" ./...          # 更详细的原因
$ go build -gcflags="-m -l" ./...          # -l 禁用内联，看真实逃逸

1
2
3
4
5

goroutine 栈的增长
┌──────────┐  需要更多栈帧   ┌───────────────┐  继续增长  ┌────────────────────┐
│  2 KB    │ ─────────────► │  4 KB → 8 KB  │ ────────► │ ... → 上限 1 GB ⚠️ │
│ 初始栈    │   复制到新栈     │  内容整体搬迁   │           │ 超出 → stack overflow│
└──────────┘                └───────────────┘           └────────────────────┘

1
2

runtime: goroutine stack exceeds 1000000000-byte limit
fatal error: stack overflow

1
2
3
4
5
6
7
8

np := new(int)          // *int，指向 0
fmt.Println(*np)        // 0

ns := new([]int)        // *[]int，切片【头】本身是 nil ⚠️
fmt.Println(*ns == nil) // true，len 也是 0
*ns = append(*ns, 1)    // 还能用，但很别扭

ms := make([]int, 0, 4) // []int，已初始化，cap=4

1
2
3
4

new(int): 0 true
new([]int): true 0
make slice: 0 4
make map/chan: true true

1
2
3
4
5
6
7

// make 的三种用法
s := make([]int, 5)        // len=5, cap=5
s2 := make([]int, 0, 100)  // len=0, cap=100（预分配，最常用）🔥
m := make(map[string]int)  // 空 map，可写 ✅
m2 := make(map[string]int, 100)  // 预分配 bucket
ch := make(chan int)       // 无缓冲
ch2 := make(chan int, 10)  // 有缓冲

1
2
3
4
5
6
7

x := 42
p := &x          // *int
*p = 100         // 通过指针修改
fmt.Println(x)   // 100

var np *int      // 零值是 nil
// *np = 1       // 💥 panic: nil pointer dereference

1
2
3
4
5
6
7

// 🛑 小结构体用指针反而多一次间接寻址
func (p *Point) Dist() float64 { ... }   // Point 只有 16 字节，值接收者更好

// 🛑 为了「省内存」把 []int 换成 []*int —— 更费内存
// 每个 int 8 字节，每个指针也 8 字节，还多了一次解引用

// 🛑 返回指向循环变量的指针（1.22 前是同一个地址）

1
2
3
4
5
6
7
8
9

type Config struct {
	Timeout *time.Duration   // nil 表示「用默认值」
	Name    *string          // nil 表示「未设置」
}

// 使用时要判空
if c.Timeout != nil {
	timeout = *c.Timeout
}

1
2
3

$ GOGC=200 ./app            # GC 频率减半，内存翻倍
$ GOMEMLIMIT=400MiB ./app   # 内存接近 400MiB 时更激进地 GC
$ GOGC=off GOMEMLIMIT=1GiB ./app   # 只在接近上限时 GC（批处理常用）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 运行期调整
debug.SetGCPercent(200)
debug.SetMemoryLimit(400 << 20)

// 手动触发（谨慎，通常只在基准测试前用）
runtime.GC()

// 读取内存统计
var ms runtime.MemStats
runtime.ReadMemStats(&ms)
fmt.Println(ms.HeapAlloc>>20, "MiB")

1
2
3
4
5
6
7
8
9

// 🆕 1.24：推荐的资源清理方式（本机实测签名）
//   func AddCleanup[T, S any](ptr *T, cleanup func(S), arg S) Cleanup
type File struct{ fd uintptr }

func open(path string) *File {
	f := &File{fd: mustOpen(path)}
	runtime.AddCleanup(f, func(fd uintptr) { syscall.Close(int(fd)) }, f.fd)
	return f
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

var bufPool = sync.Pool{
	New: func() any { return new(bytes.Buffer) },
}

func handler() {
	buf := bufPool.Get().(*bytes.Buffer)
	buf.Reset()            // ⚠️ 必须重置，Pool 不保证干净
	defer bufPool.Put(buf)
	// 用 buf 干活
}

1
2
3
4

var encPool = sync.Pool{New: func() any { return json.NewEncoder(io.Discard) }}

// 🛑 每次请求都新建 Encoder 会持续分配
// ✅ 复用，但注意 Encoder 持有 writer 引用，用完要 Reset

1
2
3

fmt.Println("Sizeof:", unsafe.Sizeof(Small{}), unsafe.Sizeof(Big{}), unsafe.Sizeof(int64(0)))
fmt.Println("Alignof:", unsafe.Alignof(Small{}), unsafe.Alignof(int64(0)), unsafe.Alignof(true))
fmt.Println("Offsetof:", unsafe.Offsetof(Small{}.A), unsafe.Offsetof(Small{}.B))

1
2
3

Sizeof: 16 65536 8
Alignof: 8 8 1
Offsetof: 0 8

1
2
3
4
5
6
7
8

✅ 允许的转换
   *T  ──►  unsafe.Pointer  ──►  *U          （任意指针互转）
   *T  ──►  unsafe.Pointer  ──►  uintptr     （仅用于打印/比较）
   uintptr  ──►  unsafe.Pointer  ──►  *T     （仅在同一个表达式内 ⚠️）

🛑 禁止
   *T ──► uintptr ──► 保存到变量 ──► 之后再转回 unsafe.Pointer
   → GC 可能在中间移动对象，指针失效 💥

1
2
3
4
5
6
7
8
9

// 🛑 危险：中间的 GC 可能让 p 失效
u := uintptr(unsafe.Pointer(p))
// ... 这里可能发生 GC 与栈增长 ...
q := (*T)(unsafe.Pointer(u))

// ✅ 正确：一气呵成
q := (*T)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) + offset))
// ✅ 更好：直接用 unsafe.Add
q := (*T)(unsafe.Add(unsafe.Pointer(p), offset))

1
2

b := []byte("hello")
s := unsafe.String(&b[0], len(b))   // ⚠️ s 与 b 共享内存，改 b 会影响 s

1
2
3

$ GODEBUG=gctrace=1 go run .
gc 1 @0.008s 1%: 0.070+0.31+0.020 ms clock, 0.70+0.16/0.55/0+0.20 ms cpu, 3->4->0 MB, 4 MB goal, 0 MB stacks, 0 MB globals, 10 P
gc 2 @0.011s 1%: 0.011+0.22+0.008 ms clock, 0.11+0.044/0.47/0.23+0.089 ms cpu, 3->3->1 MB, 4 MB goal, 0 MB stacks, 0 MB globals, 10 P