Go语言实现exec函数同步异步双模式，求代码合理性校验

你的代码可以正常运行，同步/异步分支的逻辑都能走通，但针对实际的网络/数据库调用场景，有不少可以优化的点，同时存在一些潜在问题：

现有写法的问题 #

• 没必要传递chan的指针：Go里chan是引用类型，直接传递chan本身即可，传递指针反而增加复杂度，还可能因误操作引发问题。
• 结果传递冗余：exec函数同时通过返回值和chan传递结果，异步场景下完全可以只通过chan传递，避免重复逻辑。
• 多goroutine场景的扩展性差：如果要启动多个exec goroutine，当前每个goroutine单独创建chan的写法会非常繁琐，且容易因未接收chan导致goroutine泄漏。

优化后的代码示例 #

基础优化版（单goroutine场景） #

package main

import "fmt"

type Test struct {
    a int
    b int
}

// 优化：直接传递chan，去掉指针，仅在异步场景用chan传递结果
func (t *Test) exec(responseChan chan<- bool, errChan chan<- error) {
    // 模拟网络/数据库调用
    response := false
    err := nil

    // 仅当chan不为空时发送结果，发送后关闭chan避免接收方阻塞
    if responseChan != nil {
        responseChan <- response
        close(responseChan)
    }
    if errChan != nil {
        errChan <- err
        close(errChan)
    }
}

func (t *Test) Compute(sync bool) {
    if !sync {
        responseChan := make(chan bool)
        errChan := make(chan error)

        go t.exec(responseChan, errChan)

        fmt.Println(<-responseChan)
        fmt.Println(<-errChan)
    } else {
        // 同步场景：用带缓冲的chan接收结果，避免阻塞
        responseChan := make(chan bool, 1)
        errChan := make(chan error, 1)
        t.exec(responseChan, errChan)
        fmt.Println(<-responseChan)
        fmt.Println(<-errChan)
    }
}

func main() {
    t := Test{10, 12}
    t.Compute(true)
    t.Compute(false)
}

多goroutine场景优化（使用errgroup管理） #

如果需要在Compute里启动多个exec goroutine，推荐使用golang.org/x/sync/errgroup来管理，更简洁且能统一处理错误：

package main

import (
    "fmt"
    "golang.org/x/sync/errgroup"
)

type Test struct {
    a int
    b int
}

func (t *Test) exec() (bool, error) {
    // 模拟网络/数据库调用
    return false, nil
}

func (t *Test) Compute(sync bool, goroutineNum int) {
    if !sync {
        var g errgroup.Group
        results := make([]bool, goroutineNum)

        for i := 0; i < goroutineNum; i++ {
            idx := i
            g.Go(func() error {
                res, err := t.exec()
                if err != nil {
                    return err
                }
                results[idx] = res
                return nil
            })
        }

        // 等待所有goroutine完成，捕获全局错误
        if err := g.Wait(); err != nil {
            fmt.Printf("exec error: %v\n", err)
            return
        }

        fmt.Println("all results:", results)
    } else {
        // 同步场景：依次调用并收集结果
        results := make([]bool, goroutineNum)
        for i := 0; i < goroutineNum; i++ {
            res, err := t.exec()
            if err != nil {
                fmt.Printf("exec error: %v\n", err)
                return
            }
            results[i] = res
        }
        fmt.Println("all results:", results)
    }
}

func main() {
    t := Test{10, 12}
    t.Compute(true, 3)
    t.Compute(false, 3)
}

关键注意事项 #

• goroutine泄漏：异步场景下，务必确保chan的发送和接收配对，或者使用带缓冲的chan、及时关闭chan，避免goroutine因阻塞泄漏。
• 并发安全：如果exec函数操作Test结构体的字段，需要用sync.Mutex保证并发安全，防止数据竞态。
• 错误处理：实际网络/数据库调用中，要优先处理错误，避免错误被忽略导致业务异常。

内容的提问来源于stack exchange，提问作者Shikhar Tyagi