Multithread-Anfragen laufen und erreichen keine hohen RPS-Golang-php.cn

Multithread-Anfragen laufen und erreichen keine hohen RPS

WBOY

Freigeben： 2024-02-09 16:48:10

nach vorne

1003 Leute haben es durchsucht

go 中的多线程请求并且没有获得高 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()
}

Nach dem Login kopieren

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

Nach dem Login kopieren

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

Nach dem Login kopieren

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,
}

Nach dem Login kopieren

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!