Go语言中优雅处理channel与共享内存引发的data race问题

原代码存在两个核心问题：

• 数据竞态：f.err被Start和Wait并发读写，无同步机制；
• 通道永久阻塞：若ctx.Done()先触发，f.ch <- struct{}{}会因无接收者陷入永久阻塞。

你的解法存在的遗漏 #

你提供的StartWithContext方案并未彻底解决问题：

1. 数据竞态仍存在：Wait和StartWithContext依然直接读写f.err，无任何同步保护，竞态问题未消除；
2. ctx检查时机滞后：仅在f()执行完成后检查ctx.Done()，若f()执行过程中ctx已取消，Wait已修改f.err，后续仍可能出现并发读写冲突；
3. 通道阻塞风险未完全规避：若StartWithContext中刚通过default分支进入写入逻辑，Wait就触发ctx.Done()返回，无缓冲的f.ch发送操作仍会永久阻塞。

更优解决方案 #

方案1：用互斥锁保护共享状态 + 非阻塞通道发送 #

通过互斥锁解决共享变量的竞态问题，同时用select+default避免通道发送阻塞：

import "sync"

type Future struct {
    f    func() (interface{}, error)
    resp interface{}
    err  error
    ch   chan struct{}
    mu   sync.Mutex
}

func (f *Future) Start() {
    go func() {
        resp, err := f.f()

        f.mu.Lock()
        defer f.mu.Unlock()

        // 仅在未被取消时更新结果
        if f.err == nil {
            f.resp = resp
            f.err = err
        }

        // 非阻塞发送，避免无接收者时阻塞
        select {
        case f.ch <- struct{}{}:
        default:
        }
    }()
}

func (f *Future) Wait(ctx context.Context) error {
    select {
    case <-f.ch:
        f.mu.Lock()
        defer f.mu.Unlock()
        return f.err
    case <-ctx.Done():
        f.mu.Lock()
        defer f.mu.Unlock()
        // 仅在未设置错误时写入取消错误
        if f.err == nil {
            f.err = ctx.Err()
        }
        return f.err
    }
}

方案2：完全基于CSP模型，避免共享内存 #

这是更符合Go并发设计哲学的方案，用通道传递所有结果，彻底消除共享内存带来的竞态：

type Future struct {
    f       func() (interface{}, error)
    resChan chan result
}

type result struct {
    resp interface{}
    err  error
}

func NewFuture(f func() (interface{}, error)) *Future {
    return &Future{
        f:       f,
        resChan: make(chan result, 1), // 带缓冲通道，确保发送不会阻塞
    }
}

func (f *Future) Start() {
    go func() {
        resp, err := f.f()
        f.resChan <- result{resp: resp, err: err}
    }()
}

func (f *Future) Wait(ctx context.Context) (interface{}, error) {
    select {
    case res := <-f.resChan:
        return res.resp, res.err
    case <-ctx.Done():
        return nil, ctx.Err()
    }
}

该方案的优势：

• 完全规避共享内存，自然消除数据竞态；
• 带缓冲的结果通道确保goroutine发送操作不会阻塞；
• 逻辑简洁清晰，符合Go的CSP并发模型，易维护。

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