xvgmag

Het schrijven van uw eerste gelijktijdige Go-programma op Ubuntu


Het schrijven van uw eerste gelijktijdige Go-programma op Ubuntu / Linux

Google's Go-programmeertaal bestaat al sinds 2009 en in 2012 bereikte de taal zijn officiële v1.0-status. In die tussenliggende jaren is er veel veranderd, inclusief hoe de taal is geïnstalleerd. Terug in de kinderschoenen waren er geen officiële binaire distributies en moest je Go uit de broncode bouwen, wat de aanbevolen methode was omdat de taal vaak aan het veranderen was, of een vooraf gebouwd pakket voor je Linux-distributie gebruikte. Toen was Windows-ondersteuning beperkt, net als ondersteuning voor andere CPU-architecturen dan Intel.

Sindsdien is het enorm verbeterd. Voor Linux zijn er twee eenvoudige manieren om Go te installeren. Download de officiële Linux-binaire build van de Go-downloadpagina of kies voor een vooraf gebouwd pakket voor je Linux-distributie. De gemakkelijkste manier om Go on Ubuntu te installeren is om te gebruiken apt-get:

sudo apt-get install golang

Nadat Go is geïnstalleerd, kunt u beginnen met het ontwikkelen van programma's. Een van de eenvoudigste Go-programma's is het klassieke "Hello World!" -Programma. Gebruik een teksteditor om een ​​bestand met de naam "hellomte.go"Met de volgende korte Go-code:

pakket main import "fmt" func main () {fmt.Println ("Hello Make Tech Makkelijker!")}

Sinds v1.0 van Go is de behoefte aan individuele compileer- en koppelingscommando's verwijderd en de oude 8g en 8l commando's zijn vervangen door de Gaan opdracht.

Rennen hellomte.go, open een terminal en wijzig de map in de map die het broncodebestand bevat, typ vervolgens:

go running hellomte.go

Hiermee wordt het Go-programma gecompileerd en uitgevoerd, maar er wordt geen uitvoerbaar binair bestand geproduceerd. Om een ​​binair bestand te maken en het vervolgens uit te voeren, gebruikt u de ga bouwen opdracht:

ga bouwen hellomte.go ./hellomte

De kracht van concurrency

Een van de bepalende kenmerken van de Go-programmeertaal is de ondersteuning voor concurrency waarmee een programma met meerdere taken tegelijkertijd kan werken. Parallellisme, vergelijkbaar met concurrency, stelt een programma in staat om veel taken tegelijkertijd uit te voeren, maar concurrency gaat nog een stap verder omdat het deze afzonderlijke taken in staat stelt om te communiceren en te communiceren. Als gevolg hiervan stelt Go programmeurs in staat om een ​​hele reeks verschillende gelijktijdige ontwerpen te gebruiken, inclusief werkstroompools, pijplijnen (waarbij de ene taak na de andere plaatsvindt) en synchrone of asynchrone achtergrondtaken. De basis van deze concurrency is de goroutine gekoppeld aan kanalen en Go's kiezen uitspraak.

Hier is een eenvoudig Go-programma dat meerdere keren een reeks afdrukt met behulp van een gelijktijdige goroutine:

pakket main import ("fmt" "time") func say (s string) {for i: = 0; i <5; i ++ {fmt.Println (s)}} func main () {go say ("Hello Make Tech Makkelijker!") fmt.Println ("Slaap een beetje ...") time.Sleep (100 * time.Millisecond)}

De functie zeggen() voert eenvoudig een lus uit om de reeks af te drukken (parameter s) vijf keer. Het interessante is hoe die functie wordt genoemd. In plaats van gewoon bellen zeg ("Hello Make Tech Makkelijker!") het sleutelwoord Gaan wordt vóór de functieaanroep geplaatst. Dit betekent dat de functie als een afzonderlijke taak wordt uitgevoerd. De rest van de hoofd() functie dan gewoon een beetje slaapt om tijd te geven voor de goroutine vervolledigen.

De uitvoer kan je verrassen:

Zoals je kunt zien zeggen() functie wordt uitgevoerd als een goroutine en terwijl het wordt opgezet, de rest van de hoofd() functie gaat door, wordt afgedrukt Slaap een beetje ... en dan gaan slapen. Tegen die tijd het goroutine is actief en begint de reeks vijf keer af te drukken. Uiteindelijk eindigt het programma zodra de time-outlimiet is bereikt.

kanalen

goroutines kan communiceren via kanalen. Een kanaal opent een communicatielijn tussen twee verschillende delen van een Go-programma. Meestal wordt een functie genoemd als een goroutine en als het gegevens moet terugsturen (bijvoorbeeld van een netwerkbewerking), kan het een kanaal gebruiken om die gegevens door te geven. Als een ander deel van het Go-programma op die gegevens wacht, slaapt het totdat de gegevens gereed zijn. Kanalen worden gemaakt met behulp van de maken() functie en ze kunnen als parameters worden doorgegeven aan goroutines.

Overweeg deze code:

pakket main import ("fmt") func say (s string, c chan int) {var i int voor i = 0; i <5; i ++ {fmt.Println (s)} c <- i} func main () {c: = make (chan int) ga zeggen ("Hello Make Tech Makkelijker!", c) sts: = <- c fmt.Println ( st)}

De zeggen() De functie lijkt erg op het eerste voorbeeld, met de uitzondering dat de tweede parameter een kanaal is en dat na het afdrukken van de tekenreeks het aantal iteraties via het kanaal via het kanaal wordt verzonden. c <- i regel van code.

De hoofdfunctie creëert een kanaal, start de zeggen() functioneren als een goroutine en wacht vervolgens tot de gegevens het kanaal verlaten, st: = <- c voordat u het resultaat afdrukt.

Conclusie

De Go-taal is de laatste paar jaar behoorlijk gegroeid, als je er recent niet naar hebt gekeken, is het misschien nu een goed moment!