Multithread-Anfragen laufen und erreichen keine hohen RPS

php-Editor Xigua bemerkte, dass es bei der Verwendung der Go-Sprache zum Senden von Multithread-Anfragen manchmal nicht möglich ist, eine hohe Anfrage pro Sekunde (RPS)-Geschwindigkeit zu erreichen. Obwohl sich die Go-Sprache hervorragend für die Parallelitätsverarbeitung eignet, sind Multithread-Anfragen in manchen Fällen nicht sehr effizient. Dies kann auf Netzwerklatenz, Ressourcenkonkurrenz usw. zurückzuführen sein. In diesem Artikel werden wir dieses Problem untersuchen und einige mögliche Lösungen zur Verbesserung des RPS von Multithread-Anfragen in der Go-Sprache bereitstellen.

Frageninhalt

Ich versuche, einen Multithread-Client zu schreiben, um meinen Server zu testen. Wenn ich 2 Goroutinen verwende, ist alles in Ordnung, ich erhalte 50.000 U/s und meine CPU-Auslastung ist normal, aber wenn ich mehr als 2 Goroutinen erstelle, sinkt die U/s auf 3.000, aber meine CPU-Auslastung überschreitet. Wenn ich jedoch den Client-Code mehrmals ausführe (z. B. wenn ich denselben Code gleichzeitig auf drei Konsolen ausführe), erhalte ich mehr U/s, beispielsweise 80.000 U/s.

Das ist mein Kundencode

package main

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

func main() {
    requesturl := fmt.sprintf("http://localhost:%d/home", 3333)
    var wg sync.waitgroup
    wg.add(4)
    req, err := http.newrequest(http.methodget, requesturl, nil)
    if err != nil {
        fmt.printf("client: could not create request: %s\n", err)
        os.exit(1)
    }
    for i := 0; i < 4; i++ {
        go func() {
            defer wg.done()
            client := http.client{
                timeout: 30 * time.second,
            }
            for {
                client.do(req)
            }
        }()
    }
    wg.wait()
}

Dies ist mein serverseitiger Code

package main

import (
    "errors"
    "fmt"
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
    "log"
    "net/http"
    "os"
    "sync"
)

// log handling
func openlogfile(path string) (*os.file, error) {
    logfile, err := os.openfile(path, os.o_wronly|os.o_append|os.o_create, 0644)
    if err != nil {
        return nil, err
    }
    return logfile, nil
}

// variables of counter in metric
var okstatuscounter = prometheus.newcounter(
    prometheus.counteropts{
        name: "ok_request_count",
        help: "number of 200",
    },
)

func listener(serverlog *log.logger) http.handlerfunc {
    return func(w http.responsewriter, r *http.request) {
        //metric 
        okstatuscounter.inc()
        
        w.writeheader(http.statusok)
    }
}

func main() {
    //metric
    prometheus.mustregister(okstatuscounter)

    //log handling
    filesimpleserverlog, err := openlogfile("simpleserver/simpleserverlog.log")
    if err != nil {
        log.fatal(err)
    }
    serverlog := log.new(filesimpleserverlog, "[simple server]", log.lstdflags|log.lshortfile|log.lmicroseconds)

    var wg sync.waitgroup
    wg.add(1)

    //server:
    go func() {
        defer wg.done()
        mux := http.newservemux()
        mux.handlefunc("/home", listener(serverlog))
        mux.handle("/metrics", promhttp.handler())
        server := http.server{
            addr:    fmt.sprintf(":%d", 3333),
            handler: mux,
        }
        if err := server.listenandserve(); err != nil {
            if !errors.is(err, http.errserverclosed) {
                serverlog.printf("error running http server: %s\n", err)
            }
        }
    }()
    wg.wait()
}

Zuerst dachte ich, dass Go möglicherweise einen Port für alle Client-Verbindungen verwendet, aber als ich es mit netstat überprüfte, nutzte es mehrere Ports. Ich habe versucht zu suchen, konnte aber keine passende Antwort finden

Ich habe sync.mutex ausprobiert:

var mu sync.Mutex
...
for i := 0; i < 1000; i++ {
        go func() {
            defer wg.Done()
            client := http.Client{
                //Timeout: 30 * time.Second,
            }
            for {
                mu.Lock()
                _, err := client.Do(req)
                if err != nil {
                    clientLog.Printf("client: error making http request: %s\n", err)
                    os.Exit(1)
                }
                mu.Unlock()
            }
        }()
    }
    wg.Wait()
...

Mit den oben genannten Änderungen habe ich 13.000 U/s erreicht und meine CPU-Auslastung war in Ordnung, aber es war einfach nicht genug

Workaround

Da Sie nur Anfragen an einen Host senden, funktioniert der Standardwert des HTTP-Transports nicht Du. Es ist besser, die Parameter manuell entsprechend Ihrer Situation einzustellen:

t := http.DefaultTransport.(*http.Transport).Clone()
t.MaxIdleConns = 100
t.MaxConnsPerHost = 100
t.MaxIdleConnsPerHost = 100
    
httpClient = &http.Client{
  Timeout:   10 * time.Second,
  Transport: t,
}

Weitere Informationen finden Sie hier.

Das obige ist der detaillierte Inhalt vonMultithread-Anfragen laufen und erreichen keine hohen RPS. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!