Golang-Codefreigabe mit hoher Parallelität

Heute fragte der Leiter, warum Golang verwendet wurde. Mein Kollege antwortete, dass die Syntax einfach sei, die Sprache neu sei und eine hohe Parallelität unterstütze. Wie erreicht man eine hohe Parallelität? Der folgende Artikel stellt Ihnen hauptsächlich die relevanten Informationen zur Verwendung von Golang zum Schreiben von Code mit hoher Parallelität vor. Freunde, die ihn benötigen, können einen Blick darauf werfen . Bar.

Vorwort

Ich war immer verwirrt darüber, wie Golang mit vielen gleichzeitigen HTTP-Anfragen umgeht. Ich habe in den letzten paar Blogs auch viele verwandte Blogs überprüft Ich scheine es zu verstehen, aber ich weiß nicht, wie ich den spezifischen Code schreiben soll

Am Nachmittag habe ich versehentlich einen Artikel eines ausländischen Technikers über die Developer Toutiao APP gesehen, in dem er Golang zur Verarbeitung von Millionen verwendet Anfragen pro Minute. Nachdem ich den Artikel gelesen hatte, habe ich den Code selbst geschrieben und unten meine Erfahrungen niedergeschrieben

Kernpunkte

Setzen Sie die Anforderung in die Warteschlange, ein Worker-Pool (Pool) wird durch eine bestimmte Anzahl (z. B. die Anzahl der CPU-Kerne) von Goroutinen gebildet, und die Worker im Worker-Pool lesen die Warteschlange und führen Aufgaben aus

Instanzcode

Der folgende Code wurde vom Autor basierend auf seinem eigenen Verständnis vereinfacht, hauptsächlich um seine persönlichen Ideen in der tatsächlichen Backend-Entwicklung auszudrücken wird entsprechend dem tatsächlichen Szenario geändert

func doTask() {
 //耗时炒作(模拟)
 time.Sleep(200 * time.Millisecond)
 wg.Done()
}

//这里模拟的http接口,每次请求抽象为一个job
func handle() {
 //wg.Add(1)
 job := Job{}
 JobQueue <- job
}

var (
 MaxWorker = 1000
 MaxQueue = 200000
 wg  sync.WaitGroup
)

type Worker struct {
 quit chan bool
}

func NewWorker() Worker {
 return Worker{
  quit: make(chan bool)}
}

// Start method starts the run loop for the worker, listening for a quit channel in
// case we need to stop it
func (w Worker) Start() {
 go func() {
  for {
   select {
   case <-JobQueue:
    // we have received a work request.
    doTask()
   case <-w.quit:
    // we have received a signal to stop
    return
   }
  }
 }()
}

// Stop signals the worker to stop listening for work requests.
func (w Worker) Stop() {
 go func() {
  w.quit <- true
 }()
}

type Job struct {
}

var JobQueue chan Job = make(chan Job, MaxQueue)

type Dispatcher struct {
}

func NewDispatcher() *Dispatcher {
 return &Dispatcher{}
}

func (d *Dispatcher) Run() {
 // starting n number of workers
 for i := 0; i < MaxWorker; i++ {
  worker := NewWorker()
  worker.Start()
 }
}

Testen

func Benchmark_handle(b *testing.B) {
 runtime.GOMAXPROCS(runtime.NumCPU())
 d := NewDispatcher()
 d.Run()
 for i:=0;i<10000;i++ {
  wg.Add(1)
  handle()
 }
 wg.Wait()
}

Testergebnisse

pkg: golang-study-demo/goroutine
1 2029931652 ns/op
PASS

1w Aufgaben werden in die Warteschlange gestellt und 1000 Arbeiter führen die Aufgaben aus. Der Zeitaufwand für jede Aufgabe beträgt 200 ms, es dauert mehr als 2 s, um die Aufgabe abzuschließen

Das Obige ist nur die persönliche Meinung des Autors Ich weiß, ob mein Verständnis der gleichzeitigen Golang-Programmierung korrekt ist. Ich hoffe, ein Experte kann mir einen Rat geben

Das obige ist der detaillierte Inhalt vonGolang-Codefreigabe mit hoher Parallelität. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!