переписать функцию рутин и восстановить

Question

Я хочу написать функцию для восстановления боли в рутине, приведенная ниже демонстрационная программа имеет функцию восстановления боли для рутины для «test1», но не поддерживает «test2», «test3», «test4». Как я могу просто написать функцию для восстановления любой боли от горутин.

func main() {
    go myGoroutine(test1)
    time.Sleep(10 * time.Second)
}

func myGoroutine(realGoFunc func()) {
    defer func() {
        if err := recover(); err != nil {
            fmt.Println(err)
        }
    }

    realGoFunc()
}

func test1() {
    fmt.Println("test1 come here)
    painc("test1 error")
    fmt.Println("test1 end")
}

func test2(username string) {
    fmt.Println("test2 come here)
    painc("test2 error")
    fmt.Println("test2 end")
}

func test3(userId int64, username string) {
    fmt.Println("test3 come here)
    painc("test3 error")
    fmt.Println("test3 end")
}

func test4(user *User) {
    fmt.Println("test4 come here)
    painc("test4 error")
    fmt.Println("test4 end")
}

Answer 1

Я исправляю это анонимной функцией.

func main() {
    // add go func() {}
    go func() {
      myGoroutine(test1)
    }
    // add go func() {}
    go func() {
      myGoroutine(test1)
    }
    time.Sleep(10 * time.Second)
}

func myGoroutine(realGoFunc func()) {
    defer func() {
        if err := recover(); err != nil {
            fmt.Println(err)
        }
    }

    realGoFunc()
}

Answer 2

В вашем случае возможный (но не приятный) выбор использует контекст:

type User struct {
    name string
    uid  int64
}


func main() {

    user := &User{
        name: "hezhixiong",
        uid:  int64(58741634),
    }

    ctx := context.WithValue(context.Background(), "name", user.name)
    ctx = context.WithValue(ctx, "uid", user.uid)
    ctx = context.WithValue(ctx, "user", user)

    go SafeFunc(test1, ctx)
    go SafeFunc(test2, ctx)
    go SafeFunc(test3, ctx)
    go SafeFunc(test4, ctx)

    for {
    }
}

func test1(ctx context.Context) {
    panic("test1")
}

func test2(ctx context.Context) {
    name := ctx.Value("name").(string)
    panic(name)
}

func test3(ctx context.Context) {
    name := ctx.Value("name").(string)
    uid := ctx.Value("uid").(int64)
    panic(fmt.Sprintln(name, uid))
}

func test4(ctx context.Context) {
    user := ctx.Value("user").(*User)
    panic(user)
}

// SafeFunc safe function call
func SafeFunc(f func(context.Context), ctx context.Context) {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println(r)
        }
    }()
    f(ctx)
}

В нашем производстве мы обычно деформируем вход и выход следующим образом:

func test(in *input) (out *output) {
    // parse in
    // ... do something
    // build out
}