xvgmag

Schreiben Sie Ihr erstes Concurrent Go-Programm auf Ubuntu


Schreiben Sie Ihr erstes Concurrent Go-Programm auf Ubuntu / Linux

Googles Go-Programmiersprache gibt es seit 2009 und im Jahr 2012 erreichte die Sprache ihren offiziellen v1.0-Status. In diesen Jahren hat sich viel geändert, auch was die Installation der Sprache betrifft. Zurück in den Kinderschuhen gab es keine offiziellen Binärdistributionen und Sie mussten entweder Go 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 begrenzt, ebenso wie die Unterstützung anderer CPU-Architekturen als Intel.

Die Dinge haben sich seitdem stark verbessert. Für Linux gibt es zwei einfache Möglichkeiten, Go zu installieren. Laden Sie den offiziellen Linux-Binary-Build von der Go-Download-Seite herunter oder entscheiden Sie sich für ein vorgefertigtes Paket für Ihre Linux-Distribution. Der einfachste Weg, um Go on Ubuntu zu installieren, ist zu verwenden apt-get:

sudo apt-get installieren Sie golang

Sobald Go installiert ist, können Sie damit beginnen, Programme zu entwickeln. Eines der einfachsten Go-Programme ist das klassische Programm "Hello World!". Erstellen Sie mit einem Texteditor eine Datei mit dem Namen "hellomte.go"Mit dem folgenden kurzen Go-Code:

package main import "fmt" func main () {fmt.Println ("Hallo Mach Tech Easier!")}

Seit v1.0 von Go wurde die Notwendigkeit für einzelne Kompilier- und Link-Befehle entfernt und der alte 8g und 8l Befehle wurden durch die ersetzt gehen Befehl.

Zu rennen hellomte.goÖffnen Sie ein Terminal und wechseln Sie in den Ordner, der die Quellcodedatei enthält. Geben Sie dann Folgendes ein:

gehen Sie laufen hellomte.go

Dadurch wird das Go-Programm kompiliert und ausgeführt, aber es wird keine ausführbare Binärdatei erzeugt. Um eine Binärdatei zu erstellen und sie dann auszuführen, verwenden Sie die gehe bauen Befehl:

gehe bauen hellomte.go ./hellomte

Die Macht der Parallelität

Eines der definierenden Merkmale der Go-Programmiersprache ist ihre Unterstützung für 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 es diesen separaten Aufgaben ermöglicht, zu kommunizieren und zu interagieren. Als Ergebnis ermöglicht Go Programmierern die Verwendung einer ganzen Reihe unterschiedlicher Concurrent-Designs, einschließlich Worker-Pools, Pipelines (bei denen eine Task nach der anderen auftritt) und synchroner oder asynchroner Hintergrund-Tasks. Die Grundlage dieser Nebenläufigkeit ist die Goroutine zusammen mit Kanäle und Go's wählen Erklärung.

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

Paket Hauptimport ("fmt" "time") func say (s string) {für i: = 0; i <5; i ++ {fmt.Println (s)}} func main () {go say ("Hallo Make Tech Easier!") fmt.Println ("Schlaf ein wenig ...") time.Sleep (100 * time.Millisecond)}

Die Funktion sagen() führt einfach eine einfache Schleife aus, um die Zeichenkette (Parameter s) fünf Mal. Das interessante ist, wie diese Funktion aufgerufen wird. Anstatt nur anzurufen sag ("Hallo mach Tech einfacher!") das Schlüsselwort gehen wird vor dem Funktionsaufruf platziert. Dies bedeutet, dass die Funktion als separate Aufgabe ausgeführt wird. Der Rest des Main() Funktion schläft dann nur ein wenig, um Zeit für die Goroutine fertigstellen.

Die Ausgabe kann Sie überraschen:

Wie Sie sehen können sagen() Funktion wird als a ausgeführt Goroutine und während es eingerichtet wird, der Rest der Main() Funktion wird fortgesetzt und ausgedruckt Schlaf ein wenig ... und dann schlafen gehen. Bis dahin Goroutine ist aktiv und beginnt, die Zeichenfolge fünf Mal auszudrucken. Schließlich endet das Programm, sobald das Zeitlimit erreicht ist.

Kanäle

Gorousinen kann über Kanäle kommunizieren. Ein Kanal öffnet eine Kommunikationslinie zwischen zwei verschiedenen Teilen eines Go-Programms. Normalerweise wird eine Funktion als a aufgerufen Goroutine und wenn es Daten zurücksenden muss (etwa von einer Netzwerkoperation), kann es einen Kanal verwenden, um diese Daten weiterzuleiten. Wenn ein anderer Teil des Go-Programms auf diese Daten wartet, wird er in den Ruhezustand versetzt, bis die Daten bereit sind. Kanäle werden mit dem erstellt machen() Funktion und sie können als Parameter übergeben werden Gorousinen.

Betrachten Sie diesen Code:

Paket Hauptimport ("fmt") func say (s Zeichenfolge, c chan int) {var i int für i = 0; i <5; i ++ {fmt.Println (s)} c <- i} func main () {c: = make (chan int) geh sagen ("Hallo Mach Tech Easier!", c) sts: = <- c fmt.Println ( M)}

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

Die Hauptfunktion erstellt einen Kanal, startet den sagen() Funktion als a Goroutine und wartet dann darauf, dass die Daten in den Kanal kommen, M: = <- c bevor das Ergebnis gedruckt wird.

Fazit

Die Go-Sprache hat sich in den letzten Jahren deutlich weiterentwickelt, wenn Sie es in letzter Zeit nicht angeschaut haben, ist vielleicht jetzt eine gute Zeit!