编辑“︁Go 内存泄漏”︁（章节）

= Go内存泄漏 =

== 介绍 ==
'''内存泄漏'''是指程序在运行过程中未能释放不再使用的内存，导致可用内存逐渐减少，最终可能引发程序崩溃或系统性能下降。在Go语言中，虽然垃圾回收器（GC）会自动管理内存，但某些编程模式仍会导致内存泄漏。本章将详细讨论Go中的内存泄漏类型、检测方法及预防策略。

== 常见内存泄漏场景 ==

=== 1. 未关闭的资源 ===
未关闭的文件、网络连接或数据库连接会持续占用内存。例如：
<syntaxhighlight lang="go">
func readFile() {
    file, err := os.Open("largefile.txt")
    if err != nil {
        log.Fatal(err)
    }
    // 忘记调用 file.Close()
}
</syntaxhighlight>
'''修复方法：'''使用<code>defer</code>确保资源释放：
<syntaxhighlight lang="go">
defer file.Close()
</syntaxhighlight>

=== 2. 全局变量缓存 ===
全局变量（如<code>map</code>或切片）持续增长且未清理：
<syntaxhighlight lang="go">
var cache = make(map[string][]byte)

func processData(key string, data []byte) {
    cache[key] = data // 数据永久保留在cache中
}
</syntaxhighlight>
'''修复方法：'''实现缓存淘汰策略（如LRU）或定期清理。

=== 3. Goroutine泄漏 ===
未退出的Goroutine会保留其栈内存和引用对象：
<syntaxhighlight lang="go">
func leakyGoroutine() {
    ch := make(chan int)
    go func() {
        for val := range ch {
            fmt.Println(val)
        }
    }()
    // ch未被关闭，Goroutine永远阻塞
}
</syntaxhighlight>
'''修复方法：'''显式关闭通道或使用<code>context.Context</code>取消Goroutine。

=== 4. 子字符串/切片引用 ===
子字符串或切片可能意外引用整个原始数据：
<syntaxhighlight lang="go">
func leakySlice() {
    largeData := make([]byte, 1<<20) // 1MB
    smallPart := largeData[:10]      // 引用整个largeData
    _ = smallPart
}
</syntaxhighlight>
'''修复方法：'''使用<code>copy</code>创建独立副本：
<syntaxhighlight lang="go">
smallPart := make([]byte, 10)
copy(smallPart, largeData[:10])
</syntaxhighlight>

== 检测内存泄漏 ==

=== 使用pprof ===
Go内置<code>net/http/pprof</code>包可生成内存快照：
<syntaxhighlight lang="go">
import _ "net/http/pprof"

func main() {
    go func() {
        log.Println(http.ListenAndServe("localhost:6060", nil))
    }()
    // ...程序逻辑...
}
</syntaxhighlight>
访问<code>http://localhost:6060/debug/pprof/heap</code>分析内存使用。

=== 运行时统计 ===
通过<code>runtime.ReadMemStats</code>获取内存信息：
<syntaxhighlight lang="go">
var m runtime.MemStats
runtime.ReadMemStats(&m)
fmt.Printf("HeapAlloc = %v MiB\n", m.HeapAlloc/1024/1024)
</syntaxhighlight>

== 实际案例 ==

=== 案例：HTTP处理器泄漏 ===
以下HTTP服务器每次请求会泄漏一个Goroutine：
<syntaxhighlight lang="go">
func leakyHandler(w http.ResponseWriter, r *http.Request) {
    ch := make(chan struct{})
    go func() {
        time.Sleep(10 * time.Second) // 模拟耗时操作
        ch <- struct{}{}
    }()
    select {
    case <-ch:
        w.Write([]byte("Done"))
    case <-time.After(5 * time.Second):
        w.Write([]byte("Timeout"))
        // Goroutine仍在运行并引用ch
    }
}
</syntaxhighlight>
'''修复方案：'''使用带缓冲的通道或<code>context</code>：
<syntaxhighlight lang="go">
ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
defer cancel()
// 在Goroutine中检查ctx.Done()
</syntaxhighlight>

== 数学建模 ==
内存泄漏可建模为：
<math>
M(t) = M_0 + \int_{0}^{t} L(\tau) \, d\tau - \int_{0}^{t} R(\tau) \, d\tau
</math>
其中：
* <math>M(t)</math>：时间t的内存占用
* <math>L(\tau)</math>：泄漏速率
* <math>R(\tau)</math>：回收速率

== 可视化分析 ==
<mermaid>
graph LR
    A[内存分配] --> B{对象可达?}
    B -->|是| C[保留]
    B -->|否| D[垃圾回收]
    C --> E[潜在泄漏点]
</mermaid>

== 预防策略 ==
* 对所有资源使用<code>defer</code>释放
* 避免在全局变量中存储可变数据
* 为Goroutine设置退出条件
* 定期使用工具检查内存使用

== 总结 ==
Go内存泄漏虽不如无GC语言常见，但错误使用仍会导致问题。理解引用机制、合理设计生命周期，并利用工具检测，可有效避免泄漏。

[[Category:编程语言]]
[[Category:Go]]
[[Category:Go 内存管理]]