如何在Goroutine中添加Handler时避免数据竞争？

哈哈，这个场景我太熟悉了——当初我在做一个依赖外部配置中心的HTTP服务时，也踩过http.DefaultServeMux并发注册的坑！

首先得明确核心问题：http.DefaultServeMux的Handle/HandleFunc方法完全不是并发安全的。当你在后台goroutine里忙着注册路由的同时，主线程的HTTP服务已经在处理请求（或者你的测试用例在并发发起请求），此时对ServeMux内部路由映射表的读写操作就会触发数据竞争检测。

下面给你两个最实用的解决方案，按需选择：

方案一：封装一个并发安全的ServeMux #

这是最通用的做法，给标准库的http.ServeMux套一层读写锁，保证路由注册和请求处理的并发安全：

import (
    "net/http"
    "sync"
)

// SafeMux 是并发安全的HTTP路由多路复用器
type SafeMux struct {
    mu  sync.RWMutex
    mux *http.ServeMux
}

func NewSafeMux() *SafeMux {
    return &SafeMux{
        mux: http.NewServeMux(),
    }
}

// Handle 注册路由，加写锁保证并发安全
func (sm *SafeMux) Handle(pattern string, handler http.Handler) {
    sm.mu.Lock()
    defer sm.mu.Unlock()
    sm.mux.Handle(pattern, handler)
}

// HandleFunc 注册路由函数，加写锁保证并发安全
func (sm *SafeMux) HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request)) {
    sm.mu.Lock()
    defer sm.mu.Unlock()
    sm.mux.HandleFunc(pattern, handler)
}

// ServeHTTP 处理请求，加读锁保证并发安全
func (sm *SafeMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    sm.mu.RLock()
    defer sm.mu.RUnlock()
    sm.mux.ServeHTTP(w, r)
}

然后在main函数里用这个SafeMux代替默认的http.DefaultServeMux：

func main() {
    mux := NewSafeMux()

    // 先注册不需要依赖第三方服务的路由
    mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
        fmt.Fprint(w, "OK")
    })

    // 启动goroutine注册依赖第三方服务的路由
    go func() {
        // 模拟第三方服务初始化，包含重试逻辑
        for {
            err := initThirdPartyService()
            if err == nil {
                break
            }
            log.Printf("Failed to init third-party service, retrying in 5s: %v", err)
            time.Sleep(5 * time.Second)
        }

        // 注册依赖第三方服务的路由
        mux.HandleFunc("/dependent", func(w http.ResponseWriter, r *http.Request) {
            // 使用第三方服务的业务逻辑
            fmt.Fprint(w, "Dependent route is ready!")
        })
    }()

    // 启动HTTP服务
    log.Fatal(http.ListenAndServe(":8080", mux))
}

这个方案对现有代码侵入性极小，所有路由注册逻辑和之前几乎一致，只是换了个Mux实例而已。

方案二：用原子变量动态替换单个Handler #

如果只有少数几个路由需要动态注册，没必要封装整个Mux，可以给目标路由先注册一个「占位Handler」，然后用atomic.Value在后台更新实际的处理逻辑：

import (
    "fmt"
    "net/http"
    "sync/atomic"
)

// 定义存储Handler函数的原子变量
var dependentHandler atomic.Value

func main() {
    // 先注册占位Handler，返回服务未就绪状态
    http.HandleFunc("/dependent", func(w http.ResponseWriter, r *http.Request) {
        handler, ok := dependentHandler.Load().(func(http.ResponseWriter, *http.Request))
        if !ok {
            w.WriteHeader(http.StatusServiceUnavailable)
            fmt.Fprint(w, "Service not ready yet, please try later")
            return
        }
        // 调用实际的业务Handler
        handler(w, r)
    })

    // 注册不需要依赖的路由
    http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
        fmt.Fprint(w, "OK")
    })

    // 后台初始化第三方服务并更新Handler
    go func() {
        var err error
        // 最多重试3次
        for i := 0; i < 3; i++ {
            err = initThirdPartyService()
            if err == nil {
                break
            }
            log.Printf("Retry %d: failed to init service: %v", i+1, err)
            time.Sleep(3 * time.Second)
        }

        if err != nil {
            log.Fatalf("Failed to init third-party service after retries: %v", err)
        }

        // 初始化实际的业务Handler逻辑
        actualHandler := func(w http.ResponseWriter, r *http.Request) {
            // 这里写依赖第三方服务的业务代码
            fmt.Fprint(w, "Dependent service is ready, handling request!")
        }

        // 原子更新Handler，保证并发安全
        dependentHandler.Store(actualHandler)
    }()

    log.Fatal(http.ListenAndServe(":8080", nil))
}

这个方案更轻量，不需要修改全局Mux，只针对需要动态注册的路由做处理，适合场景简单的情况。

测试时的额外注意 #

测试时如果还遇到数据竞争，除了用上面的方案修复代码，还可以在测试中等待动态路由注册完成后再发起请求，比如用sync.WaitGroup：

func TestDependentRoute(t *testing.T) {
    var wg sync.WaitGroup
    wg.Add(1)

    // 替换初始化函数，完成后通知测试
    originalInit := initThirdPartyService
    initThirdPartyService = func() error {
        defer wg.Done()
        return originalInit()
    }

    // 启动测试用服务
    server := httptest.NewServer(http.DefaultServeMux)
    defer server.Close()

    // 等待第三方服务初始化完成
    wg.Wait()

    // 发起请求验证
    resp, err := http.Get(server.URL + "/dependent")
    if err != nil {
        t.Fatal(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if string(body) != "Dependent service is ready, handling request!" {
        t.Errorf("unexpected response body: %s", body)
    }
}

这样可以避免测试在路由未注册完成时发起请求，配合上面的并发安全方案，就能彻底解决数据竞争问题。

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