Go语言中栈扩容和栈缩容的使用

package main

func recursiveFunction(depth int) {
    var buffer [1024]byte // 局部变量占用栈空间
    _ = buffer
    
    if depth > 0 {
        recursiveFunction(depth - 1) // 深度递归可能触发栈扩容
    }
}

func main() {
    recursiveFunction(1000) // 可能触发多次栈扩容
}

// 伪代码表示栈检查
func stackCheck() {
    // SP 是栈指针
    if SP < stackguard0 {
        // 栈空间不足，需要扩容
        morestack()
    }
}

// runtime/stack.go 中的扩容逻辑
func growstack(gp *g) {
    oldsize := gp.stack.hi - gp.stack.lo
    newsize := oldsize * 2 // 通常翻倍增长
    
    // 分配新栈
    newstack := stackalloc(newsize)
    
    // 复制旧栈内容
    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 // 占用大量栈空间
    // ... 使用 bigArray
} // bigArray 离开作用域，栈空间可回收

func main() {
    largeStackUsage()
    // 此时栈空间利用率低，可能触发缩容
}

// 缩容决策逻辑
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      // 系统保留
)

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

# 设置初始栈大小
export GOGC=100

# 调试栈信息
GODEBUG=gctrace=1,schedtrace=1000 ./program

# 禁用栈缩容（测试用）
GODEBUG=shrinkstackoff=1 ./program

// 传统分段栈（Go早期版本）的问题
type segmentedStack struct {
    segments []stackSegment // 栈片段链表
    // 问题：片段间调用开销大，容易导致"热分裂"
}

// Go现代连续栈的优势
type continuousStack struct {
    base uintptr    // 栈基地址
    size uintptr    // 栈大小
    // 优势：访问速度快，缓存友好
}

func copyStack(oldStack, newStack []byte) {
    // 挑战1：指针调整
    // 栈中的指针需要更新到新位置
    
    // 挑战2：活跃帧识别
    // 只复制活跃的栈帧，跳过已返回的函数
    
    // 挑战3：并发安全
    // 在goroutine暂停时进行拷贝
}

// 不好的写法：可能导致频繁栈扩容
func processLargeData(data []byte) {
    for i := 0; i < len(data); i += 1024 {
        chunk := data[i:min(i+1024, len(data))]
        processChunk(chunk) // 每次调用都使用栈空间
    }
}

// 更好的写法：重用栈空间
func processLargeDataOptimized(data []byte) {
    var chunkBuffer [1024]byte // 栈上固定缓冲区
    for i := 0; i < len(data); i += 1024 {
        size := min(1024, len(data)-i)
        copy(chunkBuffer[:], data[i:i+size])
        processChunk(chunkBuffer[:size]) // 重用栈空间
    }
}

// 对于特殊场景，可以调整默认栈大小
import "runtime/debug"

func setStackSize() {
    // 设置最大栈大小（谨慎使用）
    debug.SetMaxStack(64 * 1024 * 1024) // 64MB
    
    // 获取当前goroutine的栈信息
    buf := make([]byte, 1024)
    n := runtime.Stack(buf, false)
    fmt.Printf("Stack: %s\n", buf[:n])
}

package main

import (
    "runtime"
    "fmt"
)

func printStackInfo() {
    // 获取当前goroutine的栈信息
    var buf [64]byte
    n := runtime.Stack(buf[:], false)
    fmt.Printf("Stack trace:\n%s\n", buf[:n])
    
    // 查看内存统计
    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

# 查看栈内存使用
go tool pprof -sample_index=inuse_space mem.pprof

package main

import "runtime"

func deepRecursion(depth int) {
    if depth <= 0 {
        return
    }
    
    // 检查栈空间，避免无限递归导致的栈溢出
    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调用使用不同的栈管理
    // Go->C调用会切换到系统栈
    result := C.some_c_function()
    _ = result
}