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

Googles Go-programmeringssprog har eksisteret siden 2009, og i 2012 nåede sproget sin officielle v1.0-status. I de mellemliggende år har meget ændret sig, herunder hvordan sproget er installeret. Tilbage i sin barndom var der ikke nogen officielle binære distributioner, og du måtte enten bygge Go fra kildekoden, hvilket var den anbefalede metode, da sproget ændrede sig ofte eller bruge en færdigbygget pakke til din Linux-distribution. Derefter var Windows-support begrænset som støtte til andre CPU-arkitekturer end Intel.

Ting er blevet bedre siden da. For Linux er der to nemme måder at installere Go på. Download den officielle Linux-binære build fra Go downloads-siden eller vælg en præ-bygget pakke til din Linux distribution. Den nemmeste måde at installere Go on Ubuntu på er at bruge apt-get :

 sudo apt-get installer golang

Når Go er installeret, kan du begynde at udvikle programmer. Et af de enkleste Go-programmer er det klassiske "Hello World!" -program. Brug en teksteditor til at oprette en fil kaldet " hellomte.go " med følgende korte Go-kode:

 pakke vigtigste import "fmt" func main () {fmt.Println ("Hej gør Tech lettere!")}

Siden v1.0 of Go er behovet for individuelle kompilerings- og linkkommandoer blevet fjernet, og de gamle 8g og 8l kommandoer er blevet erstattet med go kommandoen.

Hvis du vil køre hellomte.go, skal du åbne en terminal og ændre mappe til mappen, som indeholder kildekoden filen, og skriv derefter:

 gå løb hellomte.go

Dette vil kompilere og køre Go-programmet, men det vil ikke producere en eksekverbar binær. For at oprette en binær og derefter køre den brug kommandoen go build :

 gå op til hellomte.go ./hellomte

Effekten af samtidighed

Et af de grundlæggende funktioner i Go-programmeringssproget er dets støtte til samtidighed, som gør det muligt for et program at arbejde med flere opgaver på én gang. Parallelisme, som ligner samtidighed, giver et program mulighed for at udføre mange opgaver samtidigt, men samtidighed går et skridt videre, idet det giver disse separate opgaver mulighed for at kommunikere og interagere. Som følge heraf tillader Go, at programmører bruger en lang række forskellige samtidige designs, herunder arbejderpuljer, rørledninger (hvor en opgave sker efter den anden) og synkron eller asynkron baggrundsopgaver. Grundlaget for denne samtidighed er goroutine kombineret med channels og Go's select statement.

Her er et simpelt Go-program, der udskriver en streng flere gange ved hjælp af en samtidig goroutin:

 pakke vigtigste import ("fmt" "tid") func sige (s streng) {for i: = 0; jeg <5; i ++ {fmt.Println (s)} func main () {go say ("Hej gør det lettere!") fmt.Println ("Sleep a little ...") time.Sleep (100 * time.Millisecond)}

Funktionen say() udfører bare en simpel loop for at udskrive strengen (parameter s ) fem gange. Det interessante er, hvordan denne funktion kaldes. I stedet for bare at ringe say("Hello Make Tech Easier!") søgeordet placeret foran funktionen. Det betyder, at funktionen vil blive kørt som en separat opgave. Resten af main() fungerer så bare lidt for at give tid til goroutine til at fuldføre.

Udgangen kan overraske dig:

Som du kan se, er say() -funktionen kørt som en goroutine og mens den er i gang, fortsætter resten af main() -funktionen, udskriver Sleep a little... og derefter går i seng. Dengang er goroutine aktiv og begynder at udskrive strengen fem gange. Endelig slutter programmet, når tidsgrænsen er nået.

Kanaler

goroutines kan kommunikere ved hjælp af kanaler. En kanal åbner en kommunikationslinje mellem to forskellige dele af et Go-program. Typisk kaldes en funktion som en goroutine og hvis den skal sende data tilbage (sige fra en netværksoperation), kan den bruge en kanal til at videregive disse data. Hvis en anden del af Go-programmet venter på disse data, vil det sove, indtil dataene er klare. Kanaler oprettes ved hjælp af funktionen make() og de kan overføres som parametre til goroutines .

Overvej denne kode:

 pakke vigtigste import ("fmt") func sige (s streng, c chan int) {var jeg int for i = 0; jeg <5; I ++ {fmt.Println (s)} c <- i} func main () {c: = gør (chan int) go say ("Hej gør det lettere!", c) sts: = <- c fmt.Println m)}

Funktionen say() svarer meget til det første eksempel med den undtagelse, at den anden parameter er en kanal, og at antallet af iterationer efter udskrivning af strengen sendes ned via kanalen via c <- i linjen kode.

Hovedfunktionen skaber en kanal, starter say() -funktionen som en goroutine og venter derefter på, at dataene kommer ned i kanalen, sts := <- c før resultatet udskrives.