Golang中net/http包的h2_bundle.go导致应用挂起问题

从你的描述来看，这是一个典型的HTTP/2流控制或并发写入问题。h2_bundle.go中的writeHeaders和writeDataFromHandler函数挂起通常是因为流控制窗口耗尽或并发写入冲突。

诊断工具和方法

1. 启用HTTP/2调试日志

import (
    "net/http"
    "net/http/httptrace"
    "log"
    "os"
)

func main() {
    // 启用HTTP/2调试日志
    os.Setenv("GODEBUG", "http2debug=2")
    
    // 或者使用httptrace进行更细粒度的跟踪
    trace := &httptrace.ClientTrace{
        GetConn: func(hostPort string) {
            log.Printf("GetConn: %s", hostPort)
        },
        GotConn: func(connInfo httptrace.GotConnInfo) {
            log.Printf("GotConn: %+v", connInfo)
        },
        WroteHeaders: func() {
            log.Printf("WroteHeaders")
        },
        WroteRequest: func(info httptrace.WroteRequestInfo) {
            log.Printf("WroteRequest: %+v", info)
        },
    }
    
    req, _ := http.NewRequest("GET", "https://example.com", nil)
    req = req.WithContext(httptrace.WithClientTrace(req.Context(), trace))
}

2. 使用pprof分析goroutine阻塞

import (
    "net/http"
    _ "net/http/pprof"
    "runtime/pprof"
    "os"
    "time"
)

func startDebugServer() {
    go func() {
        http.ListenAndServe("localhost:6060", nil)
    }()
}

func captureGoroutineDump() {
    f, _ := os.Create("goroutine.pprof")
    defer f.Close()
    pprof.Lookup("goroutine").WriteTo(f, 1)
}

// 在怀疑挂起的地方添加
func yourHandler(w http.ResponseWriter, r *http.Request) {
    // 定时捕获goroutine状态
    go func() {
        ticker := time.NewTicker(5 * time.Second)
        defer ticker.Stop()
        for range ticker.C {
            captureGoroutineDump()
        }
    }()
    
    // 你的处理逻辑
}

3. 检查流控制窗口状态

import (
    "golang.org/x/net/http2"
    "net/http"
    "log"
)

func monitorHTTP2Conn(server *http.Server) {
    server.ConnState = func(conn net.Conn, state http.ConnState) {
        if state == http.StateActive {
            if h2conn, ok := conn.(*http2.conn); ok {
                // 检查流控制窗口
                log.Printf("HTTP/2 connection initialized: %v", h2conn)
            }
        }
    }
}

4. 使用Delve进行深度调试

创建调试配置：

# 编译时保留调试信息
go build -gcflags="all=-N -l" -o myapp

# 使用Delve附加调试
dlv exec ./myapp

# 在Delve中设置断点
(dlv) break h2_bundle.go:1234  # writeHeaders函数
(dlv) break h2_bundle.go:5678  # writeDataFromHandler函数
(dlv) continue

# 当挂起时，检查goroutine状态
(dlv) goroutines
(dlv) goroutine <id> stack

5. 检查并发写入问题

import (
    "sync"
    "net/http"
    "io"
)

type safeResponseWriter struct {
    http.ResponseWriter
    mu sync.Mutex
}

func (w *safeResponseWriter) Write(p []byte) (int, error) {
    w.mu.Lock()
    defer w.mu.Unlock()
    return w.ResponseWriter.Write(p)
}

func (w *safeResponseWriter) WriteHeader(statusCode int) {
    w.mu.Lock()
    defer w.mu.Unlock()
    w.ResponseWriter.WriteHeader(statusCode)
}

// 在处理器中包装ResponseWriter
func yourHandler(w http.ResponseWriter, r *http.Request) {
    safeWriter := &safeResponseWriter{ResponseWriter: w}
    // 使用safeWriter进行写入操作
}

6. 使用net/http/httputil跟踪请求

import (
    "net/http/httputil"
    "log"
)

func logRequest(r *http.Request) {
    dump, err := httputil.DumpRequest(r, true)
    if err == nil {
        log.Printf("Request:\n%s", dump)
    }
}

func logResponse(resp *http.Response) {
    dump, err := httputil.DumpResponse(resp, true)
    if err == nil {
        log.Printf("Response:\n%s", dump)
    }
}

常见问题排查点

1. 检查是否在Handler中同时使用了WriteHeader和Write：

// 错误示例 - 可能导致挂起
w.WriteHeader(200)
io.Copy(w, largeFile)  // 如果largeFile很大，可能耗尽流控制窗口

// 正确做法
io.Copy(w, largeFile)  // Write会自动发送200状态码

1. 检查响应体大小和流控制窗口：

// 监控响应大小
func sizeTrackingHandler(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        tracked := &responseTracker{ResponseWriter: w}
        next.ServeHTTP(tracked, r)
        log.Printf("Response size: %d bytes", tracked.bytesWritten)
    })
}

type responseTracker struct {
    http.ResponseWriter
    bytesWritten int64
}

func (rt *responseTracker) Write(p []byte) (int, error) {
    n, err := rt.ResponseWriter.Write(p)
    rt.bytesWritten += int64(n)
    return n, err
}

这些工具和方法应该能帮助你定位h2_bundle.go中的挂起问题。重点关注goroutine堆栈、HTTP/2流控制窗口状态以及并发写入冲突。