Einführung in die Parallelität in Go

Parallelität ist ein entscheidender Aspekt der modernen Softwareentwicklung, da sie es Programmen ermöglicht, mehrere Aufgaben gleichzeitig effizient zu erledigen. Sie können Programme schreiben, die verschiedene Vorgänge ausführen, was zu einer verbesserten Leistung, Reaktionsfähigkeit und Ressourcennutzung führt.

Parallelität ist eines der Merkmale, die für die schnelle Akzeptanz von Go verantwortlich sind. Die integrierte Unterstützung von Go für gleichzeitige Programmierung gilt als unkompliziert und hilft gleichzeitig, häufige Fallstricke wie Rennbedingungen und Deadlocks zu vermeiden.

Parallelität in Go

Go bietet robuste Unterstützung für Parallelität durch verschiedene Mechanismen, die alle in seiner Standardbibliothek und Toolchain verfügbar sind. Go-Programme Erreichen Sie Parallelität durch Goroutinen und Kanäle.

Goroutinen sind leichtgewichtige, unabhängig ausführende Funktionen, die gleichzeitig mit anderen Goroutinen innerhalb desselben Adressraums ausgeführt werden. Goroutinen ermöglichen die gleichzeitige Ausführung mehrerer Aufgaben ohne explizite Thread-Verwaltung. Goroutinen sind leichter als Betriebssystem-Threads und Go kann Tausende oder sogar Millionen von Goroutinen gleichzeitig effizient ausführen.

Kanäle sind der Kommunikationsmechanismus für die Koordination und den Datenaustausch zwischen Goroutinen. Ein Kanal ist eine typisierte Leitung, die es Goroutinen ermöglicht, Werte zu senden und zu empfangen. Kanäle sorgen für Synchronisierung, um einen sicheren Datenaustausch zwischen Goroutinen zu gewährleisten und gleichzeitig Race Conditions und andere häufige Parallelitätsprobleme zu verhindern.

Durch die Kombination von Goroutinen und Kanälen bietet Go ein leistungsstarkes und unkompliziertes Parallelitätsmodell, das die Entwicklung gleichzeitiger Programme vereinfacht und gleichzeitig Sicherheit und Effizienz gewährleistet. Diese Mechanismen ermöglichen Ihnen eine einfache Verwendung Multicore-Prozessoren und hoch skalierbare und reaktionsfähige Anwendungen erstellen.

So verwenden Sie Goroutinen für die gleichzeitige Codeausführung

Die Go-Laufzeit verwaltet Goroutinen. Goroutinen verfügen über einen eigenen Stack, wodurch sie mit einer anfänglichen Stackgröße von einigen Kilobyte einen geringen Platzbedarf haben.

Goroutinen werden von der Go-Laufzeit auf mehrere Betriebssystem-Threads gemultiplext. Der Go-Laufzeitplaner plant sie auf verfügbare Threads, indem er die Arbeitslast effizient verteilt und so die gleichzeitige Ausführung mehrerer Goroutinen auf weniger Betriebssystem-Threads ermöglicht.

Das Erstellen von Goroutinen ist unkompliziert. Sie werden das verwenden gehen Schlüsselwort gefolgt von einem Funktionsaufruf zum Deklarieren von Goroutinen.

Funktionhauptsächlich() {
gehen Funktion1() // Goroutine für Funktion1 erstellen und ausführen
gehen Funktion2() // Goroutine für Funktion2 erstellen und ausführen
// ...
}
FunktionFunktion1() {
// Code für Funktion1
}
FunktionFunktion2() {
// Code für Funktion2
}

Wenn das Programm aufgerufen wird Funktion1() Und Funktion2() mit dem gehen Mit dem Schlüsselwort führt die Go-Laufzeit die Funktionen gleichzeitig als Goroutinen aus.

Hier ist ein Beispiel für die Verwendung einer Goroutine, die Text auf der Konsole ausgibt:

Paket hauptsächlich
importieren (
„fmt“
"Zeit"
)
FunktionprintText() {
für ich := 1; ich <= 5; i++ {
 fmt. Println(„Text drucken“, ich)
 Zeit. Schlafen(1 * Zeit. Zweite)
 }
}
Funktionhauptsächlich() {
gehen printText() // Eine Goroutine starten, um die printText-Funktion gleichzeitig auszuführen
// Andere Aufgaben in der Hauptgoroutine ausführen
für ich := 1; ich <= 5; i++ {
 fmt. Println(„Andere Aufgaben ausführen“, ich)
 Zeit. Schlafen(500 * Zeit. Millisekunde)
 }
// Warten, bis die Goroutine fertig ist
 Zeit. Schlafen(6 * Zeit. Zweite)
}

Der printText Die Funktion gibt mit a wiederholt Text auf der Konsole aus für Schleife, die fünfmal mit einer Verzögerung von einer Sekunde zwischen den einzelnen Anweisungen ausgeführt wird das Zeitpaket.

Der hauptsächlich Funktion startet eine Goroutine durch Aufruf Gehen Sie printText, wodurch die gestartet wird printText Funktion als separate gleichzeitige Goroutine, die es der Funktion ermöglicht, gleichzeitig mit dem Rest des Codes in der ausgeführt zu werden hauptsächlich Funktion.

Um schließlich sicherzustellen, dass das Programm nicht vor dem beendet wird printText Goroutine endet, das Zeit. Schlafen Die Funktion hält die Haupt-Goroutine für sechs Sekunden an. In realen Szenarien würden Sie Synchronisationsmechanismen wie Kanäle oder Wartegruppen verwenden, um die Ausführung von Goroutinen zu koordinieren.

Nutzung von Kanälen für Kommunikation und Synchronisierung

Goroutinen verfügen über eine integrierte Unterstützung für die Kommunikation und Synchronisierung über Kanäle, sodass das Schreiben gleichzeitig erfolgen kann Code einfacher als herkömmliche Threads, die oft manuelle Synchronisierungsmechanismen wie Sperren und erfordern Semaphore.

Sie können sich Kanäle als Pipelines für den Datenfluss zwischen Goroutinen vorstellen. Eine Goroutine kann einen Wert an den Kanal senden und eine andere Goroutine kann diesen Wert vom Kanal empfangen. Dieser Mechanismus gewährleistet einen sicheren und synchronisierten Datenaustausch.

Sie werden das verwenden Betreiber zum Senden und Empfangen von Daten über Kanäle.

Hier ist ein Beispiel, das die grundlegende Verwendung von Kanälen für die Kommunikation zwischen zwei Goroutinen demonstriert:

Funktionhauptsächlich() {
// Erstelle einen ungepufferten Kanal vom Typ String
 ch := machen(ChanZeichenfolge)
// Goroutine 1: Sendet eine Nachricht in den Kanal
gehenFunktion() {
 ch „Hallo, Kanal!“
 }()
// Goroutine 2: Empfängt die Nachricht vom Kanal
 msg :=  fmt. Println (Nachricht) // Ausgabe: Hallo, Kanal!
}

Der Kanal im hauptsächlich Die Funktion ist ein ungepufferter Kanal mit dem Namen CH erstellt mit dem machen() Funktion. Die erste Goroutine sendet die Nachricht „Hallo, Kanal!“ in den Kanal mit dem Operator, und die zweite Goroutine empfängt die Nachricht vom Kanal unter Verwendung desselben Operators. Endlich, das hauptsächlich Funktion gibt die empfangene Nachricht an die Konsole aus.

Sie können typisierte Kanäle definieren. Sie geben den Kanaltyp bei der Erstellung an. Hier ist ein Beispiel, das die Verwendung verschiedener Kanaltypen demonstriert:

Funktionhauptsächlich() {
// Ungepufferter Kanal
 ch1 := machen(Chanint)
// Gepufferter Kanal mit einer Kapazität von 3
 ch2 := machen(ChanZeichenfolge, 3)
// Werte von Kanälen senden und empfangen
 ch1 42// Einen Wert an Kanal 1 senden
 Wert1 := // Einen Wert von Kanal 1 erhalten
 ch2 "Hallo"// Einen Wert an Kanal 2 senden
 value2 := // Einen Wert von ch2 erhalten
}

Der hauptsächlich Funktion erstellt zwei Kanäle: ch1 ist ein ungepufferter Integer-Kanal, while ch2 ist ein gepufferter String-Kanal mit einer Kapazität von 3. Mit dem können Sie Werte an und von diesen Kanälen senden und empfangen Operator (die Werte müssen vom angegebenen Typ sein).

Sie können Kanäle als Synchronisationsmechanismen zur Koordinierung der Goroutine-Ausführung verwenden, indem Sie die blockierende Natur von Kanaloperationen nutzen.

Funktionhauptsächlich() {
 ch := machen(Chanbool)
gehenFunktion() {
 fmt. Println(„Goroutine 1“)
 ch WAHR// Signalabschluss
 }()
gehenFunktion() {
 // Auf das Abschlusssignal von Goroutine 1 warten
 fmt. Println(„Goroutine 2“)
 }()
 // Auf Abschlusssignal von Goroutine 2 warten
 fmt. Println(„Hauptgoroutine“)
}

Der CH Kanal ist boolesch. Zwei Goroutinen laufen gleichzeitig im hauptsächlich Funktion. Goroutine 1 signalisiert seinen Abschluss durch das Senden von a WAHR Wert in den Kanal übertragen CH. Goroutine 2 wartet auf das Abschlusssignal, indem es einen Wert vom Kanal empfängt. Schließlich wartet die Haupt-Goroutine auf das Abschlusssignal von Goroutine zwei.

Sie können Web-Apps in Go With Gin erstellen

Sie können in Go mit Gin leistungsstarke Web-Apps erstellen und gleichzeitig die Parallelitätsfunktionen von Go nutzen.

Mit Gin können Sie HTTP-Routing und Middleware effizient verwalten. Profitieren Sie von Gos integrierter Parallelitätsunterstützung, indem Sie Goroutinen und Kanäle für Aufgaben wie Datenbankabfragen, API-Aufrufe oder andere Blockierungsvorgänge einsetzen.