Schreiben Ihres ersten parallelen Go-Programms auf Ubuntu

Die Programmiersprache Go von Google gibt es seit 2009 und 2012 erreichte die Sprache ihren offiziellen Status v1.0. In den dazwischenliegenden Jahren hat sich viel verändert, einschließlich der Art und Weise, wie die Sprache installiert wird. In ihren Anfängen gab es keine offiziellen binären Distributionen, und man musste Go entweder aus dem Quellcode bauen, was die empfohlene Methode war, da sich die Sprache häufig änderte, oder ein vorgefertigtes Paket für Ihre Linux-Distribution verwenden. Damals war die Unterstützung für Windows begrenzt, ebenso wie die Unterstützung für CPU-Architekturen außer Intel.

Seitdem hat sich viel verbessert. Für Linux gibt es zwei einfache Möglichkeiten, Go zu installieren. Laden Sie das offizielle Linux-Binärpaket von der Go-Download-Seite herunter oder entscheiden Sie sich für ein vorgefertigtes Paket für Ihre Linux-Distribution. Der einfachste Weg, Go auf Ubuntu zu installieren, ist die Verwendung von apt-get:

sudo apt-get install golang

Sobald Go installiert ist, können Sie mit der Entwicklung von Programmen beginnen. Eines der einfachsten Go-Programme ist das klassische “Hello World!”-Programm. Erstellen Sie mit einem Texteditor eine Datei namens “ hellomte.go “ mit dem folgenden kurzen Go-Code:

package main  
  
import "fmt"  
  
func main(){  
     fmt.Println("Hello Make Tech Easier!")  
}

Seit v1.0 von Go wurde die Notwendigkeit für einzelne Kompilierungs- und Linkbefehle entfernt, und die alten Befehle 8g und 8l wurden durch den Befehl go ersetzt.

Um hellomte.go auszuführen, öffnen Sie ein Terminal und wechseln Sie in das Verzeichnis, das die Quellcodedatei enthält, und geben Sie dann ein:

go run hellomte.go

Dies wird das Go-Programm kompilieren und ausführen, aber es wird keine ausführbare Binärdatei erzeugen. Um eine Binärdatei zu erstellen und sie dann auszuführen, verwenden Sie den Befehl go build:

go build hellomte.go  
./hellomte

Die Kraft der Parallelität

Eine der definierenden Eigenschaften der Programmiersprache Go ist ihre Unterstützung für Parallelität, die es einem Programm ermöglicht, mit mehreren Aufgaben gleichzeitig zu arbeiten. Parallelismus, der der Parallelität ähnlich ist, ermöglicht es einem Programm, viele Aufgaben gleichzeitig auszuführen, aber Parallelität geht einen Schritt weiter, indem sie es diesen separaten Aufgaben ermöglicht, zu kommunizieren und zu interagieren. Infolgedessen ermöglicht Go Programmierern die Verwendung einer Vielzahl von verschiedenen parallelen Designs, einschließlich Arbeiterpools, Pipelines (bei denen eine Aufgabe nach einer anderen erfolgt) und synchronen oder asynchronen Hintergrundaufgaben. Die Grundlage dieser Parallelität ist die goroutine, gekoppelt mit channels und dem select-Befehl von Go.

Hier ist ein einfaches Go-Programm, das eine Zeichenfolge mehrmals mit einer parallelen Goroutine ausgibt:

package main  
  
import(  
"fmt"  
"time"  
)  
  
func say(s string){  
for i := 0; i < 5; i++ {  
        fmt.Println(s)  
}  
}  
  
func main(){  
go say("Hello Make Tech Easier!")  
    fmt.Println("Schlaf ein wenig...")  
    time.Sleep(100 * time.Millisecond)  
}

Die Funktion say() führt einfach eine Schleife aus, um die Zeichenfolge (Parameter s) fünfmal auszugeben. Das Interessante ist, wie diese Funktion aufgerufen wird. Anstatt einfach say("Hello Make Tech Easier!") aufzurufen, wird das Schlüsselwort go vor den Funktionsaufruf gesetzt. Das bedeutet, dass die Funktion als separate Aufgabe ausgeführt wird. Der Rest der Funktion main() schläft dann einfach ein wenig, um der goroutine Zeit zu geben, abzuschließen.

Die Ausgabe könnte Sie überraschen:

Wie Sie sehen können, wird die Funktion say() als goroutine ausgeführt, und während sie eingerichtet wird, läuft der Rest der Funktion main(), gibt “Schlaf ein wenig…” aus und geht dann schlafen. Zu diesem Zeitpunkt ist die goroutine aktiv und beginnt, die Zeichenfolge fünfmal auszugeben. Schließlich endet das Programm, sobald die Zeitüberschreitung erreicht ist.

Kanäle

goroutines können über Kanäle kommunizieren. Ein Kanal öffnet eine Kommunikationslinie zwischen zwei verschiedenen Teilen eines Go-Programms. Typischerweise wird eine Funktion als goroutine aufgerufen, und wenn sie Daten zurücksenden muss (zum Beispiel von einer Netzwerkoperation), kann sie einen Kanal verwenden, um diese Daten weiterzugeben. Wenn ein anderer Teil des Go-Programms auf diese Daten wartet, schläft er, bis die Daten bereit sind. Kanäle werden mit der Funktion make() erstellt und können als Parameter an goroutines übergeben werden.

Betrachten Sie diesen Code:

package main  
  
import(  
"fmt"  
)  
  
func say(s string, c chan int){  
var i int  
for i = 0; i < 5; i++ {  
          fmt.Println(s)  
}  
     c <- i  
}  
  
func main(){  
     c := make(chan int)  
go say("Hello Make Tech Easier!", c)  
     sts := <- c  
     fmt.Println(sts)  
}

Die Funktion say() ist sehr ähnlich zum ersten Beispiel, mit der Ausnahme, dass der zweite Parameter ein Kanal ist und dass nach dem Ausgeben der Zeichenfolge die Anzahl der Iterationen über die Zeile c <- i an den Kanal gesendet wird.

Die Hauptfunktion erstellt einen Kanal, startet die Funktion say() als goroutine und wartet dann darauf, dass die Daten über den Kanal kommen, sts := <- c, bevor sie das Ergebnis ausgibt.

Fazit

Die Go-Sprache hat sich in den letzten Jahren erheblich weiterentwickelt. Wenn Sie sich in letzter Zeit nicht damit beschäftigt haben, ist jetzt vielleicht ein guter Zeitpunkt!