package main

func recursiveFunction(depth int) {
    var buffer [1024]byte // 局部變量占用?？臻g
    _ = buffer
    
    if depth > 0 {
        recursiveFunction(depth - 1) // 深度遞歸可能觸發(fā)棧擴(kuò)容
    }
}

func main() {
    recursiveFunction(1000) // 可能觸發(fā)多次棧擴(kuò)容
}

// 偽代碼表示棧檢查
func stackCheck() {
    // SP 是棧指針
    if SP < stackguard0 {
        // ?？臻g不足，需要擴(kuò)容
        morestack()
    }
}

// runtime/stack.go 中的擴(kuò)容邏輯
func growstack(gp *g) {
    oldsize := gp.stack.hi - gp.stack.lo
    newsize := oldsize * 2 // 通常翻倍增長
    
    // 分配新棧
    newstack := stackalloc(newsize)
    
    // 復(fù)制舊棧內(nèi)容
    copied := uintptr(0)
    if gp.stack.lo != 0 {
        copied = gp.stack.hi - uintptr(unsafe.Pointer(&gp))
        memmove(newstack, gp.stack.lo, copied)
    }
    
    // 更新棧信息
    gp.stack.lo = newstack
    gp.stack.hi = newstack + newsize
    gp.stackguard0 = gp.stack.lo + stackGuard
}

package main

func largeStackUsage() {
    var bigArray [10000]int // 占用大量?？臻g
    // ... 使用 bigArray
} // bigArray 離開作用域，?？臻g可回收

func main() {
    largeStackUsage()
    // 此時?？臻g利用率低，可能觸發(fā)縮容
}

// 縮容決策邏輯
func shouldShrink(stackSize, usedSize uintptr) bool {
    utilization := float64(usedSize) / float64(stackSize)
    return utilization < 0.25 // 利用率低于25%考慮縮容
}

// runtime/stack.go 中的常量
const (
    _StackMin = 2048      // 最小棧大小 2KB
    _StackBig = 4096      // 大棧閾值
    _StackSystem = 0      // 系統(tǒng)保留
)

// 棧增長因子
func stackGrowthFactor(currentSize uintptr) uintptr {
    if currentSize < 4096 {
        return currentSize * 2 // 小棧翻倍增長
    }
    return currentSize + currentSize/4 // 大棧增長25%
}

# 設(shè)置初始棧大小
export GOGC=100

# 調(diào)試棧信息
GODEBUG=gctrace=1,schedtrace=1000 ./program

# 禁用?？s容（測試用）
GODEBUG=shrinkstackoff=1 ./program

// 傳統(tǒng)分段棧（Go早期版本）的問題
type segmentedStack struct {
    segments []stackSegment // 棧片段鏈表
    // 問題：片段間調(diào)用開銷大，容易導(dǎo)致"熱分裂"
}

// Go現(xiàn)代連續(xù)棧的優(yōu)勢
type continuousStack struct {
    base uintptr    // ?；刂?
    size uintptr    // 棧大小
    // 優(yōu)勢：訪問速度快，緩存友好
}

func copyStack(oldStack, newStack []byte) {
    // 挑戰(zhàn)1：指針調(diào)整
    // 棧中的指針需要更新到新位置
    
    // 挑戰(zhàn)2：活躍幀識別
    // 只復(fù)制活躍的棧幀，跳過已返回的函數(shù)
    
    // 挑戰(zhàn)3：并發(fā)安全
    // 在goroutine暫停時進(jìn)行拷貝
}

// 不好的寫法：可能導(dǎo)致頻繁棧擴(kuò)容
func processLargeData(data []byte) {
    for i := 0; i < len(data); i += 1024 {
        chunk := data[i:min(i+1024, len(data))]
        processChunk(chunk) // 每次調(diào)用都使用?？臻g
    }
}

// 更好的寫法：重用?？臻g
func processLargeDataOptimized(data []byte) {
    var chunkBuffer [1024]byte // 棧上固定緩沖區(qū)
    for i := 0; i < len(data); i += 1024 {
        size := min(1024, len(data)-i)
        copy(chunkBuffer[:], data[i:i+size])
        processChunk(chunkBuffer[:size]) // 重用?？臻g
    }
}

// 對于特殊場景，可以調(diào)整默認(rèn)棧大小
import "runtime/debug"

func setStackSize() {
    // 設(shè)置最大棧大小（謹(jǐn)慎使用）
    debug.SetMaxStack(64 * 1024 * 1024) // 64MB
    
    // 獲取當(dāng)前goroutine的棧信息
    buf := make([]byte, 1024)
    n := runtime.Stack(buf, false)
    fmt.Printf("Stack: %s\n", buf[:n])
}

package main

import (
    "runtime"
    "fmt"
)

func printStackInfo() {
    // 獲取當(dāng)前goroutine的棧信息
    var buf [64]byte
    n := runtime.Stack(buf[:], false)
    fmt.Printf("Stack trace:\n%s\n", buf[:n])
    
    // 查看內(nèi)存統(tǒng)計
    var memStats runtime.MemStats
    runtime.ReadMemStats(&memStats)
    fmt.Printf("Stack in use: %d bytes\n", memStats.StackInuse)
}

func main() {
    printStackInfo()
}

# 生成堆棧 profile
go test -bench . -benchmem -memprofile=mem.pprof
go tool pprof -alloc_space mem.pprof

# 查看棧內(nèi)存使用
go tool pprof -sample_index=inuse_space mem.pprof

package main

import "runtime"

func deepRecursion(depth int) {
    if depth <= 0 {
        return
    }
    
    // 檢查?？臻g，避免無限遞歸導(dǎo)致的棧溢出
    if depth%100 == 0 {
        var buf [64]byte
        n := runtime.Stack(buf[:], false)
        // 可以在這里添加棧深度檢查邏輯
    }
    
    deepRecursion(depth - 1)
}

package main

/*
#include <some_c_library.h>
*/
import "C"

func callCFunction() {
    // CGO調(diào)用使用不同的棧管理
    // Go->C調(diào)用會切換到系統(tǒng)棧
    result := C.some_c_function()
    _ = result
}