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: Dies stellt eine Aufgabe dar.
Ein Koch: Er ist ein Verarbeiter.
Gleichzeitigkeit:

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 Zeit mit anderen Aufgaben verbringen, 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 im wirklichen Leben mehrere Gerichte gleichzeitig kochen.

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 Pipes, ü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 verteilt werden

ch := make(chan int)
go func() {
    ch 



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 



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 jeder Ausführung ändert, liegt in der nichtdeterministischen Natur der Parallelität.

Hier ist eine Aufschlüsselung dessen, was passiert:

Erstelle 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 Kanal.

Schließen Sie den Kanal: Der Aufruf close(c) schließt den Kanal und zeigt an, dass keine weiteren Werte 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 Nummern ü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 Senden von HTTP-Anfragen).
Erhöhte Reaktionsfähigkeit: Die Anwendung kann weiterhin auf andere Anfragen reagieren, während eine Aufgabe blockiert ist.
Skalierbarere Architekturen: Sie können die Arbeit auf mehrere Kerne oder Maschinen verteilen.

Erinnern!

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 zu nutzen 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