Skip to Content
Go棧和堆

堆與棧詳解：理解 Go 泛型中的內存分配

📚 基礎概念

棧 (Stack)

特點：

  • 生命周期：與函數調用綁定，函數返回時自動釋放
  • 分配速度：極快（只需移動棧指針）
  • 大小限制：通常較小（幾MB到幾GB，取決於系統）
  • 存取速度：極快（CPU 緩存友好）
  • 管理方式：自動管理，無需手動釋放

適用場景：

  • 局部變數
  • 函數參數
  • 返回值（值類型）

堆 (Heap)

特點：

  • 生命周期：獨立於函數調用，需要垃圾回收器管理
  • 分配速度：較慢（需要查找可用內存塊）
  • 大小限制：理論上只受系統內存限制
  • 存取速度：較慢（可能觸發緩存未命中）
  • 管理方式：由 Go 的 GC 自動管理

適用場景：

  • 需要跨函數使用的資料
  • 大小未知或很大的資料
  • 返回指針指向的資料

🔍 Go 的逃逸分析 (Escape Analysis)

Go 編譯器在編譯時會進行逃逸分析，決定變數應該分配在棧還是堆上。

逃逸分析規則

情況分配位置原因
局部變數，函數返回後不再使用棧生命周期與函數綁定
返回指向局部變數的指針堆指針可能在函數外使用
變數大小超過棧限制堆棧空間不足
閉包捕獲的變數堆可能被延遲使用
接口類型賦值堆接口值可能包含指針

💡 程式碼示例對比

示例 1: 棧分配（返回值）

// stack/main.go
func Sum[T Numeric](args ...T) T {
    var defaultT T          // 棧上分配
    var sum *T = &defaultT  // 指針也在棧上
    for i := 0; i < len(args); i++ {
        *sum += args[i]
    }
    return *sum              // 返回值，defaultT 在棧上即可
}

逃逸分析結果：

$ go run -gcflags "-m" ./stack
# 關鍵信息：
# 04-getting-going/01-var-t/stack/main.go:17:6: moved to heap: defaultT
# ❌ 實際上這裡沒有顯示 "moved to heap"，說明 defaultT 在棧上

內存布局：

棧 (Stack)
┌─────────────────┐
│ defaultT (int)   │ ← 值在棧上
│ sum (*int)       │ ← 指針在棧上，指向 defaultT
└─────────────────┘

示例 2: 堆分配（返回指針）

// heap/main.go
func Sum[T Numeric](args ...T) *T {  // ⚠️ 返回指針
    var defaultT T
    var sum *T = &defaultT
    for i := 0; i < len(args); i++ {
        *sum += args[i]
    }
    return sum  // ⚠️ 返回指針，defaultT 必須逃逸到堆
}

逃逸分析結果：

$ go run -gcflags "-m" ./heap
# 關鍵信息：
# 04-getting-going/01-var-t/heap/main.go:17:6: moved to heap: defaultT
# ✅ 明確顯示 defaultT 被移動到堆

內存布局：

棧 (Stack)              堆 (Heap)
┌──────────┐           ┌──────────────┐
│ sum (*T) │ ────────→ │ defaultT    │ ← 值在堆上
└──────────┘           │ (int = 6)    │
                       └──────────────┘

🎯 關鍵理解點

1. 爲什麼返回指針會導致堆分配？

func Bad() *int {
    x := 42  // 局部變數在棧上
    return &x // ❌ 錯誤！返回棧上變數的地址
}
 
func Good() *int {
    x := new(int) // ✅ 在堆上分配
    *x = 42
    return x
}

原因：

  • 函數返回後，棧幀被銷毀
  • 如果返回棧上變數的指針，指針會指向無效內存
  • 因此，Go 編譯器會將 x 逃逸到堆，確保指針有效

2. 指針本身可以在棧上

func Example() {
    x := 42        // 值在棧上
    ptr := &x      // ✅ 指針本身在棧上，指向棧上的值
    fmt.Println(*ptr)
}

要點：

  • 指針變數本身可以分配在棧上
  • 只要指針指向的資料生命周期足夠長即可

3. 泛型中的表現

func Sum[T Numeric](args ...T) T {
    var sum T  // 泛型類型，行爲與普通類型相同
    // ...
    return sum  // 返回值，sum 在棧上
}
 
func SumPtr[T Numeric](args ...T) *T {
    var sum T
    // ...
    return &sum  // 返回指針，sum 逃逸到堆
}

泛型不影響逃逸分析：

  • 泛型類型在編譯時會被具體化
  • 逃逸分析規則與普通類型完全相同

📊 性能對比

特性棧分配堆分配
分配速度極快（~1ns）較慢（~100ns）
存取速度極快（CPU 緩存）較慢（可能緩存未命中）
GC 壓力無有（需要 GC 回收）
內存碎片無可能有
適用場景局部變數、小對象跨函數、大對象

實際性能影響

// 棧分配版本（快）
func Fast() int {
    var x int = 0
    for i := 0; i < 1000; i++ {
        x += i
    }
    return x  // 棧分配，無 GC 壓力
}
 
// 堆分配版本（慢）
func Slow() *int {
    x := new(int)
    for i := 0; i < 1000; i++ {
        *x += i
    }
    return x  // 堆分配，需要 GC
}

性能差異：

  • 棧分配：幾乎零開銷
  • 堆分配：需要 GC 管理，可能慢 10-100 倍

🔧 如何查看逃逸分析

方法 1: 編譯時查看

go build -gcflags "-m" your_file.go

方法 2: 執行時查看

go run -gcflags "-m" your_file.go

方法 3: 詳細逃逸信息

go build -gcflags "-m -m" your_file.go  # 更詳細的信息

輸出解讀

moved to heap: x        # x 逃逸到堆
does not escape         # 不逃逸，在棧上
escapes to heap         # 逃逸到堆

✅ 最佳實踐

1. 優先使用值返回

// ✅ 推薦：值返回，棧分配
func GetValue() int {
    var x int = 42
    return x
}
 
// ❌ 避免：指針返回，堆分配
func GetPointer() *int {
    x := 42
    return &x  // 逃逸到堆
}

2. 大對象考慮指針

// ✅ 大結構體使用指針
type LargeStruct struct {
    data [1000]int
}
 
func GetLarge() *LargeStruct {
    return &LargeStruct{}  // 大對象，堆分配合理
}

3. 接口類型注意逃逸

// ⚠️ 接口賦值可能導致逃逸
func GetInterface() interface{} {
    x := 42  // int 可能被裝箱，逃逸到堆
    return x
}

4. 泛型中的建議

// ✅ 泛型函數，值返回
func Process[T any](val T) T {
    // 處理邏輯
    return val  // 棧分配
}
 
// ⚠️ 需要返回指針時，明確使用 new
func ProcessPtr[T any](val T) *T {
    result := new(T)
    *result = val
    return result  // 堆分配，但明確
}

🎓 總結

核心要點

  1. 棧 vs 堆：

    • 棧：快速、自動管理、生命周期短
    • 堆：較慢、GC 管理、生命周期長

  2. 逃逸分析：

    • Go 編譯器自動決定分配位置
    • 返回指針通常導致堆分配
    • 泛型不影響逃逸分析規則

  3. 性能影響：

    • 棧分配幾乎零開銷
    • 堆分配需要 GC，有性能成本
    • 優先使用值返回，避免不必要的堆分配

  4. 實踐建議：

    • 小對象、局部變數：優先棧
    • 大對象、跨函數：使用堆
    • 使用 -gcflags "-m" 驗證逃逸分析

在泛型中的表現

// 泛型類型遵循相同的逃逸分析規則
func GenericExample[T any](val T) T {
    var result T  // 棧分配
    result = val
    return result  // 值返回，不逃逸
}
 
func GenericExamplePtr[T any](val T) *T {
    result := new(T)  // 堆分配
    *result = val
    return result  // 指針返回
}

關鍵：泛型只是類型佔位符，編譯後會變成具體類型，逃逸分析行爲完全相同。

最後更新於
玩轉泛型理解new