HikariTish

1
应用层（代码）
2
    │
3
    ├── 频繁创建堆对象 ──→ 触发 GC 扫描
4
    ├── 大量指针引用   ──→ 增加标记成本
5
    └── 大对象分配     ──→ 内存峰值波动
6
                            │
7
                            ↓
8
                    GC 执行（标记 + 清除）
9
                            │
10
                            ├── CPU 消耗（Mark Assist）
11
                            ├── 内存峰值（堆膨胀）
12
                            └── STW 停顿（极短但不为零）

1
// 运行时动态设置
2
debug.SetGCPercent(200)
3

4
// 环境变量设置
5
// GOGC=200 ./myapp
6

7
// 读取当前值
8
pct := debug.SetGCPercent(-1)  // 返回当前值，不修改

1
// 场景 1：内存宽裕但 CPU 满载的计算密集型应用
2
// → 调大 GOGC，用内存换 CPU
3
// GOGC=500 ./cpu-bound-service
4

5
// 场景 2：内存受限环境（小容器/嵌入式）
6
// → 调小 GOGC，用 CPU 换内存
7
// GOGC=25 ./memory-constrained-app
8

9
// 场景 3：极致延迟追求（游戏服务器、批处理任务）
10
// → 关闭自动 GC，业务空闲时手动触发
11
debug.SetGCPercent(-1)
12
processBatch()           // 高效处理
13
runtime.GC()             // 手动回收
14
debug.SetGCPercent(100)  // 恢复

1
// 运行时设置
2
debug.SetMemoryLimit(1800 * 1 << 20)  // 1800 MiB
3

4
// 环境变量设置
5
// GOMEMLIMIT=1800MiB ./myapp

1
堆内存使用量
2
    ↑
3
    │                                    ┌─ OOM Kill 线（容器限制）
4
    │                              ══════┤  例：2GB
5
    │                           ╱        │
6
    │                        ╱           │
7
    │  ┌──────────────────╱              │
8
    │  │  GOGC 触发线 ← 积极 GC 区域     │
9
    │  │               GOMEMLIMIT=1.8GB  │
10
    │  │                                 │
11
    │  │  正常 GC（GOGC 控制）            │
12
    │  │                                 │
13
    └──┴────────────────────────────────→ 时间

1
// GOGC=off 时 GOMEMLIMIT 仍生效——GC 会在接近限制时触发
2
debug.SetGCPercent(-1)           // 关闭 GOGC 触发
3
debug.SetMemoryLimit(1 << 30)    // 但 1GB 上限时仍会触发
4
// 适合：物理内存有限但不希望 GOGC 频繁触发的场景

1
// ❌ 每次请求都分配新 buffer
2
func handleRequest(data []byte) {
3
    buf := make([]byte, 1024)   // 每次分配 → 成为 GC 负担
4
    copy(buf, data)
5
    process(buf)
6
}
7

8
// ✅ 使用 sync.Pool 复用
9
var bufPool = sync.Pool{
10
    New: func() any {
11
        return make([]byte, 1024)
12
    },
13
}
14

15
func handleRequest(data []byte) {
16
    buf := bufPool.Get().([]byte)       // 从池中取
17
    defer func() {
18
        clear(buf)                      // ⚠️ 清空数据，防止泄漏
19
        bufPool.Put(buf)                // 归还池中
20
    }()
21
    copy(buf, data)
22
    process(buf)
23
}

1
// sync.Pool 在每次 GC 时会被清空
2
// 这意味着：
3
// 1. 池中的对象会在 GC 时被回收（不阻止 GC）
4
// 2. 如果 GC 频率高，Pool 的命中率会下降
5
// 3. 适合 GOGC 较大的场景（GC 间隔长，Pool 利用率高）

1
// ❌ 不必要的指针返回 → 逃逸到堆
2
func newUser(name string) *User {
3
    u := User{Name: name}   // u 本可以在栈上
4
    return &u               // 返回指针 → 逃逸！
5
}
6

7
// ✅ 按值返回 → 留在栈上
8
func newUser(name string) User {
9
    return User{Name: name} // 无逃逸，零 GC 开销
10
}
11

12
// ❌ 接口装箱 → 逃逸
13
func print(v any) {
14
    fmt.Println(v)
15
}
16

17
func main() {
18
    x := 42                  // int 本在栈上
19
    print(x)                 // 装箱为 interface{} → 逃逸到堆！
20
}
21

22
// ✅ 泛型避免装箱（Go 1.18+）
23
func print[T any](v T) {
24
    fmt.Println(v)
25
}

1
// ❌ 无预分配：多次扩容，多次分配
2
func buildSlice(n int) []int {
3
    var s []int              // cap = 0
4
    for i := 0; i < n; i++ {
5
        s = append(s, i)     // 扩容：1→2→4→8→16... 每次扩容 = 新数组 + 复制 + 旧数组变垃圾
6
    }
7
    return s
8
}
9

10
// ✅ 预分配容量：一次分配到位
11
func buildSlice(n int) []int {
12
    s := make([]int, 0, n)   // cap = n，无需扩容
13
    for i := 0; i < n; i++ {
14
        s = append(s, i)
15
    }
16
    return s
17
}
18

19
// ✅ Map 同样需要预分配
20
m := make(map[string]int, expectedSize)

1
// 从原型推断容量
2
users := make([]User, 0, len(input))
3

4
// 已知固定大小
5
buf := make([]byte, 0, 4096)
6

7
// 一个常见陷阱：make 的第二个参数是 len 不是 cap
8
s := make([]int, 100)       // len=100, cap=100 → 已有 100 个零值
9
s := make([]int, 0, 100)    // len=0,   cap=100 → 空但预分配了容量 ← 通常推荐！

1
// ❌ 数百万指针 → GC 扫描压力巨大
2
type Cache struct {
3
    items map[string]*Item   // 假设 100 万个条目，每个 Item 都是指针
4
}
5

6
// ✅ 值类型 + 扁平化 → 减少扫描
7
type Cache struct {
8
    items map[string]Item    // 值类型，GC 只扫描 map 本身
9
}
10

11
// ✅✅ 进一步优化：连续内存替代散列
12
type Cache struct {
13
    keys   []string          // 键列表（连续内存）
14
    values []Item            // 值列表（连续内存）
15
    index  map[string]int    // 小索引：string→数组下标
16
}
17
// 虽然仍然有指针，但 GC 扫描范围从"百万个 Item"变为"一个 map"

1
// 1. 用索引替代指针
2
type Node struct {
3
    children []int  // 子节点索引，而非 []*Node
4
}
5
nodes := []Node{...}  // 所有节点在连续内存中
6

7
// 2. 大数组存值而非指针
8
// ❌  items := make([]*LargeStruct, 10000)
9
// ✅  items := make([]LargeStruct, 10000)
10

11
// 3. 字符串处理优化
12
// ❌  map[string]*SomeStruct
13
// ✅  如果 key 是枚举型，改用 map[int]SomeStruct

1
// 引入 pprof 端点
2
import _ "net/http/pprof"
3

4
func main() {
5
    go func() {
6
        log.Println(http.ListenAndServe("localhost:6060", nil))
7
    }()
8
    // ... 业务逻辑
9
}

1
import (
2
    "os"
3
    "runtime/trace"
4
)
5

6
func main() {
7
    f, _ := os.Create("trace.out")
8
    defer f.Close()
9

10
    trace.Start(f)
11
    defer trace.Stop()
12
    // ... 业务逻辑
13
}

1
时间线视图
2
├── GC 标记阶段（所有 P 的灰白交替）
3
├── STW 暂停点（垂直红线）
4
├── Mark Assist（G 被迫协助标记的时刻）
5
├── 各 Goroutine 的实际执行时间
6
└── P 被 GC 占用的时长 vs 执行用户代码的时长

1
./main.go:10:2: moved to heap: user    ← 逃逸了
2
./main.go:15:9: x does not escape      ← 留在栈上

1
┌─────────────────────────────────────────────────────────────────┐
2
│                       Go GC 调优全景                             │
3
├─────────────────────────────────────────────────────────────────┤
4
│                                                                 │
5
│   第一层：参数调优（运行时控制）                                   │
6
│   ┌──────────────────────────────────────┐                      │
7
│   │  GOGC          → 控制 GC 触发频率     │                      │
8
│   │  GOMEMLIMIT    → 软内存上限，防 OOM   │                      │
9
│   │  runtime.GC()  → 手动触发            │                      │
10
│   └──────────────────────────────────────┘                      │
11
│                         ↓                                       │
12
│   第二层：代码调优（减少堆分配）                                   │
13
│   ┌──────────────────────────────────────┐                      │
14
│   │  sync.Pool     → 对象复用，跳过分配   │                      │
15
│   │  逃逸分析      → 让变量留在栈上       │                      │
16
│   │  预分配        → make 指定 cap        │                      │
17
│   │  减少指针      → 值类型 + 扁平化      │                      │
18
│   └──────────────────────────────────────┘                      │
19
│                         ↓                                       │
20
│   第三层：观察手段（验证效果）                                     │
21
│   ┌──────────────────────────────────────┐                      │
22
│   │  GODEBUG       → 实时 GC 日志         │                      │
23
│   │  pprof heap    → 分配热点 / 内存泄漏   │                      │
24
│   │  trace         → 微秒级 GC 事件分析   │                      │
25
│   │  gcflags="-m"  → 编译期逃逸诊断       │                      │
26
│   └──────────────────────────────────────┘                      │
27
│                                                                 │
28
└─────────────────────────────────────────────────────────────────┘