Wie maximiere ich gleichzeitige HTTP-Anfragen in Go?

Wie kann man gleichzeitige HTTP-Anfragen effektiv „maximieren“?

Wenn Sie mit der Leistung von Go experimentieren, kann es beim Versuch, eine große Menge an HTTP-Anfragen gleichzeitig auszuführen, zu Einschränkungen kommen . Dieser Artikel untersucht die Herausforderungen, mit denen man konfrontiert ist, und bietet eine Lösung, um maximale Parallelität zu erreichen.

Das Problem

Ihr erster Ansatz besteht darin, eine große Anzahl von Goroutinen zu starten, um HTTP-Anfragen parallel zu senden, und zu erwarten, dass sie genutzt werden alle verfügbaren CPUs. Aufgrund von Dateideskriptorbeschränkungen treten jedoch Fehler auf.

Die Lösung

Um diese Einschränkungen zu überwinden, ziehen Sie die folgenden Ansätze in Betracht:

• Verwenden Sie eine Begrenzung Semaphorkanal zur Steuerung der Parallelität: Implementieren Sie einen gepufferten Kanal, der als Semaphor dient und die Anzahl gleichzeitiger Verbindungen begrenzt Anfragen. Durch Anpassen der Kanalpuffergröße und Optimieren von GOMAXPROCS können Sie die Parallelität für Ihr System optimieren.
• Nutzen Sie einen Worker-Pool mit einem Dispatcher:Verwenden Sie ein Worker-Pool-Muster, bei dem Anforderungen in einem Kanal in die Warteschlange gestellt werden . Ein Dispatcher füllt den Kanal, während ein Pool von Arbeitern die Anfragen einzeln bearbeitet. Dieser Ansatz stellt sicher, dass die maximale Anzahl gleichzeitiger Anfragen beibehalten wird.
• Verwenden Sie eine dedizierte Verbraucher-Goroutine, um Antworten zu verarbeiten: Um eine Blockierung der Anforderungsverarbeitung zu vermeiden, verwenden Sie eine dedizierte Goroutine, um Antworten vom Worker zu konsumieren Pool. Dies gewährleistet eine kontinuierliche Anforderungsausführung, sodass Ihr System mehr gleichzeitige Anforderungen verarbeiten kann.

Optimierter Code

Hier ist eine modifizierte Version Ihres Codes, die diese Optimierungen enthält:

package main

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

var (
    reqs       int
    concurrent int
    work       chan *http.Request
    results    chan *http.Response
)

func init() {
    reqs = 1000000
    concurrent = 200
}

func main() {
    runtime.GOMAXPROCS(runtime.NumCPU())
    work = make(chan *http.Request, concurrent)
    results = make(chan *http.Response)
    start := time.Now()

    // Create a semaphore channel to limit concurrency
    sem := make(chan struct{}, concurrent)

    // Create a dispatcher to populate the work channel
    go func() {
        for i := 0; i < reqs; i++ {
            req, _ := http.NewRequest("GET", "http://localhost/", nil)
            work <- req
        }
        close(work) // Signal to workers that no more requests are incoming
    }()

    // Create a worker pool to process requests
    for i := 0; i < concurrent; i++ {
        go func() {
            for req := range work {
                resp, err := http.DefaultClient.Do(req)
                if err != nil {
                    fmt.Println(err)
                }
                results <- resp

                // Release semaphore token to allow another worker to proceed
                <-sem
            }
        }()
    }

    // Consume responses from worker pool
    var (
        conns int64
        totalSize int64
        wg     sync.WaitGroup
    )

    wg.Add(1)
    go func() {
        defer wg.Done()
        for {
            select {
            case resp, ok := <-results:
                if ok {
                    conns++
                    totalSize += resp.ContentLength
                    resp.Body.Close()
                } else {
                    return
                }
            }
        }
    }()

    // Block until all responses are processed
    wg.Wait()

    elapsed := time.Since(start)
    fmt.Printf("Connections:\t%d\nConcurrent:\t%d\nTotal size:\t%d bytes\nElapsed:\t%s\n", conns, concurrent, totalSize, elapsed)
}

Durch Anpassen der Concurrent-Variable und Beobachten der Ergebnisse können Sie den optimalen Parallelitätsgrad für Ihr System bestimmen und so seine Kapazität für gleichzeitiges HTTP „maximieren“. Anfragen.

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