Wie kann ich gleichzeitige HTTP-Anfragen in Go effizient verarbeiten?

So maximieren Sie gleichzeitige HTTP-Anfragen in Go

In Go erfordert die Maximierung gleichzeitiger HTTP-Anfragen die Bewältigung der Dateideskriptorgrenzen. Der häufigste Fehler, der sich aus der Überschreitung dieser Grenzwerte ergibt, ist:

net/http: Request.Body is closed

Verbesserter gleichzeitiger Ansatz

Hier ist eine effektivere gleichzeitige Implementierung mit Worker-Pools und einem Semaphorkanal:

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

// Default values
var (
    reqs        = 1000000
    maxWorkers  = 200
    sem         = make(chan bool, maxWorkers)
    respChan    = make(chan *http.Response)
    respErrChan = make(chan error)
)

func main() {
    runtime.GOMAXPROCS(runtime.NumCPU())

    // Dispatcher: sends requests to the worker pool
    go func() {
        for i := 0; i < reqs; i++ {
            sem <- true
            req, err := http.NewRequest(http.MethodGet, "http://localhost:8080", nil)
            if err != nil {
                respErrChan <- err
                return
            }
            client := &http.Client{Timeout: 15 * time.Second}
            resp, err := client.Do(req)
            if err != nil {
                respErrChan <- err
                return
            }
            respChan <- resp
        }
        close(sem)
        close(respChan)
    }()

    // Worker Pool: sends requests to the API
    var wg sync.WaitGroup
    for i := 0; i < maxWorkers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for {
                select {
                case resp := <-respChan:
                    fmt.Println(resp.Status)
                    resp.Body.Close()
                    sem <- true
                case err := <-respErrChan:
                    log.Fatal(err)
                }
            }
        }()
    }

    wg.Wait()
}

Dieser Ansatz verwendet einen Worker-Pool, um Anfragen gleichzeitig innerhalb eines begrenzten Semaphors zu senden. Halten Sie die Anzahl gleichzeitiger Anfragen innerhalb der Systemgrenzen. Die Antwortverarbeitung wurde ebenfalls verbessert, einschließlich Statusausdruck und Textabschluss. Diese Technik ist genauer und skalierbarer als die ursprüngliche Implementierung.

Das obige ist der detaillierte Inhalt vonWie kann ich gleichzeitige HTTP-Anfragen in Go effizient verarbeiten?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!