Home-theater-designers
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.
MUO-Video des Tages Scrollen Sie, um mit dem Inhalt fortzufahren
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.
5 0 Funkpolizeiscanner Android
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.
func main() {
go function1() // Create and execute goroutine for function1
go function2() // Create and execute goroutine for function2
// ...
}
func function1() {
// Code for function1
}
func function2() {
// Code for function2
}
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:
package main
import (
"fmt"
"time"
)
func printText() {
for i := 1; i <= 5; i++ {
fmt.Println("Printing text", i)
time.Sleep(1 * time.Second)
}
}
func main() {
go printText() // Start a goroutine to execute the printText function concurrently
// Perform other tasks in the main goroutine
for i := 1; i <= 5; i++ {
fmt.Println("Performing other tasks", i)
time.Sleep(500 * time.Millisecond)
}
// Wait for the goroutine to finish
time.Sleep(6 * time.Second)
}
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.Schlaf 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.
Wie ändern Sie Ihr Standard-Google-Konto?
Nutzung von Kanälen für Kommunikation und Synchronisierung
Goroutinen verfügen über eine integrierte Unterstützung für Kommunikation und Synchronisierung über Kanäle, was das Schreiben gleichzeitigen Codes einfacher macht als herkömmliche Threads, die häufig manuelle Synchronisierungsmechanismen wie Sperren und Semaphoren erfordern.
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:
func main() {
// Create an unbuffered channel of type string
ch := make(chan string)
// Goroutine 1: Sends a message into the channel
go func() {
ch <- "Hello, Channel!"
}()
// Goroutine 2: Receives the message from the channel
msg := <-ch
fmt.Println(msg) // Output: Hello, Channel!
}
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:
func main() {
// Unbuffered channel
ch1 := make(chan int)
// Buffered channel with a capacity of 3
ch2 := make(chan string, 3)
// Sending and receiving values from channels
ch1 <- 42 // Send a value into ch1
value1 := <-ch1 // Receive a value from ch1
ch2 <- "Hello" // Send a value into ch2
value2 := <-ch2 // Receive a value from ch2
}
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.
So erhöhen Sie den dedizierten Video-RAM Intel HD-Grafik
func main() {
ch := make(chan bool)
go func() {
fmt.Println("Goroutine 1")
ch <- true // Signal completion
}()
go func() {
<-ch // Wait for the completion signal from Goroutine 1
fmt.Println("Goroutine 2")
}()
<-ch // Wait for completion signal from Goroutine 2
fmt.Println("Main goroutine")
}
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 dabei 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.