Go Basics Goroutine

Dieser Artikel konzentriert sich weiterhin auf den grundlegenden Teil der Go-Sprache. Wir werden ein wenig über die Leistung sprechen und unsere Anwendung erweitern, indem wir einige einfache Goroutinen erstellen.

Wir werden auch auf einige der zugrunde liegenden Ausführungslogik der Go-Sprache und die Unterschiede zwischen der Go-Sprache und anderen Sprachen achten.

Parallelität in der Go-Sprache

Bevor wir mit der Diskussion fortfahren, müssen wir die Konzepte von Parallelität und Parallelität verstehen. Golang kann Parallelität und Parallelität erreichen.

Werfen wir einen Blick auf den Unterschied zwischen Parallelität und Parallelität.

Parallelität verstehen

Eine Anwendung kann mehrere Prozesse verarbeiten, um ihre beabsichtigte Funktionalität zu erfüllen. Nehmen wir eine einfache E-Commerce-Website an. Es wurde festgestellt, dass die folgenden Aufgaben gleichzeitig ausgeführt werden müssen:

1. Anzeige der neuesten Transaktions- und Produktinformationen oben auf der Webseite; die aktuelle Anzahl der Online-Benutzer der Website;

2. Warenkorbdetails aktualisieren, nachdem der Benutzer einen Artikel ausgewählt hat;

3. Die Website benötigt um alle diese Aufgaben gleichzeitig auszuführen, um den Benutzer mit der Website zu beschäftigen. Bleiben Sie relevant, machen Sie Ihre Website für Benutzer attraktiv und ziehen Sie mehr Geschäfte an. Daher kann eine einfache Anwendung oder Website eine Reihe von Aufgaben enthalten, die im Hintergrund ausgeführt werden, um geschäftlichen Anforderungen gerecht zu werden.

In den beiden oben gezeigten Beispielen werden mehrere Aufgaben gleichzeitig ausgeführt, es gibt jedoch dennoch Unterschiede zwischen ihnen. Lassen Sie uns weiter studieren, um es besser zu verstehen.

4. Parallelität und parallele Ausführung verstehen

Umgang mit gleichzeitigen Anwendungen

Angenommen, es gibt ein Szenario, in dem wir einen Single-Core-Computer haben, der mehrere Aufgaben ausführen muss, aber es gibt eine Einschränkung, dass immer nur eine Aufgabe auf dem Single-Core-Computer ausgeführt werden kann.

Im Parallelitätsmodell gibt es Kontextwechsel zwischen Aufgaben. Das Programm verarbeitet mehrere Aufgaben, aber da wir nur einen einzigen Kern haben, können die Aufgaben nicht gemeinsam ausgeführt werden.

Der Kontextwechsel zwischen Aufgaben erfolgt so schnell, dass wir das Gefühl haben, die Aufgaben würden gleichzeitig ausgeführt.

Während des Ausführungsprozesses gibt es keinen Faktor der parallelen Ausführung, da es sich um ein Single-Core-System handelt und mehrere Prozesse nicht parallel ausgeführt werden können.

Wie im Bild oben gezeigt, hat Parallelität (ohne Parallelität) zwei Aufgaben, die gleichzeitig ausgeführt werden müssen. Es wird immer nur eine Aufgabe ausgeführt und es gibt Kontextwechsel zwischen den Aufgaben.

Die Anwendung schließt sich der Parallelität an

Bei Verwendung eines einzelnen Kerns ist die Anzahl der Kerne begrenzt. Wenn wir der Maschine weitere Kerne hinzufügen, können wir Aufgaben auf verschiedenen Kernen gleichzeitig ausführen.

Im obigen Bild (Parallelität) werden zu jedem Zeitpunkt zwei Aufgaben ausgeführt, und diese beiden Aufgaben werden auf unterschiedlichen Kernen ausgeführt.

Parallelität ist die gleichzeitige Bearbeitung mehrerer Aufgaben innerhalb eines bestimmten Zeitraums, und Parallelität ist die Fähigkeit, mehrere Aufgaben zu einem bestimmten Zeitpunkt auszuführen.

Mit der Go-Sprache können Sie Ihr Programm ganz einfach von der gleichzeitigen zur parallelen Ausführung skalieren.

Verwendung von Goroutinen

Um mit der Go-Sprache Parallelität und Parallelität zu erreichen, müssen wir das Konzept von Goroutinen verstehen. Die Coroutine der Go-Sprache kann als Wrapper für einen Thread verstanden werden, der von der Go-Laufzeit und nicht vom Betriebssystem verwaltet wird.

Die Go-Laufzeit ist für die Zuweisung und Wiederverwendung von Ressourcen für Coroutinen verantwortlich. Coroutinen sind Threads sehr ähnlich, die Multitasking durchführen, aber weniger Ressourcen verbrauchen als Betriebssystem-Threads. Es gibt keine Eins-zu-Eins-Beziehung zwischen Coroutinen und Threads.

Wir können die Anwendung in mehrere gleichzeitige Aufgaben „zerlegen“, die von verschiedenen Goroutinen ausgeführt werden können. Auf diese Weise kann die Parallelität der Go-Sprache erreicht werden.

Vorteile von Coroutine:

1. Leichter

2. Einfach zu erweitern

3. Virtuelle Threads;

4. Benötigt weniger anfänglichen Speicher (2 KB);

5. Bei Bedarf kann die Go-Laufzeit mehr Speicher zuweisen;

ein Blick auf a einfaches Beispiel:

package main

import (
    "fmt"
    "time"
)

func main() {
  start := time.Now()
  func() {
    for i:=0; i < 3; i++ {
      fmt.Println(i)
    }
  }()

  func() {
    for i:=0; i < 3; i++ {
      fmt.Println(i)
    }
  }()

  elapsedTime := time.Since(start)

  fmt.Println("Total Time For Execution: " + elapsedTime.String())

  time.Sleep(time.Second)
}

Der obige Code führt nacheinander zwei unabhängige Funktionen in der Hauptfunktion aus.

Der Code verwendet keine Coroutinen und das Programm wird im selben Thread ausgeführt. Das Programm hat keine Parallelität und die Ausführungsergebnisse sind wie folgt:

Der Code wird der Reihe nach ausgeführt, beginnend mit der Hauptfunktion, zuerst die erste Funktion ausführen, dann die zweite Funktion ausführen und schließlich normal beenden aus der Hauptfunktion.

Einführung in Coroutinen

In den obigen Szenariobeispielen werden keine Coroutinen verwendet. Wir können das Schlüsselwort go verwenden, um die Coroutine zu starten, bevor wir die Funktion ausführen.

Noch das obige Beispiel, schauen wir uns an, wie es aussehen wird, nachdem das Schlüsselwort „go“ zum Öffnen der Coroutine verwendet wurde:

package main

import (
    "fmt"
    "time"
)

func main() {
  start := time.Now()
  go func() {
    for i:=0; i < 3; i++ {
      fmt.Println(i)
    }
  }()

  go func() {
    for i:=0; i < 3; i++ {
      fmt.Println(i)
    }
  }()

  elapsedTime := time.Since(start)

  fmt.Println("Total Time For Execution: " + elapsedTime.String())

  time.Sleep(time.Second)
}

Führen Sie die obige Codeausgabe aus:

Verwenden Sie im obigen Code jeweils das Schlüsselwort „go“. Es werden zwei Coroutinen geöffnet und ihre jeweiligen Funktionen ausgeführt, einschließlich der Hauptcoroutine. Es gibt insgesamt 3 Coroutinen.

Verstehen Sie den Unterschied zur sequentiellen Ausführung. Im obigen Code verwenden wir das Schlüsselwort „go“, um die Coroutine zu öffnen. Dies erhöht die Parallelität und verbessert die Leistung des Programms .

Parallelität erhöhen

In der Go-Sprache können Sie die Anzahl der Kerne festlegen, die das Programm über die folgende einfache Codezeile ausführen soll (PS: Ab Go 1.5 hat der Standardwert von Go's GOMAXPROCS auf die Anzahl der Kerne der CPU eingestellt).

runtime.GOMAXPROCS(4)

package main

import (
    "fmt"
    "time"
    "runtime"
)

func main() {
  runtime.GOMAXPROCS(4)
  start := time.Now()
  go func() {
    for i:=0; i < 3; i++ {
      fmt.Println(i)
    }
  }()

  go func() {
    for i:=0; i < 3; i++ {
      fmt.Println(i)
    }
  }()

  elapsedTime := time.Since(start)

  fmt.Println("Total Time For Execution: " + elapsedTime.String())

  time.Sleep(time.Second)
}

Parallelität und Parallelität können mit der Go-Sprache leicht erreicht werden. Fügen Sie einfach das Schlüsselwort go vor der Funktion hinzu, um die Programmausführungsgeschwindigkeit zu erhöhen.