Comment gérer efficacement les requêtes HTTP simultanées dans Go ?

Comment maximiser les requêtes HTTP simultanées dans Go

Dans Go, maximiser les requêtes HTTP simultanées implique de répondre aux limites des descripteurs de fichiers. L'erreur courante résultant du dépassement de ces limites est :

net/http: Request.Body is closed

Approche concurrente améliorée

Voici une implémentation simultanée plus efficace utilisant des pools de travailleurs et un canal sémaphore :

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()
}

Cette approche utilise un pool de tâches pour envoyer des requêtes simultanément dans un sémaphore limité, en conservant le nombre de requêtes simultanées dans le système. limites. La gestion des réponses est également améliorée, y compris l'impression du statut et la fermeture du corps. Cette technique est plus précise et évolutive par rapport à la mise en œuvre originale.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!