Schreiben Sie Ihr erstes gleichzeitiges Go-Programm unter Ubuntu

Die Programmiersprache Go von Google gibt es seit 2009 und im Jahr 2012 erreichte die Sprache ihren offiziellen Status v1.0. In den vergangenen Jahren hat sich viel verändert, auch bei der Art und Weise, wie die Sprache installiert wird. Als es noch in den Kinderschuhen steckte, gab es keine offiziellen Binärdistributionen und Sie mussten Go entweder aus dem Quellcode erstellen, 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 Windows-Unterstützung ebenso eingeschränkt wie die Unterstützung für andere CPU-Architekturen als Intel.

Seitdem hat sich alles enorm verbessert. Für Linux gibt es zwei einfache Möglichkeiten, Go zu installieren. Laden Sie den offiziellen Linux-Binär-Build herunter von die Go-Downloads-Seite Oder entscheiden Sie sich für ein vorgefertigtes Paket für Ihre Linux-Distribution. Der einfachste Weg, Go unter 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 der Klassiker „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 Version 1.0 von Go entfällt die Notwendigkeit individueller Kompilierungs- und Linkbefehle und die alten 8g- und 8l-Befehle wurden durch den go-Befehl ersetzt.

Um hellomte.go auszuführen, öffnen Sie ein Terminal, wechseln Sie in das Verzeichnis, in dem sich die Quellcodedatei befindet, und geben Sie dann Folgendes ein:

Dadurch wird das Go-Programm kompiliert und ausgeführt, es wird jedoch keine ausführbare Binärdatei erstellt. Um eine Binärdatei zu erstellen und diese dann auszuführen, verwenden Sie den Befehl go build:

Gehe und baue hellomte.go ./hellomte

Die Kraft der Parallelität

Eines der entscheidenden Merkmale der Programmiersprache Go ist die Unterstützung der Parallelität, die es einem Programm ermöglicht, mit mehreren Aufgaben gleichzeitig zu arbeiten. Parallelität, die der Parallelität ähnelt, ermöglicht es einem Programm, viele Aufgaben gleichzeitig auszuführen, aber die Parallelität geht noch einen Schritt weiter, indem sie die Kommunikation und Interaktion dieser separaten Aufgaben ermöglicht. Dadurch ermöglicht Go Programmierern die Verwendung einer Vielzahl unterschiedlicher gleichzeitiger Designs, darunter Worker-Pools, Pipelines (in denen eine Aufgabe nach der anderen ausgeführt wird) sowie synchrone oder asynchrone Hintergrundaufgaben. Die Grundlage dieser Parallelität ist die Goroutine in Verbindung mit Kanälen und der Select-Anweisung von Go.

Hier ist ein einfaches Go-Programm, das mithilfe einer gleichzeitigen Goroutine mehrmals einen String ausgibt:

Pakethauptimport ( "fmt" "time" ) func say(s string) { for i := 0;  ich < 5;  i++ { fmt.Println(s) } } func main() { go say("Hello Make Tech Easier!") fmt.Println("Sleep a little...") time.Sleep(100 * time.Millisecond) }

Die Funktion say() führt lediglich eine einfache 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. Dies bedeutet, dass die Funktion als separate Aufgabe ausgeführt wird. Der Rest der Funktion main() schläft dann nur ein wenig, um der Goroutine Zeit zum Abschluss zu geben.

Die Ausgabe wird Sie vielleicht überraschen:

Wie Sie sehen können, wird die say()-Funktion als Goroutine ausgeführt und während sie eingerichtet wird, läuft der Rest der main()-Funktion weiter, indem sie „Sleep a little“ ausgibt … und dann „schlafen“ geht. Zu diesem Zeitpunkt ist die Goroutine aktiv und beginnt, den String fünfmal auszudrucken. Schließlich endet das Programm, sobald das Timeout-Limit erreicht ist.

Kanäle

Goroutinen können über Kanäle kommunizieren. Ein Kanal öffnet eine Kommunikationslinie zwischen zwei verschiedenen Teilen eines Go-Programms. Normalerweise wird eine Funktion als Goroutine aufgerufen und wenn sie Daten zurücksenden muss (z. B. von einem Netzwerkvorgang), kann sie einen Kanal verwenden, um diese Daten weiterzuleiten. Wenn ein anderer Teil des Go-Programms auf diese Daten wartet, bleibt er im Ruhezustand, bis die Daten bereit sind. Kanäle werden mit der Funktion make() erstellt und können als Parameter an Goroutinen übergeben werden.

Betrachten Sie diesen Code:

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

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

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

Abschluss

Die Go-Sprache hat sich in den letzten Jahren erheblich weiterentwickelt. Wenn Sie sich in letzter Zeit noch nicht damit befasst haben, ist jetzt vielleicht ein guter Zeitpunkt dafür!

Index
  1. Die Kraft der Parallelität
  2. Kanäle
  3. Abschluss

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Go up