So führen Sie Parallelität in Golang durch

Golang ist eine effiziente, schnelle und äußerst sichere Sprache, und ihre Parallelitätsfunktionen machen sie zu einem immer beliebter werdenden und leistungsfähigeren Werkzeug. Dieser Artikel beginnt mit grundlegenden Konzepten und stellt vor, wie Golang Parallelität implementiert.

1. Parallelität und Parallelität

Das erste, was geklärt werden muss, ist der Unterschied zwischen Parallelität und Parallelität. Parallelität bezieht sich auf mehrere Aufgaben, die sich überschneiden und im gleichen Zeitraum ausgeführt werden, während sich Parallelität darauf bezieht, dass mehrere Aufgaben gleichzeitig ausgeführt werden. In der Praxis verwechseln wir die beiden oft, aber in der Theorie handelt es sich um völlig unterschiedliche Konzepte.

2. Golangs Goroutine

Golangs Parallelität hängt hauptsächlich von Goroutine ab. Goroutine ist ein leichter Thread in Golang, der mit dem Schlüsselwort go gestartet wird. Der größte Unterschied zwischen Goroutine und Threads besteht darin, dass die Ausführung nicht auf Betriebssystem-Threads angewiesen ist, sondern direkt vom Laufzeitsystem von Golang verwaltet wird. Jede Goroutine ist eine unabhängige Einheit, die von der Go-Sprachlaufzeitumgebung (Laufzeit) geplant wird. Sie wird in einem logischen Prozessor ausgeführt. Der logische Prozessor bestimmt die Zuordnung der Goroutine zur tatsächlichen Anzahl von Threads im Betriebssystem.

In Golang-Programmen wird die Hauptfunktion standardmäßig in einer Goroutine ausgeführt, und andere Goroutinen können jederzeit gestartet und gleichzeitig mit der Hauptfunktion oder anderen Goroutinen ausgeführt werden.

3. Verwenden Sie das Schlüsselwort „go“, um Goroutine zu starten.

Sie können Goroutine ganz einfach mit dem Schlüsselwort „go“ starten. Wir müssen vor dem Funktionsaufruf nur das Schlüsselwort go hinzufügen, und das System öffnet bei Bedarf automatisch eine neue Goroutine. Beispiel:

go func1(arg1, arg2)

Diese Anweisung führt die Funktion func1 in Form einer Goroutine aus und der synchrone Code wird weiterhin ausgeführt. Zu diesem Zeitpunkt druckt das Programm zuerst diese Anweisung aus und führt dann sofort den folgenden Code aus. Zu einem bestimmten Zeitpunkt startet die Go-Sprachlaufzeit eine neue Goroutine, um die Funktion auszuführen. In diesem Fall können wir nicht direkt wissen, wann die Goroutine gestartet und wann sie endet.

Bei Funktionen mit Rückgabewerten müssen wir warten, bis die Ausführung der Goroutine abgeschlossen ist, bevor wir mit dem nächsten Schritt fortfahren. Dieser Vorgang kann durch die Verwendung von Kanälen erreicht werden.

4. Kanal

Kanal (Kanal) ist ein sehr wichtiger Kommunikationsmechanismus in der gleichzeitigen Golang-Programmierung. Kanäle ermöglichen den Datenaustausch zwischen Goroutinen. Kanäle verfügen immer über Sende- und Empfangsvorgänge, die standardmäßig blockiert sind, bis das andere Ende bereit ist.

Die Syntax zum Erstellen eines Kanals lautet wie folgt:

channel := make(chan type)

wobei Typ ein beliebiger Typ sein kann und Kanal eine Pipe mit dem Typ Typ ist.

Die Syntax zum Senden von Daten an den Kanal lautet wie folgt:

channel <- data

Diese Anweisung sendet Daten an den Kanal und sendet sie an die Goroutine, die auf den Empfang der Daten wartet.

Die Syntax zum Empfangen von Daten vom Kanal in Goroutine lautet wie folgt:

data := <- channel

Diese Anweisung empfängt Daten vom Kanal. Wenn im Kanal keine Daten vorhanden sind, blockiert diese Anweisung das Warten auf das Eintreffen von Daten.

Über Kanäle können wir die Synchronisation und Parallelität zwischen Goroutinen steuern. Beispiel:

ch := make(chan int)
go func(){
    ch <- 1
}()
data := <- ch

Diese Anweisung wartet darauf, dass die Goroutine nach dem Starten einer neuen Goroutine Daten an den Kanal sendet, und empfängt dann Daten vom Kanal, um die Ausführung fortzusetzen.

5. Sync-Paket

Zusätzlich zu den Kanälen bietet Golang auch ein Sync-Paket zur Unterstützung der gleichzeitigen Programmierung an. Dieses Paket bietet viele atomare Betriebsfunktionen und -mechanismen wie Mutex-Sperren.

Die atomare Operationsfunktion ist ein sehr wichtiges Konzept in der gleichzeitigen Golang-Programmierung. Sie kann sicherstellen, dass eine Reihe von Operationen während der Ausführung unteilbar sind, was bedeutet, dass andere Goroutinen sie nicht sehen können, wenn sie atomare Operationen ausführen Im Status ist das Objekt entweder unverändert oder geändert. Dadurch kann das Synchronisationsproblem sehr gut gelöst werden.

Zum Beispiel:

var sum int64 = 0
for i := 0; i < 10000; i++ {
    go func(){
        atomic.AddInt64(&sum, 1)
    }()
}

Diese Anweisung demonstriert die Verwendung atomarer Operationsfunktionen zur Durchführung von Berechnungen. In diesem Programm addiert die Goroutine kontinuierlich 1 zur Summenvariablen, ohne Rennbedingungen zu schaffen. Dieses Problem, das durch die fehlende Synchronisation von Lese- und Schreibvariablen verursacht wird, wird als Race Condition bezeichnet, und atomare Operationsfunktionen können dieses Problem perfekt vermeiden.

6. Zusammenfassung

In diesem Artikel wird vorgestellt, wie Golang Parallelität implementiert. Es geht hauptsächlich um grundlegende Elemente wie Golangs Goroutine, Kanäle und atomare Operationen im Sync-Paket sowie deren Anwendung in der gleichzeitigen Programmierung. Die Parallelitätsfunktionen von Golang helfen nicht nur bei der Verarbeitung technischer Aufgaben, der gleichzeitigen Verarbeitung von Servern, der Entwicklung von Echtzeitsystemen und anderen Bereichen, sondern sind auch einer der wichtigen Gründe, warum Golang zu einer beliebten Programmiersprache geworden ist.

Das obige ist der detaillierte Inhalt vonSo führen Sie Parallelität in Golang durch. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!