如何使用 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中文網其他相關文章！