xvgmag

Skrive ditt første samtidige Go-program på Ubuntu


Skrive ditt første samtidige Go-program på Ubuntu / Linux

Googles Go-programmeringsspråk har eksistert siden 2009, og i 2012 nådde språket sin offisielle v1.0-status. I de mellomliggende årene har mye endret seg, inkludert hvordan språket er installert. Tilbake i sin barndom var det ikke noen offisielle binære distribusjoner, og du måtte enten bygge Go fra kildekoden, som var den anbefalte metoden siden språket endret ofte, eller bruk en forhåndsbygget pakke for Linux-distribusjonen din. Tilbake da var Windows-støtte begrenset, som var støtte for CPU-arkitekturer annet enn Intel.

Ting har forbedret seg langt siden da. For Linux er det to enkle måter å installere Go på. Last ned den offisielle Linux-binære bygningen fra Go-nedlastingssiden, eller velg en forhåndsbygd pakke for Linux-distribusjonen din. Den enkleste måten å installere Go on Ubuntu på er å bruke apt-get:

sudo apt-get installer golang

Når Go er installert, kan du begynne å utvikle programmer. En av de enkleste Go-programmene er det klassiske "Hello World!" -Programmet. Bruk en tekstredigerer, opprett en fil som heter "hellomte.go"Med følgende korte Go-kode:

pakke viktigste importen "fmt" func main () {fmt.Println ("Hei gjør det enklere!")}

Siden v1.0 of Go har behovet for individuelle kompilere og koblingskommandoer blitt fjernet, og den gamle 8G og 8L kommandoer har blitt erstattet med kommando.

Å løpe hellomte.go, åpne en terminal og endre katalogen til mappen som inneholder kildekoden filen, og skriv deretter inn:

gå løp hellomte.go

Dette vil kompilere og kjøre Go-programmet, men det vil ikke produsere en kjørbar binær. For å lage en binær og deretter kjøre den bruker du gå bygge kommando:

gå bygge hellomte.go ./hellomte

Kraften til samtidighet

En av de definerende funksjonene i Go-programmeringsspråket er dens støtte for samtidighet som gjør det mulig for et program å arbeide med flere oppgaver samtidig. Parallelisme, som ligner samtidighet, tillater et program å utføre mange oppgaver samtidig, men samtidighet går ett skritt videre, fordi det tillater disse separate oppgavene å kommunisere og samhandle. Som et resultat lar Go programmerere å bruke en rekke forskjellige samtidige motiver, inkludert arbeiderspooler, rørledninger (hvor en oppgave skjer etter hverandre) og synkron eller asynkron bakgrunnsoppgaver. Grunnlaget for denne samtidigheten er goroutine kombinert med kanaler og Go er plukke ut uttalelse.

Her er et enkelt Go-program som skriver ut en streng flere ganger ved hjelp av en samtidig goroutine:

pakke viktigste import ("fmt" "tid") func si (s streng) {for i: = 0; jeg <5; i ++ {fmt.Println (s)} func main () {go say ("Hello Make Tech Easier!") fmt.Println ("Sleep a little ...") time.Sleep (100 * time.Millisecond)}

Funksjonen si() utfører bare en enkel sløyfe for å skrive ut strengen (parameter s) fem ganger. Det interessante er hvordan denne funksjonen kalles. Snarere enn bare å ringe si ("Hei gjør det enklere!") søkeordet er plassert foran funksjonssamtalen. Dette betyr at funksjonen vil bli kjørt som en egen oppgave. Resten av hoved() funksjon så sover bare litt for å gi tid til goroutine å fullføre.

Utgangen kan overraske deg:

Som du kan se si() funksjonen drives som en goroutine og mens det blir satt opp resten av hoved() Funksjonen fortsetter, utskrift Sov litt ... og deretter går å sove. Ved da goroutine er aktiv og begynner å skrive ut strengen fem ganger. Endelig avsluttes programmet når tidsgrensen er nådd.

kanaler

goroutines kan kommunisere ved hjelp av kanaler. En kanal åpner en kommunikasjonslinje mellom to forskjellige deler av et Go-program. En funksjon blir vanligvis kalt som en goroutine og hvis den trenger å sende tilbake data (si fra en nettverksoperasjon) kan den bruke en kanal til å passere sammen med dataene. Hvis en annen del av Go-programmet venter på dataene, vil den sove til dataene er klare. Kanaler opprettes ved hjelp av gjøre() funksjon og de kan sendes som parametere til goroutines.

Vurder denne koden:

pakke viktigste import ("fmt") func si (s streng, c chan int) {var jeg int for i = 0; jeg <5; i ++ {fmt.Println (s)} c <- i} func main () {c: = gjør (chan int) go say ("Hei gjør det enklere!", c) sts: = <- c fmt.Println m)}

De si() funksjonen er veldig lik det første eksemplet med unntak av at den andre parameteren er en kanal og at etter utskrift av strengen, vil antall iterasjoner bli sendt ned via kanalen via c <- i linje med kode.

Hovedfunksjonen skaper en kanal, starter si() fungere som en goroutine og venter deretter på at dataene kommer ned i kanalen, m: = <- c før du skriver ut resultatet.

Konklusjon

Go-språket har utviklet seg betydelig de siste årene, hvis du ikke har sett på det nylig, er kanskje det nå en god tid!