Golang的Panic包装实现以及引申的一点点思考

最近在清理之前收藏的文章, 其中有一段话是, "刚使用 Golang 的人很容易踩到的一个 goroutine 坑点是，一个 goroutine 如果 panic 了，在它的父 goroutine 是无法 recover 的——严格来讲，并没有父子 goroutine 的概念，一旦启动，就是一个独立的 goroutine 了"

这就很有意思了, 虽然现在有很多的开源实现, 但是我想自己写一个, 因为很明显的, 这里需要用到泛型. 而我之前没有实践过. 还是从最简单的部分开始.

func Go(fn func()) {
    go func() {
        defer func() {
            if v := recover(); v != nil {
                log.Printf("goroutine panic: %v\n", v)
            }
        }()
        fn()
    }()
}

func main() {
    Go(func() {
        panic("something went wrong")
    })

    Go(func() {
        fmt.Println("hello from goroutine")
    })

    time.Sleep(time.Second)
}

但是这里有一个问题是, goroutine没有参数啊. 假设这里我需要传递一个in, 一个out 两个channel, 为了达到这个目的, 我想到了三种办法

package main

import (
    "fmt"
    "log"
    "time"
)

func Go(fn func()) {
    go func() {
        defer func() {
            if v := recover(); v != nil {
                log.Printf("goroutine panic: %v\n", v)
            }
        }()
        fn()
    }()
}

// --- 方法 1：工厂函数，先绑 in/out，再返回 func() ---

func pipeWorker(in <-chan int, out chan<- int) func() {
    return func() {
        for v := range in {
            out <- v * 2
        }
        close(out)
    }
}

func example1() {
    in := make(chan int, 3)
    out := make(chan int, 3)
    in <- 1
    in <- 2
    in <- 3
    close(in)

    Go(pipeWorker(in, out))

    for v := range out {
        fmt.Println("method 1:", v)
    }
}

// --- 方法 2：结构体打包，参数与业务逻辑一并放入结构体 ---

type PipeWorker struct {
    In  <-chan string
    Out chan<- string
    Fn  func(string) string
}

func (w PipeWorker) Run() {
    for v := range w.In {
        w.Out <- w.Fn(v)
    }
    close(w.Out)
}

func example2() {
    in := make(chan string, 3)
    out := make(chan string, 3)
    in <- "go"
    in <- "rust"
    in <- "zig"
    close(in)

    w := PipeWorker{
        In:  in,
        Out: out,
        Fn: func(s string) string {
            return "[" + s + "]"
        },
    }
    Go(w.Run)

    for v := range out {
        fmt.Println("method 2:", v)
    }
}

// --- 方法 3：直接闭包，捕获外层的 in/out ---

func example3() {
    in := make(chan int, 3)
    out := make(chan int, 3)
    in <- 7
    in <- 8
    in <- 9
    close(in)

    Go(func() {
        for v := range in {
            out <- v + 1
        }
        close(out)
    })

    for v := range out {
        fmt.Println("method 3:", v)
    }
}

func main() {
    example1()
    example2()
    example3()

    time.Sleep(100 * time.Millisecond)
}

写到这里, 忽然发现并没有泛型什么事情, 等下一次好机会...

<完>