《Go小技巧易错点100例》第三十五篇

本期分享：

1.循环依赖导致栈溢出

2.无法捕获子协程的panic

---

循环依赖导致栈溢出

在Go语言开发中，我们经常会遇到结构体之间需要相互引用的情况。当两个结构体直接或间接地相互包含对方作为自己的字段时，就会形成循环依赖。

但是在Go语言中直接进行结构体的相互引用会默认不符合语法，因此我们就使用接口进行引用。

代码示例：

结构体A

type A struct {Name stringHi   Hi
}type Say interface {Say()
}func (a *A) Say() {fmt.Println(a.Name, " say Hi")
}func NewA(name string) *A {return &A{Name: name,Hi:   NewB("B"),}
}

结构体B

type B struct {Name stringSay  Say
}type Hi interface {Hi()
}func (b *B) Hi() {fmt.Println("Hi ", b.Name)
}func NewB(name string) *B {return &B{Name: name,Say:  NewA("A"),}
}

当调用NewA(“A”)时，程序会立即崩溃并报错：

runtime: goroutine stack exceeds 1000000000-byte limit
fatal error: stack overflow

错误原因分析：

• 无限递归初始化：NewA调用NewB，NewB又调用NewA，从而形成无限循环调用链。

• 栈空间耗尽：每次函数调用都会占用栈空间，无限递归导致栈空间被耗尽，最终触发栈溢出错误

解决方案

方案1：打破初始化循环

func NewA(name string) *A {b := &B{Name: "B"}  // 先创建B实例a := &A{Name: name,Hi:   b,  // 直接赋值}b.Say = a  // 后设置B的Say字段return a
}

方案2：使用接口+延迟设置

type A struct {Name stringHi   Hi  // 使用接口类型
}type B struct {Name stringSay  Say  // 使用接口类型
}// 初始化时先创建实例，后设置字段
a := &A{Name: "A"}
b := &B{Name: "B"}
a.Hi = b
b.Say = a

方案3：重新设计结构

考虑是否真的需要双向依赖，可以将共用逻辑提取到第三个结构体。

Go语言中的循环依赖问题看似简单，但可能导致严重的运行时错误。通过本文的分析和解决方案，我们可以更安全地处理对象间的复杂关系

无法捕获子协程的panic

在Go语言中，父协程默认情况下不能直接捕获子协程的panic。这是由Go的并发模型和goroutine的设计决定的：

func Run() {defer func() {if r := recover(); r != nil {log.Printf("ping panic: %v", r)  // 这个recover只能捕获当前goroutine的panic}}()go func() {panic("panic")}()time.Sleep(time.Second * 3)
}

原因如下：

• 独立的执行栈：每个goroutine都有自己的调用栈，panic和recover机制是基于当前goroutine的调用栈的

• 设计哲学：Go的设计是让每个goroutine自己处理自己的错误，而不是由父goroutine来管理

• 并发安全：如果允许跨goroutine捕获panic，会导致复杂的并发问题

正确写法：

func Run() {go func() {defer func() {if r := recover(); r != nil {log.Printf("ping panic: %v", r)}}()panic("panic")}()time.Sleep(time.Second * 3)
}

本篇结束~