xvgmag

Skriva ditt första samtidiga Go-program på Ubuntu


Skriva ditt första samtidiga Go-program på Ubuntu / Linux

Googles Go-programmeringsspråk har funnits sedan 2009 och i 2012 nådde språket sin officiella v1.0-status. Under de mellanliggande åren har mycket förändrats, inklusive hur språket är installerat. I sin spädbarn fanns det inga officiella binära utdelningar och du måste antingen bygga Go från källkoden, vilket var den rekommenderade metoden eftersom språket ändrade ofta eller använd en förbyggd paket för din Linux-distribution. Därefter var Windows-support begränsat, vilket var stöd för andra CPU-arkitekturer än Intel.

Sakerna har förbättrats väldigt sedan dess. För Linux finns det två enkla sätt att installera Go. Ladda ner den officiella Linux-binära byggningen från Go-nedladdningsidan eller välj en förbyggd paket för din Linux-distribution. Det enklaste sättet att installera Go on Ubuntu är att använda apt-get:

sudo apt-get install golang

När Go är installerat kan du börja utveckla program. Ett av de enklaste Go-programmen är det klassiska "Hello World!" -Programmet. Använd en textredigerare, skapa en fil som heter "hellomte.go"Med följande korta Go-kod:

Paket Huvud Import "Fmt" Func Main () {fmt.Println ("Hej Gör Tech Mindre!")}

Sedan v1.0 of Go har behovet av individuella kompilera och länkkommandon tagits bort och den gamla 8g och 8l kommandon har ersatts med kommando.

Att springa hellomte.go, öppna en terminal och ändra katalog till mappen som innehåller källkodsfilen och skriv sedan:

gå köra hellomte.go

Detta kommer att kompilera och köra Go-programmet, men det kommer inte att producera en körbar binär. För att skapa en binär och kör sedan använd den gå bygga kommando:

gå bygg hellomte.go ./hellomte

Kraften av samtidighet

Ett av de definierande funktionerna i Go-programmeringsspråket är dess stöd för samtidighet som gör att ett program kan fungera med flera uppgifter samtidigt. Parallelism, som liknar samtidighet, tillåter ett program att utföra många uppgifter samtidigt, men samtidighet går ett steg längre genom att det gör det möjligt för dessa separata uppgifter att kommunicera och interagera. Som en följd gör att Go tillåter programmerare att använda en mängd olika samtidiga mönster, inklusive arbetarkollekar, pipelines (där en uppgift händer efter varandra) och synkrona eller asynkrona bakgrundsuppgifter. Grunden för denna samtidighet är goroutine i kombination med kanaler och Go's Välj påstående.

Här är ett enkelt Go-program som skriver ut en sträng flera gånger med en samtidig goroutine:

paketets huvudsakliga import ("fmt" "time") func say (s string) {för i: = 0; jag <5; i ++ {fmt.Println (s)} func main () {go say ("Hej gör Tech enklare!") fmt.Println ("Sova lite ...") time.Sleep (100 * time.Millisecond)}

Funktionen säga() utför bara en enkel slinga för att skriva ut strängen (parameter s) fem gånger. Det intressanta är hur den funktionen heter. Snarare än att bara ringa säg ("Hej gör Tech enklare!") sökordet är placerad framför funktionssamtalet. Det innebär att funktionen kommer att köras som en separat uppgift. Resten av main () funktionen sover bara lite för att ge tid åt goroutine att slutföra.

Utgången kan överraska dig:

Som du kan se säga() funktionen körs som en goroutine och medan det installeras resten av main () funktionen fortsätter, utskrift Sov lite ... och sedan går och lägger sig. Då då goroutine är aktiv och börjar skriva ut strängen fem gånger. Slutligen slutar programmet en gång tidsgränsen som uppnåtts.

kanaler

goroutines kan kommunicera med kanaler. En kanal öppnar en kommunikationslinje mellan två olika delar av ett Go-program. Vanligtvis kallas en funktion som en goroutine och om det behövs att skicka tillbaka data (säg från en nätverksoperation) kan den använda en kanal för att vidarebefordra denna data. Om en annan del av Go-programmet väntar på den data kommer den att sova tills datan är klar. Kanaler skapas med hjälp av göra() funktionen och de kan överföras som parametrar till goroutines.

Tänk på den här koden:

paketets huvudsakliga import ("fmt") func say (s sträng, c chan int) {var jag int för i = 0; jag <5; i ++ {fmt.Println (s)} c <- i} func main () {c: = gör (chan int) go say ("Hej gör det enklare!", c) sts: = <- c fmt.Println m)}

De säga() funktionen är väldigt lik det första exemplet med undantag för att den andra parametern är en kanal och att efter att ha skrivit ut strängen kommer antalet iterationer att skickas ner via kanalen via c <- i kodlinje.

Huvudfunktionen skapar en kanal, startar säga() fungera som en goroutine och väntar sedan på att data kommer ner i kanalen, m: = <- c innan du skriver ut resultatet.

Slutsats

Go-språket har utvecklats betydligt under de senaste åren, om du inte har tittat på det nyligen är det kanske nu bra!