Go 内存管理、逃逸分析与垃圾回收

package main

import (
    "fmt"
    "runtime"
)

func main() {
    // 步骤1：打印 GOMAXPROCS，即 P 的数量，也即 mcache 的数量
    fmt.Println("GOMAXPROCS:", runtime.GOMAXPROCS(0))

    // 步骤2：分配一个小对象，走 mcache 无锁路径
    s := make([]int, 100)
    fmt.Println("slice len:", len(s))

    // 步骤3：读取并打印当前内存统计
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    fmt.Printf("HeapAlloc = %v MB\n", m.HeapAlloc/1024/1024)
    fmt.Printf("NumGC = %v\n", m.NumGC)
}

package main

import "fmt"

func main() {
    // 步骤1：小对象分配，走 mcache 无锁路径
    small := make([]byte, 1024)
    fmt.Println("small size:", len(small))

    // 步骤2：大对象分配（大于32KB），直接走 mheap
    large := make([]byte, 33*1024)
    fmt.Println("large size:", len(large))

    // 步骤3：预分配容量，避免多次扩容拷贝
    pre := make([]int, 0, 1000)
    for i := 0; i < 1000; i++ {
        pre = append(pre, i)
    }
    fmt.Println("pre-allocated cap:", cap(pre))
}

# 步骤1：-m 显示逃逸分析结果，-l 禁用内联（避免内联干扰分析）
go build -gcflags="-m -l" main.go

# 步骤2：两个 -m 显示更详细的分析过程
go build -gcflags="-m -m -l" main.go

package main

import "fmt"

// 场景1：返回局部变量指针
func newInt() *int {
    // 步骤1：x 本应在栈上，但返回了指针，编译器判定它逃逸到堆
    x := 42
    return &x
}

// 场景2：interface 动态类型
func printVal(v interface{}) {
    // 步骤1：v 是 interface 类型，实际值会逃逸到堆
    fmt.Println(v)
}

// 场景3：闭包引用
func counter() func() int {
    // 步骤1：n 被闭包捕获，生命周期超出 counter 函数，逃逸到堆
    n := 0
    return func() int {
        n++
        return n
    }
}

// 场景4：发送到 channel 的指针
func sendPtr(ch chan *int) {
    // 步骤1：val 的指针被发送到 channel，接收者可能在其他 goroutine，逃逸
    val := 100
    ch <- &val
}

// 场景5：slice 超过栈容量
func bigSlice() {
    // 步骤1：超过一定大小的 slice 会在堆上分配
    s := make([]int, 10000)
    fmt.Println(len(s))
}

// 场景6：未逃逸
func add(a, b int) int {
    // 步骤1：a 和 b 仅在函数内使用，分配在栈上
    return a + b
}

func main() {
    p := newInt()
    fmt.Println(*p)

    printVal(42)

    c := counter()
    fmt.Println(c())

    ch := make(chan *int, 1)
    sendPtr(ch)
    fmt.Println(*(<-ch))

    bigSlice()

    fmt.Println(add(1, 2))
}

package main

import (
    "fmt"
    "unsafe"
)

// b2s []byte 转 string，零拷贝
func b2s(b []byte) string {
    // 步骤1：unsafe.SliceData 获取底层数据指针，unsafe.String 直接构造 string
    return unsafe.String(unsafe.SliceData(b), len(b))
}

// s2b string 转 []byte，零拷贝
func s2b(s string) []byte {
    // 步骤2：unsafe.StringData 获取底层数据指针，unsafe.Slice 直接构造切片
    return unsafe.Slice(unsafe.StringData(s), len(s))
}

func main() {
    // 步骤3：[]byte 转 string，不拷贝
    b := []byte("hello world")
    s := b2s(b)
    fmt.Println(s)

    // 步骤4：string 转 []byte，不拷贝（只读使用，不要修改）
    str := "Go语言"
    bytes := s2b(str)
    fmt.Println(bytes)
}

package main

import (
    "bytes"
    "fmt"
)

func main() {
    // 步骤1：创建 Buffer，内部维护可增长的 []byte
    var buf bytes.Buffer

    // 步骤2：多次写入，Buffer 自动扩容，避免每次拼接都分配新内存
    for i := 0; i < 100; i++ {
        buf.WriteString("hello ")
        buf.WriteString("world\n")
    }

    // 步骤3：最终一次性取出结果
    result := buf.String()
    fmt.Println("total bytes:", len(result))
}

package main

import (
    "fmt"
    "io"
    "strings"
)

func main() {
    // 步骤1：创建数据源 Reader
    src := strings.NewReader("Go streaming data processing example")

    // 步骤2：创建目标 Writer（可以是文件、网络连接等）
    var dst strings.Builder

    // 步骤3：用 io.Copy 流式拷贝，内部使用 32KB 缓冲区，不一次性加载全部数据
    n, err := io.Copy(&dst, src)
    if err != nil {
        fmt.Println("copy error:", err)
        return
    }

    fmt.Printf("copied %d bytes\n", n)
    fmt.Println("result:", dst.String())
}

package main

import (
    "context"
    "fmt"
    "time"
)

// 泄露版本：channel 阻塞，goroutine 永远等待
func leakyFunc() {
    ch := make(chan int) // 无缓冲 channel
    go func() {
        // 步骤1：等待接收数据，但无人发送，永久阻塞
        val := <-ch
        fmt.Println("received:", val)
    }()
    // 步骤2：函数返回，channel 无人引用，但 goroutine 仍在等待
}

// 修复版本：使用 context 超时控制
func fixedFunc(ctx context.Context) {
    ch := make(chan int, 1)
    go func() {
        // 步骤3：使用 select 同时监听 channel 和 context
        select {
        case val := <-ch:
            fmt.Println("received:", val)
        case <-ctx.Done():
            // 步骤4：context 超时或取消，goroutine 正常退出
            fmt.Println("goroutine exited:", ctx.Err())
        }
    }()
}

func main() {
    // 步骤5：测试泄露版本（不要在生产环境运行）
    for i := 0; i < 10; i++ {
        leakyFunc()
    }
    time.Sleep(time.Second)
    fmt.Println("leaked goroutines created")

    // 步骤6：测试修复版本
    ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
    defer cancel()
    for i := 0; i < 10; i++ {
        fixedFunc(ctx)
    }
    time.Sleep(time.Second)
    fmt.Println("fixed goroutines exited")
}

package main

import (
    "fmt"
    "net/http"
    _ "net/http/pprof"
    "time"
)

func main() {
    // 步骤1：启动 pprof HTTP 服务器
    go func() {
        http.ListenAndServe("localhost:6060", nil)
    }()

    // 步骤2：模拟 goroutine 泄露
    ch := make(chan int)
    for i := 0; i < 100; i++ {
        go func() {
            <-ch // 永久阻塞
        }()
    }

    // 步骤3：等待用户访问 pprof
    time.Sleep(60 * time.Second)
    fmt.Println("访问 http://localhost:6060/debug/pprof/goroutine?debug=2")
    fmt.Println("或运行: go tool pprof http://localhost:6060/debug/pprof/goroutine")
}

# 步骤4：在终端中查看 goroutine 堆栈
go tool pprof http://localhost:6060/debug/pprof/goroutine

# 步骤5：在 pprof 交互界面中输入 top 查看阻塞最多的函数
# (pprof) top
# (pprof) traces

// 混合写屏障的运行时实现（伪代码，展示逻辑，非真实可运行代码）
func writeBarrier(slot *unsafe.Pointer, ptr unsafe.Pointer) {
    // 步骤1：Dijkstra 插入写屏障 —— 新指向的对象标灰
    shade(ptr)

    // 步骤2：Yuasa 删除写屏障 —— 原指向的对象标灰
    shade(*slot)

    // 步骤3：执行实际赋值
    *slot = ptr
}

# 步骤1：默认值 GOGC=100，堆翻倍时触发 GC
GOGC=100 ./myapp

# 步骤2：调大 GOGC，减少 GC 频率，但内存占用增加
GOGC=200 ./myapp

# 步骤3：调小 GOGC，增加 GC 频率，但内存占用降低
GOGC=50 ./myapp

# 步骤4：关闭 GC（仅用于测试，生产环境禁止）
GOGC=off ./myapp

# 步骤5：Go 1.19+ 设置内存硬限制，配合 GOGC 使用
GOMEMLIMIT=512MiB GOGC=100 ./myapp

package main

import (
    "fmt"
    "runtime"
    "runtime/debug"
)

func main() {
    // 步骤1：读取当前 GOGC 值
    gogc := debug.SetGCPercent(-1)
    debug.SetGCPercent(gogc) // 恢复原值
    fmt.Printf("当前 GOGC = %d\n", gogc)

    // 步骤2：设置 GOMEMLIMIT（Go 1.19+）
    // 设为 512MB，超出时强制触发 GC
    oldLimit := debug.SetMemoryLimit(512 * 1024 * 1024)
    defer debug.SetMemoryLimit(oldLimit)

    // 步骤3：手动触发一次 GC
    runtime.GC()

    // 步骤4：读取内存统计
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    fmt.Printf("HeapAlloc = %d MB\n", m.HeapAlloc/1024/1024)
    fmt.Printf("NumGC = %d\n", m.NumGC)
    fmt.Printf("PauseTotalNs = %d ms\n", m.PauseTotalNs/1000000)
}

# 步骤5：运行时开启 GC 日志，观察每次 GC 的详细信息
# 输出格式：GC N: STW ...
GODEBUG=gctrace=1 ./myapp

package main

import (
    "bytes"
    "fmt"
    "sync"
)

var bufPool = sync.Pool{
    // 步骤1：New 函数在池为空时创建新对象
    New: func() interface{} {
        return new(bytes.Buffer)
    },
}

func process(data string) string {
    // 步骤2：从池中获取 Buffer（可能复用，可能新建）
    buf := bufPool.Get().(*bytes.Buffer)

    // 步骤3：用完后放回池中，下次复用
    defer func() {
        buf.Reset()
        bufPool.Put(buf)
    }()

    // 步骤4：使用 Buffer 处理数据
    buf.WriteString("prefix-")
    buf.WriteString(data)
    buf.WriteString("-suffix")
    return buf.String()
}

func main() {
    // 步骤5：多次调用，复用同一个 Buffer，减少堆分配
    for i := 0; i < 100; i++ {
        result := process("hello")
        if i == 0 {
            fmt.Println(result)
        }
    }
}

package main

import (
    "fmt"
    "os"
    "syscall"
)

func main() {
    // 步骤1：打开源文件，数据此时在内核页缓存中
    src, err := os.Open("source.txt")
    if err != nil {
        panic(err)
    }
    defer src.Close()

    // 步骤2：创建目标文件
    dst, err := os.Create("dest.txt")
    if err != nil {
        panic(err)
    }
    defer dst.Close()

    // 步骤3：调用 Sendfile，数据从 src fd 直接搬到 dst fd
    // 全程停留在内核态，用户态只拿到返回值（拷贝字节数）
    n, err := syscall.Sendfile(int(dst.Fd()), int(src.Fd()), nil, 1<<20)
    if err != nil {
        panic(err)
    }
    fmt.Printf("sendfile 零拷贝搬运了 %d 字节\n", n)
}

package main

import (
    "fmt"
    "os"
    "syscall"
)

func main() {
    // 步骤1：以读写方式打开文件
    f, err := os.OpenFile("data.txt", os.O_RDWR, 0644)
    if err != nil {
        panic(err)
    }
    defer f.Close()

    // 步骤2：获取文件大小，作为映射长度
    fi, _ := f.Stat()
    size := int(fi.Size())

    // 步骤3：将文件映射到虚拟内存
    // MAP_SHARED：对内存的修改会回写文件；PROT_READ|PROT_WRITE：可读可写
    data, err := syscall.Mmap(int(f.Fd()), 0, size,
        syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_SHARED)
    if err != nil {
        panic(err)
    }
    // 步骤4：退出前解除映射，避免内存泄漏
    defer syscall.Munmap(data)

    // 步骤5：像操作切片一样读写文件，无需任何 read/write 系统调用
    fmt.Printf("首字节: %c\n", data[0])
    data[0] = 'X' // 直接改内存，内核负责同步到磁盘
    fmt.Println("已通过 mmap 原地修改文件")
}

package main

import (
    "fmt"
    "os"
    "syscall"

    "golang.org/x/sys/unix"
)

func main() {
    // 步骤1：创建内核管道，作为 splice 的中间通道
    var pipeFds [2]int
    if err := unix.Pipe(pipeFds[:]); err != nil {
        panic(err)
    }
    defer syscall.Close(pipeFds[0])
    defer syscall.Close(pipeFds[1])

    // 步骤2：打开源文件与目标文件
    src, err := os.Open("source.txt")
    if err != nil {
        panic(err)
    }
    defer src.Close()
    dst, err := os.Create("dest.txt")
    if err != nil {
        panic(err)
    }
    defer dst.Close()

    // 步骤3：splice 把源文件数据搬进管道（内核态，不进用户态）
    n1, err := unix.Splice(int(src.Fd()), nil, pipeFds[1], nil, 1<<20, 0)
    if err != nil {
        panic(err)
    }
    // 步骤4：splice 把管道数据搬到目标文件（仍然内核态）
    n2, err := unix.Splice(pipeFds[0], nil, int(dst.Fd()), nil, int(n1), 0)
    if err != nil {
        panic(err)
    }
    fmt.Printf("splice 零拷贝转发了 %d 字节\n", n2)
}

# 步骤1：逃逸分析（最常用），-l 关闭内联让结果更直观
go build -gcflags="-m -l" main.go

# 步骤2：-m 可叠加，最多约 4 层，信息逐层变细
go build -gcflags="-m -m -m -l" main.go

# 步骤3：输出汇编，确认某函数是否被内联
go build -gcflags="-S" main.go 2>&1 | grep -A5 "main.foo"

# 步骤4：禁用优化 + 禁用内联，方便调试器逐行跟踪
go build -gcflags="-N -l" -o app main.go

# 步骤1：查看编译器支持的全部选项（最权威，包含已废弃项说明）
go tool compile -help

# 步骤2：查看 -d 下属的调试子项（逃逸、内联、写屏障等都挂在这里）
go tool compile -d=help

# 步骤3：在 Go 官方文档中检索编译器与链接器文档
go doc cmd/compile
go doc cmd/link

# 步骤4：开启“编译期所有诊断”看编译器在想什么
go build -gcflags="-m -m -m -d=checkptr" main.go

package main

import (
	"fmt"
	"time"
)

// 错误示范：两个 goroutine 对共享变量既无锁也无 channel 同步
func wrong() {
	var x int
	// 步骤1：goroutine A 写 x
	go func() {
		x = 1 // 没有同步，这行对下面读的 goroutine 不一定可见
	}()
	// 步骤2：main goroutine 直接读 x
	// 没有任何 happens-before 边把"写 x"和"读 x"连起来
	if x == 1 {
		fmt.Println("看到了 1") // 可能打印，也可能不打印
	}
	time.Sleep(10 * time.Millisecond)
	fmt.Println("x =", x) // 大概率 1，但属于"运气好"，并非内存模型保证
}

// 用 -race 运行会报告数据竞争：WARNING: DATA RACE

package main

import "fmt"

// 正确示范：用 channel 交接，发送 happens-before 接收
func rightWithChannel() {
	var x int
	done := make(chan struct{})
	// 步骤1：goroutine A 写 x 后，通过 close(done) 通知
	go func() {
		x = 1                 // 步骤2：在 close 之前写
		close(done)           // 步骤3：close happens-before 接收方从 done 收到
	}()
	<-done                   // 步骤4：接收完成，保证能看到 x = 1
	fmt.Println("x =", x)     // 一定是 1，内存模型保证
}

package main

import (
	"fmt"
	"sync"
)

// 正确示范：锁的 Unlock happens-before 后续 Lock
func rightWithMutex() {
	var (
		x  int
		mu sync.Mutex
		wg sync.WaitGroup
	)
	wg.Add(1)
	go func() {
		defer wg.Done()
		mu.Lock()
		x = 1          // 步骤1：持锁写
		mu.Unlock()    // 步骤2：Unlock
	}()
	mu.Lock()         // 步骤3：这次 Lock happens-after 上面的 Unlock
	fmt.Println("x =", x) // 一定是 1
	mu.Unlock()
	wg.Wait()
}

package main

import (
	"fmt"
	"sync"
	"sync/atomic"
)

// 正确示范：atomic 的写 happens-before 任意后续对该地址的原子读
func rightWithAtomic() {
	var x int64
	var wg sync.WaitGroup
	wg.Add(1)
	go func() {
		defer wg.Done()
		atomic.StoreInt64(&x, 1) // 步骤1：原子写
	}()
	wg.Wait()                       // 步骤2：WaitGroup 也建立 happens-before
	fmt.Println(atomic.LoadInt64(&x)) // 一定是 1
}