如何使用 Goroutine 和工作池最大化 Go 中的并发 HTTP 请求？

如何在 Go 中最大化并发 HTTP 请求

许多编程语言和框架都提供了用于发出 HTTP 请求的工具，但是如果您需要发送当同时处理大量请求时，了解如何最大化并发性以优化性能至关重要。本文将深入研究 Go 中“最大化”并发 HTTP 请求的复杂性，利用 Goroutine 充分发挥系统处理能力的潜力。

问题：

让我们考虑一个场景，我们希望使用多个 goroutine 尽快生成对特定 URL 的一百万个 HTTP 请求。但是，由于超出了文件描述符限制，最初的帖子中提供的代码导致了错误。这是尝试处理大量并发请求时的常见问题。

解决方案：

为了有效地最大化并发性，我们可以通过以下方式解决文件描述符限制：使用缓冲通道作为工作池模型中的信号量机制。下面是解决方案的细分：

• 工作池：

  • 创建一个工作池来管理处理 HTTP 请求的 goroutine 数量.
  • 每个工作例程一次处理一个请求，并在准备好时发出信号

• 信号量通道：

  • 使用容量有限的缓冲通道来控制同时 HTTP 的数量请求。
  • 当工作例程完成请求时，它会向信号量通道发出信号，从而允许另一个要处理的请求。

• 调度程序：

  • 调度程序不断生成 HTTP 请求并将其发送给工作人员通过请求通道池。
  • 当工作人员可用时，调度程序从通道中提取请求并分配

• 消费者：

  • 一个单独的 goroutine 监视响应通道并增加每个通道的连接计数有效的回应。它还计算平均响应时间。

优化代码：

package main

import (
    "flag"
    "fmt"
    "log"
    "net/http"
    "runtime"
    "time"
)

var (
    reqs int
    max  int
)

func init() {
    flag.IntVar(&reqs, "reqs", 1000000, "Total requests")
    flag.IntVar(&max, "concurrent", 200, "Maximum concurrent requests")
}

type Response struct {
    *http.Response
    err error
}

// Dispatcher
func dispatcher(reqChan chan *http.Request) {
    defer close(reqChan)
    for i := 0; i < reqs; i++ {
        req, err := http.NewRequest("GET", "http://localhost/", nil)
        if err != nil {
            log.Println(err)
        }
        reqChan <- req
    }
}

// Worker Pool
func workerPool(reqChan chan *http.Request, respChan chan Response) {
    t := &amp;http.Transport{}
    for i := 0; i < max; i++ {
        go worker(t, reqChan, respChan)
    }
}

// Worker
func worker(t *http.Transport, reqChan chan *http.Request, respChan chan Response) {
    for req := range reqChan {
        resp, err := t.RoundTrip(req)
        r := Response{resp, err}
        respChan <- r
    }
}

// Consumer
func consumer(respChan chan Response) (int64, int64) {
    var (
        conns int64
        size  int64
    )
    for conns < int64(reqs) {
        select {
        case r, ok := <-respChan:
            if ok {
                if r.err != nil {
                    log.Println(r.err)
                } else {
                    size += r.ContentLength
                    if err := r.Body.Close(); err != nil {
                        log.Println(r.err)
                    }
                }
                conns++
            }
        }
    }
    return conns, size
}

func main() {
    flag.Parse()
    runtime.GOMAXPROCS(runtime.NumCPU())
    reqChan := make(chan *http.Request)
    respChan := make(chan Response)
    start := time.Now()
    go dispatcher(reqChan)
    go workerPool(reqChan, respChan)
    conns, size := consumer(respChan)
    took := time.Since(start)
    ns := took.Nanoseconds()
    av := ns / conns
    average, err := time.ParseDuration(fmt.Sprintf("%d", av) + "ns")
    if err != nil {
        log.Println(err)
    }
    fmt.Printf("Connections:\t%d\nConcurrent:\t%d\nTotal size:\t%d bytes\nTotal time:\t%s\nAverage time:\t%s\n", conns, max, size, took, average)
}

此改进的代码结合了前面讨论的元素创建一个基于工作池的高效系统，用于同时发送大量 HTTP 请求。通过仔细控制信号量通道的并发请求数量，我们可以避免与文件描述符限制相关的任何问题，并最大限度地利用系统资源。

总之，通过利用 goroutine、信号量通道、工作池和专用消费者来处理响应，我们可以有效地“最大化”Go 中的并发 HTTP 请求。这种方法使我们能够有效地进行性能测试和压力测试，将我们的系统推向极限并获得对其功能的宝贵见解。

以上是如何使用 Goroutine 和工作池最大化 Go 中的并发 HTTP 请求？的详细内容。更多信息请关注PHP中文网其他相关文章！