xvgmag

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


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

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 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. Ved hjælp af en teksteditor skal du 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 kompilere og linkkommandoer blevet fjernet, og den gamle 8g og 8L kommandoer er blevet erstattet med kommando.

At løbe hellomte.go, åbner en terminal og ændrer mappe til mappen, som indeholder kildekodefilen, 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 bruger den gå opbygge kommando:

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 kanaler og Go er Vælg udmelding.

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 sige() udfører blot en enkel loop for at udskrive strengen (parameter s) fem gange. Det interessante er, hvordan denne funktion kaldes. I stedet for bare at ringe sig ("Hej gør tech lettere!") søgeordet er placeret foran funktionen opkald. Det betyder, at funktionen vil blive kørt som en separat opgave. Resten af main () funktion så sover bare lidt for at give tid til goroutine at færdiggøre.

Udgangen kan overraske dig:

Som du kan se sige() funktionen køres som en goroutine og mens det er ved at blive installeret resten af main () funktionen fortsætter, udskrivning Sov lidt ... og så går i seng. Derefter goroutine er 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 det er nødvendigt at 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 lave() funktion og de kan bestilles 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)}

Det sige() funktionen ligner meget på det første eksempel med den undtagelse, at den anden parameter er en kanal, og at efter udskrivning af strengen bliver antallet af iterationer sendt ned via kanalen via c <- i kode kode.

Hovedfunktionen skaber en kanal, starter den sige() fungere som en goroutine og venter derefter på, at dataene kommer ned i kanalen, m: = <- c før du udskriver resultatet.

Konklusion

Go-sproget har udviklet sig betydeligt i løbet af de sidste par år, hvis du ikke har kigget på det for nylig, er det måske nu et godt tidspunkt!