第一章：golang常驻内存吗
Go 程序本身并不“常驻内存”——它编译为静态链接的可执行文件，启动时加载到内存中运行，退出后释放全部资源。是否“常驻”，取决于进程生命周期，而非语言特性。
进程生命周期决定内存驻留
- 启动时：操作系统将二进制映像（含代码段、数据段、堆、栈）载入内存；
- 运行中：GC 自动管理堆内存，但 goroutine 栈、全局变量、未被回收的对象持续占用内存；
- 退出时：内核回收进程所有内存页（包括堆、栈、BSS、data 段），不留残留。
这与 Java 的 JVM 长期驻留或 Python 解释器常驻不同：Go 程序是典型的“即启即走”模型。
如何验证内存行为？
可通过 ps 和 /proc 观察实时内存占用：
# 编译并后台运行一个简单 HTTP 服务
go build -o server main.go
./server &
# 查看进程 PID 和 RSS（实际物理内存使用）
ps -o pid,rss,comm -p $(pgrep server)
# 检查其内存映射详情（重点关注 anon-rss 和 heap 区域）
cat /proc/$(pgrep server)/smaps | grep -E "^(Size|RSS|heap|anon)"注意：RSS（Resident Set Size）反映当前驻留物理内存大小；若程序空闲但未退出，RSS 不会归零，但也不会无限增长（受 GC 控制）。
影响常驻感的关键因素
- 长期运行的服务：如 Web 服务器、守护进程，因进程不退出，给人“常驻”印象；
- 内存泄漏：未释放的指针（如全局 map 持有对象引用）、goroutine 泄漏，导致 RSS 持续上升；
- GC 延迟：
GOGC=100下，堆增长至上次回收量 2 倍才触发，可能造成短期内存滞留。
| 场景 | 是否实质常驻 | 原因说明 |
|---|---|---|
| CLI 工具执行完毕 | 否 | 进程终止，内核立即回收内存 |
http.ListenAndServe 长期运行 |
是（进程级） | 进程存活，内存随负载动态变化 |
| goroutine 无限 sleep | 是（但低开销） | 协程栈保留，但仅 2KB 起步 |
Go 的内存管理透明而高效，但“常驻”本质是进程行为，而非语言设计意图。
第二章：unsafe.Pointer与内存生命周期的隐式绑定
2.1 unsafe.Pointer如何绕过Go内存管理机制
unsafe.Pointer 是 Go 中唯一能自由转换为任意指针类型的桥梁，它直接跳过类型系统与垃圾回收器的检查。
核心能力：类型擦除与地址直读
- 绕过编译期类型安全校验
- 避免 GC 对底层内存的追踪（若未配合
runtime.KeepAlive易致悬垂指针） - 允许对结构体字段进行偏移量级访问
典型用法示例
type Header struct {
Data *[4]byte
}
h := &Header{Data: &[4]byte{1, 2, 3, 4}}
p := (*[4]byte)(unsafe.Pointer(&h.Data)) // 强制重解释指针此处将
*[4]byte指针转为[4]byte数组指针，跳过 Go 的“不可寻址数组字面量”限制；unsafe.Pointer作为中转媒介，使内存布局解释权回归开发者。
| 场景 | 是否触发 GC 扫描 | 安全风险 |
|---|---|---|
(*T)(unsafe.Pointer(&x)) |
否 | 高（x 可能被提前回收） |
&x[0] via unsafe |
否 | 中（需确保切片底层数组存活） |
graph TD
A[Go变量] -->|取地址| B[uintptr/unsafe.Pointer]
B --> C[强制类型转换]
C --> D[绕过类型系统]
D --> E[直接读写内存]2.2 实战：通过unsafe.Pointer延长底层内存块存活期
Go 的垃圾回收器会回收不再被任何强引用指向的底层数据。但有时需让底层字节切片（如 []byte）在上层 slice 被释放后仍保持有效——此时 unsafe.Pointer 可建立隐式引用链。
核心机制：伪造强引用
func keepAliveByPointer(data []byte) *C.char {
ptr := unsafe.Pointer(&data[0]) // 获取底层数组首地址
C.free(C.CString("")) // 触发 GC 检查（仅示意）
return (*C.char)(ptr) // 返回裸指针，阻止 data 底层数组被回收
}逻辑分析：
&data[0]生成unsafe.Pointer后，若该指针在函数返回后仍被 Go 运行时“可见”（如转为*C.char并传入 C 函数），GC 会保守地认为底层数组仍在使用。注意：此行为依赖 Go 编译器对unsafe.Pointer转换的逃逸分析抑制。
关键约束（表格速查）
| 条件 | 是否必需 | 说明 |
|---|---|---|
data 非空 |
✅ | 空切片无底层数组地址 |
ptr 必须逃逸到函数外 |
✅ | 局部 unsafe.Pointer 不影响 GC 判定 |
不得与 runtime.KeepAlive 混用 |
⚠️ | 二者语义冲突 |
数据同步机制
- 使用
sync.Pool配合unsafe.Pointer复用底层内存； - 所有
unsafe操作必须包裹在//go:noescape注释块中。
2.3 源码剖析：runtime.markroot与GC对unsafe.Pointer的特殊处理
Go 的 GC 在标记阶段需谨慎处理 unsafe.Pointer，因其绕过类型系统，无法通过常规指针追踪。runtime.markroot 函数在根扫描（root marking）中对含 unsafe.Pointer 的栈帧和全局变量执行保守扫描。
GC 对 unsafe.Pointer 的三重约束
- 不允许直接作为堆对象字段存储（编译器拒绝
struct{ p unsafe.Pointer }的逃逸分析） - 仅允许在
reflect、syscall等极少数包中临时持有 - 若其值指向堆内存，必须由用户通过
runtime.KeepAlive显式延长生命周期
核心逻辑片段（src/runtime/mgcmark.go）
func markroot(scanned *gcWork, i uint32) {
// ...
switch {
case i < uint32(work.nstackRoots):
// 栈根：对每个栈帧，扫描时跳过 unsafe.Pointer 字段（按类型信息屏蔽）
scanstack(uintptr(unsafe.Pointer(&work.stackRoots[i])), scanned)
case i < uint32(work.nstackRoots+work.nglobRoots):
// 全局根：仅当该全局变量类型明确标注为 *T（非 unsafe）才标记
ptr := (*uintptr)(unsafe.Pointer(work.globRoots[i-work.nstackRoots]))
if !isUnsafePointer(ptr) { // 内部通过 type.hash 判断
scanned.push(ptr)
}
}
}此处
isUnsafePointer并非运行时动态识别，而是编译期注入的类型元数据查询——GC 依赖runtime._type.kind & kindUnsafePointer位标志做静态过滤。
| 场景 | GC 行为 | 安全保障机制 |
|---|---|---|
*int 字段 |
正常标记并追踪 | 类型系统保证可达性 |
unsafe.Pointer 字段 |
完全跳过（不推入 workbuf） | 编译器禁止其逃逸 |
reflect.Value 内部 |
通过 runtime/internal/unsafeheader 白名单特例处理 |
受限 runtime 包豁免 |
graph TD
A[markroot 调用] --> B{是否为栈/全局根？}
B -->|是栈| C[scanstack → 按 frame.type 掩码过滤]
B -->|是全局| D[查 globRoots.type.kind]
C --> E[跳过 kindUnsafePointer 字段]
D --> E
E --> F[避免误标裸地址导致悬垂引用]2.4 调试实践：用pprof+gdb定位被unsafe.Pointer“钉住”的内存
Go 中 unsafe.Pointer 可绕过 GC 引用追踪，导致对象无法回收——这类“钉住”（pinned）内存常表现为 heap profile 持续增长但无明显泄漏点。
pprof 初筛：识别可疑存活对象
go tool pprof -http=:8080 ./app mem.pprof在 Web UI 中按 top 查看 runtime.mallocgc 调用栈，重点关注含 unsafe.* 或自定义 *C.struct_XXX 的路径。
gdb 深挖：定位指针持有者
gdb ./app
(gdb) set $p = *(unsafe.Pointer*)0x000000c000123000 # 假设该地址为疑似钉住对象首址
(gdb) info proc mappings # 确认地址所属内存段
(gdb) x/10gx $p-0x10 # 向前查看元数据（如 span、mspan）$p 是 unsafe.Pointer 指向的原始地址；x/10gx 以 16 进制显示 10 个 8 字节单元，用于反查 runtime 分配元信息。
关键诊断流程
graph TD
A[pprof heap profile] –> B{是否存在 long-lived unsafe.Pointer?}
B –>|Yes| C[gdb attach + inspect memory layout]
B –>|No| D[检查 finalizer 或 cgo handle]
C –> E[定位持有该 Pointer 的 Go 变量或 C 全局变量]
| 工具 | 作用 | 局限 |
|---|---|---|
pprof |
定位高存活堆分配栈 | 无法看到裸指针引用链 |
gdb |
直接读取 runtime 内存结构 | 需符号表与调试构建 |
2.5 风险案例：unsafe.Slice导致的内存泄漏复现与规避方案
复现代码片段
func leakProneSlice(data []byte, offset int, length int) []byte {
// ⚠️ 错误：未约束底层数组生命周期，导致data无法被GC
return unsafe.Slice(&data[offset], length)
}unsafe.Slice 仅生成新切片头，不复制数据也不延长原底层数组引用计数；若 data 是短生命周期局部切片（如函数参数），其底层数组可能因返回值持有而长期驻留内存。
关键规避策略
- ✅ 使用
copy()+make([]byte, length)显式分配独立底层数组 - ✅ 对长生命周期切片，改用
data[offset:offset+length]（安全切片表达式） - ❌ 禁止在闭包或全局缓存中返回
unsafe.Slice结果
内存影响对比
| 方式 | 底层数组引用延长 | GC 可回收性 | 安全等级 |
|---|---|---|---|
unsafe.Slice |
是 | 否 | ⚠️ 高危 |
| 安全切片表达式 | 否（受限于原范围） | 是 | ✅ 推荐 |
copy + make |
否 | 是 | ✅ 推荐 |
第三章：cgo调用链中的内存驻留陷阱
3.1 cgo调用栈中C内存分配与Go GC的隔离边界
Go运行时对C分配的内存完全不可见，GC不会扫描、标记或回收malloc/calloc等返回的指针。
内存生命周期责任分离
- Go堆：由GC自动管理，对象逃逸分析决定分配位置
- C堆：由开发者手动管理（
free配对），CGO调用栈中分配即脱离GC视野 - 混合指针（如
*C.char）在Go代码中仅作“不透明句柄”，GC不递归追踪其指向内容
典型误用示例
// C部分：分配后返回裸指针
char* new_buffer() {
return (char*)malloc(1024); // GC完全不知情
}// Go部分：未配对free → 内存泄漏
func misuse() {
p := C.new_buffer()
// 忘记调用 C.free(unsafe.Pointer(p))
}逻辑分析：
C.new_buffer()返回的*C.char在Go中是unsafe.Pointer语义，GC仅保留该变量本身（栈上指针值），绝不访问其指向的1024字节C堆内存；参数p无类型信息、无finalizer绑定、无写屏障拦截。
| 隔离维度 | Go内存 | C内存 |
|---|---|---|
| 分配器 | mheap/mcache | libc malloc arena |
| 回收机制 | 三色标记-清除 | 手动 free / calloc |
| GC可见性 | ✅ 全量扫描 | ❌ 完全不可见 |
graph TD
A[Go函数调用C.new_buffer] --> B[C堆分配1024B]
B --> C[返回*char给Go栈]
C --> D[Go GC扫描栈变量p]
D --> E[仅保留p指针值]
E --> F[忽略p所指C内存]3.2 实战：CGO_NO_GC=1场景下C堆内存未释放的完整链路追踪
当启用 CGO_NO_GC=1 时，Go 运行时完全跳过对 C 分配内存（如 C.malloc）的扫描与跟踪，导致 C 堆对象无法被自动回收。
内存泄漏触发点
// cgo_export.h
#include <stdlib.h>
void* leaky_alloc(size_t sz) {
return malloc(sz); // Go GC 不知此指针存在
}该函数返回的指针未被 Go runtime 记录，CGO_NO_GC=1 下更无任何元信息注册，成为 GC “盲区”。
关键调用链
- Go 侧调用
C.leaky_alloc(1024) - 返回指针被赋值给
*C.void变量并长期持有 - 程序退出前未调用
C.free()→ 内存永久泄漏
CGO_NO_GC=1 影响对比
| 行为 | CGO_NO_GC=0（默认） |
CGO_NO_GC=1 |
|---|---|---|
| C 指针是否入栈扫描 | 是 | 否 |
| 是否触发 finalizer | 可能（若注册） | 完全忽略 |
| 内存泄漏风险 | 中（依赖正确注册） | 高（零防护） |
// go side — no free call, no finalizer registration
p := C.leaky_alloc(1024)
// p 逃逸至全局或长生命周期结构体 → 泄漏确定此处 p 未绑定任何 runtime.SetFinalizer，且 CGO_NO_GC=1 屏蔽所有隐式跟踪，泄漏路径彻底闭环。
3.3 源码验证：runtime.cgoCheckPointer与cgo pointer tracking的失效条件
cgo pointer tracking 的核心约束
Go 运行时通过 cgoCheckPointer 在 GC 前校验 Go 指针是否被 C 代码非法持有。但以下场景会绕过检查：
- C 代码通过
uintptr中转指针（类型擦除） - 指针经
unsafe.Pointer → uintptr → *T二次转换 - C 分配内存未调用
C.CBytes而直接malloc
失效条件验证代码
func bypassCheck() {
s := []byte("hello")
p := &s[0]
// ❌ 触发 cgoCheckPointer panic（若启用 CGO_CHECK=1）
// C.takePtr((*C.char)(unsafe.Pointer(p)))
// ✅ 绕过：转为 uintptr 后传入 C
u := uintptr(unsafe.Pointer(p))
C.takeUintptr(u) // runtime 不追踪 uintptr
}逻辑分析：
cgoCheckPointer仅对unsafe.Pointer类型参数做栈/寄存器扫描，uintptr被视为纯整数，不触发指针可达性分析。参数u无类型信息，GC 无法识别其底层指向 Go 堆对象。
失效场景对比表
| 条件 | 是否触发检查 | 原因 |
|---|---|---|
(*C.char)(unsafe.Pointer(&s[0])) |
✅ 是 | 显式 unsafe.Pointer 参数 |
uintptr(unsafe.Pointer(&s[0])) |
❌ 否 | uintptr 非指针类型，逃逸检测失效 |
C.malloc(size) 返回值转 *byte |
❌ 否 | C 堆内存不在 Go GC 管理范围 |
graph TD
A[Go 代码生成 unsafe.Pointer] --> B{cgoCheckPointer 检查}
B -->|是 Pointer 类型| C[扫描栈/寄存器中的 Go 指针]
B -->|是 uintptr 类型| D[跳过追踪：视为普通整数]
C --> E[若指向 Go 堆且 C 持有→panic]第四章：net.Conn底层资源持有与连接池伪常驻现象
4.1 net.Conn底层file descriptor、read/write buffers与runtime.netpoller的耦合关系
net.Conn 的 I/O 行为并非直接系统调用，而是经由三层协同：
- 底层
fd.sysfd（OS file descriptor） - 用户态读写缓冲区（如
conn.buf和conn.r/conn.w） - Go 运行时
runtime.netpoller（基于 epoll/kqueue/iocp 的事件驱动引擎）
数据同步机制
当调用 conn.Read(b)：
- 若内核 recv buffer 有数据且用户 buffer 未满 → 零拷贝复制；
- 否则注册
EPOLLIN事件到netpoller，goroutine park； netpoller唤醒后，再次尝试读取。
// src/net/fd_posix.go 中关键逻辑节选
func (fd *FD) Read(p []byte) (int, error) {
n, err := syscall.Read(fd.Sysfd, p) // 实际系统调用
if err == syscall.EAGAIN || err == syscall.EWOULDBLOCK {
// 触发 netpoller 等待
err = fd.pd.waitRead(fd.isFile)
}
return n, err
}fd.pd.waitRead() 将当前 goroutine 关联到 netpoller 的等待队列，并挂起调度器；Sysfd 是原始 fd，pd（pollDesc）封装了 runtime.netpoller 的句柄与状态。
核心耦合点
| 组件 | 职责 | 依赖方 |
|---|---|---|
fd.Sysfd |
OS 层文件描述符 | syscall.Read/Write |
fd.r/rd 缓冲区 |
用户态预读缓存 | bufio.Reader 或 conn.readBuf |
fd.pd |
事件注册/唤醒元数据 | runtime.netpoller |
graph TD
A[net.Conn.Read] --> B{内核buffer有数据？}
B -->|是| C[拷贝至用户buf，返回]
B -->|否| D[fd.pd.waitRead → park goroutine]
D --> E[runtime.netpoller 监听 EPOLLIN]
E --> F[就绪后唤醒G]
F --> A4.2 实战：Close()后仍残留的epoll_wait监听与goroutine阻塞分析
现象复现：被忽略的文件描述符生命周期
当 net.Conn.Close() 被调用，底层 socket fd 虽被标记关闭，但若 epoll_wait 仍在等待该 fd 事件，内核仍可能返回 EPOLLIN | EPOLLRDHUP，导致 goroutine 持续阻塞。
关键代码片段
// 伪代码：错误的资源清理顺序
conn, _ := listener.Accept()
go func() {
epoll.Wait() // 阻塞在此，未感知 conn.Close()
read(conn) // 此时 conn 已关闭，但 epoll 未移除 fd
}()
conn.Close() // 仅关闭 fd，未从 epoll 实例中 del逻辑分析：
Close()仅触发syscalls.close(fd)，但epoll_ctl(EPOLL_CTL_DEL)必须显式调用；否则该 fd 在 epoll 实例中持续“存活”，epoll_wait将反复返回就绪事件（尤其在边缘触发 ET 模式下更隐蔽）。
正确清理流程
- ✅ 调用
epoll_ctl(epfd, EPOLL_CTL_DEL, fd, nil) - ✅ 使用
runtime.SetFinalizer作兜底（不推荐依赖） - ❌ 仅依赖
Close()或 GC
| 步骤 | 操作 | 是否必需 |
|---|---|---|
| 1 | conn.Close() |
是（用户层语义） |
| 2 | epoll_ctl(... DEL ...) |
是（系统层同步） |
| 3 | close(epfd) |
否（可延迟至连接池回收） |
graph TD
A[conn.Close()] --> B[syscalls.close(fd)]
B --> C{fd 仍注册于 epoll？}
C -->|是| D[epoll_wait 持续返回就绪]
C -->|否| E[goroutine 正常退出]
F[显式 EPOLL_CTL_DEL] --> C4.3 源码级解读：net/http.Transport空闲连接复用与time.Timer泄漏关联
空闲连接管理核心字段
net/http.Transport 中关键字段：
idleConn：map[connectMethodKey][]*persistConnidleConnTimer：map[connectMethodKey]map[*persistConn]*timermaxIdleConnsPerHost默认为2，直接影响复用粒度
Timer泄漏的触发路径
// src/net/http/transport.go:1420 节选
if t.IdleConnTimeout > 0 {
timer := time.AfterFunc(t.IdleConnTimeout, p.closeConn)
p.idleTimer = timer // 若p被重复加入idleConn但未清理旧timer，即泄漏
}逻辑分析：persistConn.closeConn() 仅关闭底层连接，但 AfterFunc 创建的 *timer 若未显式 Stop()，将长期持有 p 引用，阻止 GC。
复用与泄漏的耦合关系
| 场景 | idleConn 状态 | Timer 状态 | 是否泄漏 |
|---|---|---|---|
| 首次归还 | ✅ 新增条目 | ✅ 新建 timer | 否 |
| 二次归还（未 Stop） | ✅ 覆盖条目 | ❌ 旧 timer 仍运行 | 是 |
graph TD
A[conn.Close] --> B{是否已存在idleConn条目？}
B -->|是| C[Stop 旧 timer]
B -->|否| D[创建新 timer]
C --> E[存入 idleConn & idleConnTimer]
D --> E4.4 压测验证：通过/proc/[pid]/fd与pstack交叉定位“已关闭但未释放”的Conn实例
在高并发压测中，netstat -an | grep TIME_WAIT 持续攀升却无对应业务连接增长，常指向 Conn 对象已调用 Close() 但底层文件描述符未释放。
关键诊断组合
/proc/[pid]/fd/：查看真实打开的 fd 数量及类型pstack [pid]：捕获 Goroutine 栈，定位阻塞或遗忘的defer conn.Close()
# 列出进程所有 fd，并过滤 socket 类型
ls -l /proc/12345/fd/ 2>/dev/null | grep socket | wc -l
# 输出示例：892 → 远超预期连接池大小（如 100）逻辑分析：
/proc/[pid]/fd/是内核实时视图，每个socket:[inode]条目代表一个未释放的网络资源；2>/dev/null忽略权限错误；wc -l统计数量。若数值稳定高于连接池上限，即存在泄漏。
交叉验证流程
graph TD
A[压测中发现 fd 持续增长] --> B[/proc/[pid]/fd/ 统计 socket 数]
B --> C{是否 > 预期最大连接数？}
C -->|是| D[pstack 12345 | grep -A5 'net.conn']
C -->|否| E[检查连接复用逻辑]
D --> F[定位未执行 Close 的 Goroutine]典型泄漏模式
- 忘记
defer conn.Close() if err != nil { return }提前返回，跳过Closeconn.Close()被包裹在未触发的条件分支中
| 现象 | 对应证据 |
|---|---|
fd/ 中大量 socket:[1234567] |
ls -l /proc/[pid]/fd/ \| head -n5 |
Goroutine 卡在 read 或 write |
pstack [pid] \| grep -A2 'net.*read' |
第五章：golang常驻内存吗
Go 程序是否“常驻内存”，取决于其运行模式与生命周期管理方式，而非语言本身的固有属性。与 Java 的 JVM 或 Python 的解释器不同，Go 编译生成的是静态链接的原生可执行文件，启动后即独占进程空间，不存在传统意义上的“类加载器”或“运行时热重载”机制。这意味着：一旦 main 函数退出，整个进程立即终止，所有堆/栈内存由操作系统回收——Go 本身不提供长期驻留的内存容器抽象。
进程级驻留 vs 应用级常驻
在 Linux 系统中，一个 Go 编写的 HTTP 服务（如 net/http 启动的服务器）会长期运行，表现为 ps aux | grep myserver 持续可见。但这本质是进程未退出，而非语言强制驻留。如下代码片段启动后将持续监听：
package main
import "net/http"
func main() {
http.ListenAndServe(":8080", nil) // 阻塞式调用，进程保持运行
}若该服务被 kill -9 终止，所有 goroutine、heap 对象、全局变量瞬间释放，无 finalizer 回调延迟（runtime.SetFinalizer 仅在 GC 时触发，且不可靠）。
内存泄漏的真实场景
真实项目中，“看似常驻”常源于未释放资源导致的内存持续增长。例如以下典型泄漏模式：
| 场景 | 原因 | 检测方式 |
|---|---|---|
| 全局 map 无清理 | var cache = make(map[string]*User) 持续写入不删除 |
pprof heap profile 显示 mapbucket 占比飙升 |
| Goroutine 泄漏 | go func(){ for { doWork() } }() 忘记退出条件 |
runtime.NumGoroutine() 持续上升，/debug/pprof/goroutine?debug=2 查看栈 |
实战诊断：用 pprof 定位驻留对象
部署一个带 /debug/pprof 的服务后，执行：
curl -s "http://localhost:6060/debug/pprof/heap?debug=1" > heap1.txt
# 运行 10 分钟压力测试
curl -s "http://localhost:6060/debug/pprof/heap?debug=1" > heap2.txt
# 对比两份 profile，识别新增分配对象使用 go tool pprof 可交互分析：
graph LR
A[启动服务] --> B[注入 pprof 路由]
B --> C[采集 heap profile]
C --> D[对比 diff]
D --> E[定位 leaky struct]
E --> F[检查 GC root 引用链]静态编译与内存布局事实
Go 默认静态链接（-ldflags '-extldflags "-static"'），二进制包含所有依赖代码段与只读数据段。.text 段常驻物理内存（mmap 映射），但 .data 和 .bss 中的全局变量仅在进程存活期间有效。unsafe.Sizeof 无法反映实际内存占用，而 runtime.ReadMemStats 才是真相：
var m runtime.MemStats
runtime.ReadMemStats(&m)
fmt.Printf("Alloc = %v MiB", bToMb(m.Alloc))即使空闲 goroutine 处于 Gwaiting 状态，其栈内存（默认 2KB）仍被保留，直到被调度器回收——这并非“常驻”，而是调度策略的瞬时表现。
系统级 OOM Killer 触发时，内核依据 cgroup.memory.limit_in_bytes 直接 kill 进程，Go 运行时无干预能力。
Kubernetes 中 livenessProbe 失败导致的重启，本质上就是对“非常驻”的主动纠正。
sync.Pool 的对象复用仅作用于当前 GC 周期，Put 后对象可能被下一轮 GC 清理。
runtime.GC() 手动触发无法保证立即释放内存，仅向调度器提交请求。
mmap 分配的大块内存（如 make([]byte, 1<<30)）在 free 后可能返回给内核，也可能被运行时缓存复用。
