GO: Parallelität vs. Parallelität für Dummies.

Willkommen zu diesem Beitrag mit einem etwas erniedrigenden Titel.
Aber in diesem Beitrag möchte ich Ihnen auf sehr einfache Weise erklären, was diese beiden Merkmale des Programmierens sind, dieses Mal mit meiner Lieblingsprogrammiersprache GOLANG.

Stellen wir uns eine Küche vor:

Ein Gericht kochen: Das stellt eine Aufgabe dar.
Ein Koch: Er ist ein Verarbeiter.
Anwesenheit:

Mehrere Köche in der Küche: Jeder bereitet ein anderes Gericht zu.
In Go: Jeder Koch wäre ein Goroutine. Obwohl die Küche (Prozessor) nur über einen Ofen verfügt, können Köche gleichzeitig an ihren Gerichten arbeiten und sich die Zeit mit anderen Aufgaben vertreiben, während sie darauf warten, dass der Ofen verfügbar wird.
Parallelität:

Verschiedene Öfen: Jeder Koch hat seinen eigenen Ofen.
In Go: Wenn wir mehrere physische Prozessoren haben, könnte jede Goroutine auf einem anderen Prozessor laufen und mehrere Gerichte gleichzeitig auf echte Weise zubereiten.

Was ist der Unterschied?

Parallelität: Aufgaben werden ineinandergreifend ausgeführt, wodurch die Illusion von Parallelität entsteht, selbst auf einem einzelnen Prozessor.
Parallelität: Aufgaben laufen gleichzeitig auf mehreren Prozessoren, was den Prozess deutlich beschleunigt.

Wie verwende ich sie in Go?

Goroutinen: Sie sind wie leichte Fäden. Um eine Goroutine zu erstellen, verwenden wir einfach das Schlüsselwort go vor einer Funktion:

Sehen wir uns ein Beispiel an, wie wir Goroutinen in Golang verwenden können:

go func() {
    // Código que se ejecutará en una goroutine
}()

Kanäle: Dies sind Kanäle, über die Goroutinen kommunizieren und synchronisieren können.
Stellen Sie sich vor, dass es sich um Röhren handelt, mit denen Zutaten zwischen den Köchen weitergegeben werden

ch := make(chan int)
go func() {
    ch <- 42 // Enviar un valor por el canal
}()
value := <-ch // Recibir un valor del canal

Praxisbeispiel:

package main

import (
    "fmt"
    "time"
)

func worker(id int, c chan int) {
    for n := range c {
        fmt.Printf("Worker %d received %d\n", id, n)
        time.Sleep(time.Second)
    }
}

func main() {
    c := make(chan int)

    for i := 1; i <= 5; i++ {
        go worker(i, c)
    }

    for n := 1; n <= 10; n++ {
        c <- n
    }
    close(c)

    time.Sleep(time.Second)
}

Die Ausgabe dieses Codes wäre

Worker 1 received 1
Worker 2 received 2
Worker 3 received 3
Worker 4 received 4
Worker 5 received 5
Worker 1 received 6
Worker 2 received 7
Worker 3 received 8
Worker 4 received 9
Worker 5 received 10

obwohl es manchmal so aussehen könnte

Worker 5 received 1
Worker 1 received 3
Worker 2 received 2
Worker 4 received 5
Worker 3 received 4
Worker 3 received 6
Worker 5 received 10
Worker 2 received 8
Worker 4 received 7
Worker 1 received 9

oder so

Worker 5 received 1
Worker 1 received 2
Worker 2 received 3
Worker 3 received 4
Worker 4 received 5
Worker 1 received 6
Worker 2 received 7
Worker 3 received 8
Worker 5 received 9
Worker 4 received 10

Warum ändert sich die Ausgabe jedes Mal, wenn ich das Programm ausführe?

Der Hauptgrund, warum sich die Programmausgabe bei jedem Lauf ändert, liegt in der nichtdeterministischen Natur der Parallelität.

Hier ist eine Aufschlüsselung dessen, was passiert:

Erstellen Sie einen Kanal: make(chan int) erstellt einen Kanal aus Ganzzahlen. Dieser Kanal wird für die Kommunikation zwischen Goroutinen verwendet.

Goroutinen starten: Die Schleife für i := 1; ich Die Worker-Funktion erhält die ID und den Kanal.

Werte an Kanal senden: Die Schleife für n := 1; n 1 bis 10 an den Kanal.

Kanal schließen: Der Aufruf close(c) schließt den Kanal und zeigt an, dass keine Werte mehr gesendet werden.

Werte vom Kanal empfangen: Jede Goroutine empfängt Werte vom Kanal mithilfe der for n := range c-Schleife. Wenn ein Wert empfangen wird, wird er auf der Konsole ausgegeben.

Warten, bis die Goroutinen fertig sind: Der Aufruf time.Sleep(time.Second) stellt sicher, dass die Haupt-Goroutine vor dem Beenden auf den Abschluss der anderen Goroutinen wartet.

Bisher:

Wir erstellen 5 Goroutinen (Köche), die Zahlen über einen Kanal empfangen.
Wir senden Nummern an den Kanal, damit die Köche sie verarbeiten können.
Die Köche arbeiten gleichzeitig und verarbeiten die Zahlen, sobald sie sie erhalten.

Warum Parallelität und Parallelität in Go verwenden?

Bessere Leistung: Insbesondere bei I/O-gebundenen Aufgaben (wie dem Lesen von Dateien oder dem Stellen von HTTP-Anfragen).
Erhöhte Reaktionsfähigkeit: Die Anwendung kann weiterhin auf andere Anfragen reagieren, während eine Aufgabe gesperrt ist.
Skalierbarere Architekturen: Sie können die Arbeit auf mehrere Kerne oder Maschinen verteilen.

Denken Sie daran!

Parallelität und Parallelität sind leistungsstarke Werkzeuge, können aber auch dazu führen, dass Code komplexer zu verstehen und zu debuggen ist. Es ist wichtig, sie sorgfältig einzusetzen und ihre Auswirkungen zu verstehen.

Möchten Sie tiefer in ein bestimmtes Thema einsteigen?

Wir können Konzepte erkunden wie:

Synchronisation: Mutexe, Arbeitsgruppen usw.
Parallelitätsmuster: Producer-Consumer, Pipeline usw.
Gleichzeitiges Testen: So testen Sie gleichzeitigen Code effektiv.

Grüße,
Lucatonny Raudales

X/Twitter
Github

Das obige ist der detaillierte Inhalt vonGO: Parallelität vs. Parallelität für Dummies.. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!