goroutine 中的请求时间

Question

我正在尝试计算发出并发请求所需的时间。我的计时结果比ab2 报告的慢四倍左右。

我尝试了两种不同的计时请求，这两种方法都导致相似的结果（与 ab2 的结果相差甚远）。举个例子，ab2 将在本地服务器上报告最长的请求持续 2 毫秒，而此代码将报告最多 4.5 毫秒。顺便说一句，整个代码库都可用here。

我如何正确地为 go 中的请求计时？

方法一：计时不仅仅包括请求

来自this commit。

// Let's spawn all the requests, with their respective concurrency.
wg.Add(r.Repeat)
r.doneWg.Add(r.Repeat)
for rno := 1; rno <= r.Repeat; rno++ {
    go func(no int, greq goreq.Request) {
        r.ongoingReqs <- struct{}{} // Adding sentinel value to limit concurrency.
        startTime := time.Now()
        greq.Uri = r.URL.Generate()
        gresp, err := greq.Do()
        if err != nil {
            log.Critical("could not send request to #%d %s: %s", no, r.URL, err)
        } else if no < r.Repeat {
            // We're always using the last response for the next batch of requests.
            gresp.Body.Close()
        }
        <-r.ongoingReqs // We're done, let's make room for the next request.
        resp := Response{Response: gresp, duration: time.Now().Sub(startTime)}
        // Let's add that request to the list of completed requests.
        r.doneChan <- &resp
        runtime.Gosched()
    }(rno, greq)
}

方法2：使用带有defer语句的内部函数

来自this commit。

// Let's spawn all the requests, with their respective concurrency.
wg.Add(r.Repeat)
r.doneWg.Add(r.Repeat)
for rno := 1; rno <= r.Repeat; rno++ {
    go func(no int, greq goreq.Request) {
        r.ongoingReqs <- struct{}{} // Adding sentinel value to limit concurrency.
        greq.Uri = r.URL.Generate()
        var duration time.Duration
        gresp, err := func(dur *time.Duration) (gresp *goreq.Response, err error) {
            defer func(startTime time.Time) { *dur = time.Now().Sub(startTime) }(time.Now())
            return greq.Do()
        }(&duration)

        if err != nil {
            log.Critical("could not send request to #%d %s: %s", no, r.URL, err)
        } else if no < r.Repeat {
            // We're always using the last response for the next batch of requests.
            gresp.Body.Close()
        }
        <-r.ongoingReqs // We're done, let's make room for the next request.
        resp := Response{Response: gresp, duration: duration}
        // Let's add that request to the list of completed requests.
        r.doneChan <- &resp
        runtime.Gosched()
    }(rno, greq)
}

我查看了this question，但没有帮助。

Answer 1

当您的 goroutine 进入系统调用（写入套接字）时，它们会被抢占。这意味着它们被中断，另一个 goroutine 将在它们的位置运行。最终，你被抢占的 goroutine 将再次被调度，它将继续从它停止的地方运行。不过，这并不一定会在系统调用完成之后发生。

在 goroutine 中计时很困难，因为即使您以串行方式完成所有操作，Go 1.5 的垃圾收集器也会偶尔运行，从而中断您理论上的串行循环。

唯一真正的解决方案有点复杂：

1. 直接使用RawSyscall。
2. 使用 //go:nosplit 注释您的函数，以防止它被抢占。
3. 禁用垃圾收集器。

即便如此，我也可能会忘记一些事情。