Introduksjon til samtidighet i Go

Samtidighet er et avgjørende aspekt ved moderne programvareutvikling ettersom det gjør det mulig for programmer å effektivt håndtere flere oppgaver samtidig. Du kan skrive programmer som utfører ulike operasjoner som fører til forbedret ytelse, respons og ressursutnyttelse.

Samtidighet er en av funksjonene som er ansvarlige for Gos raske bruk. Gos innebygde støtte for samtidig programmering anses som enkel samtidig som den hjelper til med å unngå vanlige fallgruver som løpsforhold og vranglås.

Samtidighet i Go

Go gir robust støtte for samtidighet gjennom ulike mekanismer, alle tilgjengelige i standardbiblioteket og verktøykjeden. Gå programmer oppnå samtidighet gjennom goroutiner og kanaler.

Goroutiner er lette, uavhengig utførende funksjoner som kjører samtidig med andre gorutiner innenfor samme adresserom. Goroutiner lar flere oppgaver utvikle seg samtidig uten eksplisitt trådbehandling. Goroutiner er lettere enn operativsystemtråder og Go kan effektivt kjøre tusenvis eller til og med millioner av gorutiner samtidig.

Kanaler er kommunikasjonsmekanismen for koordinering og datadeling mellom goroutiner. En kanal er en maskinskrevet kanal som lar goroutiner sende og motta verdier. Kanaler gir synkronisering for å sikre sikker datadeling mellom goroutiner samtidig som de forhindrer løpsforhold og andre vanlige samtidighetsproblemer.

Ved å kombinere goroutiner og kanaler gir Go en kraftig og enkel samtidighetsmodell som forenkler utviklingen av samtidige programmer samtidig som sikkerhet og effektivitet opprettholdes. Disse mekanismene lar deg enkelt bruke flerkjerneprosessorer og bygge svært skalerbare og responsive applikasjoner.

Slik bruker du Goroutines for samtidig kodeutførelse

Go runtime administrerer goroutiner. Goroutiner har sin stabel, slik at de kan ha et lett fotavtrykk med en innledende stabelstørrelse på noen få kilobyte.

Goroutiner multiplekses til flere OS-tråder av Go-runtime. Go runtime-planleggeren planlegger dem på tilgjengelige tråder ved å effektivt distribuere arbeidsmengden, slik at flere goroutiner kan kjøres samtidig på færre OS-tråder.

Det er enkelt å lage goroutiner. Du vil bruke gå nøkkelord etterfulgt av et funksjonskall for å deklarere goroutiner.

funchoved-() {
gå funksjon1() // Opprett og utfør goroutine for funksjon1
gå funksjon2() // Opprett og utfør goroutine for funksjon2
// ...
}
funcfunksjon 1() {
// Kode for funksjon1
}
funcfunksjon 2() {
// Kode for funksjon2
}

Når programmet påkaller funksjon1() og funksjon2() med gå nøkkelord, kjører Go runtime funksjonene samtidig som goroutiner.

Her er et eksempel på bruk av en goroutine som skriver ut tekst til konsollen:

pakke hoved-
import (
"fmt"
"tid"
)
funcprintTekst() {
til jeg := 1; jeg <= 5; i++ {
 fmt. Println("Skriver ut tekst", Jeg)
 tid. Sove(1 * tid. Sekund)
 }
}
funchoved-() {
gå printText() // Start en goroutine for å utføre printText-funksjonen samtidig
// Utfør andre oppgaver i hovedgoroutinen
til jeg := 1; jeg <= 5; i++ {
 fmt. Println("Utføre andre oppgaver", Jeg)
 tid. Sove(500 * tid. millisekund)
 }
// Vent til goroutinen er ferdig
 tid. Sove(6 * tid. Sekund)
}

De printTekst funksjonen skriver gjentatte ganger ut tekst til konsollen med en til loop som kjører fem ganger etter en forsinkelse på ett sekund mellom hver setning med tidspakken.

De hoved- funksjon starter en goroutine ved å ringe gå printTekst, som lanserer printTekst fungere som en separat samtidig goroutine som lar funksjonen utføres samtidig med resten av koden i hoved- funksjon.

Til slutt, for å sikre at programmet ikke avsluttes før printTekst goroutine avslutter, den tid. Sove funksjonen setter hovedgoroutinen på pause i seks sekunder. I virkelige scenarier vil du bruke synkroniseringsmekanismer som kanaler eller ventegrupper for å koordinere utførelsen av goroutiner.

Bruke kanaler for kommunikasjon og synkronisering

Goroutiner har innebygd støtte for kommunikasjon og synkronisering gjennom kanaler, noe som gjør skriving samtidig kode enklere enn tradisjonelle tråder, som ofte krever manuelle synkroniseringsmekanismer som låser og semaforer.

Du kan tenke på kanaler som rørledninger for dataflyt mellom goroutiner. En goroutine kan sende en verdi inn i kanalen, og en annen goroutine kan motta den verdien fra kanalen. Denne mekanismen sikrer at datautveksling er trygg og synkronisert.

Du vil bruke operatør for å sende og motta data gjennom kanaler.

Her er et eksempel som viser den grunnleggende bruken av kanaler for kommunikasjon mellom to goroutiner:

funchoved-() {
// Lag en ubufret kanal av typen streng
 ch := gjøre(chanstreng)
// Goroutine 1: Sender en melding inn i kanalen
gåfunc() {
 ch "Hei, Channel!"
 }()
// Goroutine 2: Mottar meldingen fra kanalen
 melding :=  fmt. Println (msg) // Utgang: Hei, kanal!
}

Kanalen i hoved- funksjonen er en ubufret kanal kalt kap opprettet med gjøre() funksjon. Den første goroutinen sender meldingen "Hei, kanal!" inn i kanalen ved hjelp av operatør, og den andre goroutinen mottar meldingen fra kanalen med samme operatør. Til slutt, den hoved- funksjonen skriver ut den mottatte meldingen til konsollen.

Du kan definere maskinskrevne kanaler. Du spesifiserer kanaltypen når du oppretter. Her er et eksempel som viser bruken av forskjellige kanaltyper:

funchoved-() {
// Ubufret kanal
 ch1 := gjøre(chanint)
// Bufret kanal med en kapasitet på 3
 ch2 := gjøre(chanstreng, 3)
// Sende og motta verdier fra kanaler
 ch1 42// Send en verdi inn i ch1
 verdi1 := // Motta en verdi fra ch1
 ch2 "Hallo"// Send en verdi inn i ch2
 verdi2 := // Motta en verdi fra ch2
}

De hoved- funksjonen lager to kanaler: ch1 er en ubufret heltallskanal, while ch2 er en bufret strengkanal med en kapasitet på 3. Du kan sende og motta verdier til og fra disse kanalene ved å bruke operatør (verdiene må være av den angitte typen).

Du kan bruke kanaler som synkroniseringsmekanismer for å koordinere utførelse av goroutine ved å utnytte blokkeringsnaturen til kanaloperasjoner.

funchoved-() {
 ch := gjøre(chanbool)
gåfunc() {
 fmt. Println("Goroutine 1")
 ch ekte// Signal ferdigstillelse
 }()
gåfunc() {
 // Vent på fullføringssignalet fra Goroutine 1
 fmt. Println("Goroutine 2")
 }()
 // Vent på fullføringssignal fra Goroutine 2
 fmt. Println("Hovedgoroutine")
}

De kap kanalen er boolsk. To goroutiner kjører samtidig i hoved- funksjon. Goroutine 1 signaliserer at den er fullført ved å sende en ekte verdi inn i kanalen kap. Goroutine 2 venter på fullføringssignalet ved å motta en verdi fra kanalen. Til slutt venter hovedgoroutinen på fullføringssignalet fra goroutine to.

Du kan bygge nettapper i Go With Gin

Du kan bygge høyytende nettapper i Go with Gin mens du utnytter Gos samtidighetsfunksjoner.

Du kan bruke Gin til å håndtere HTTP-ruting og mellomvare effektivt. Dra nytte av Gos innebygde samtidighetsstøtte ved å bruke goroutiner og kanaler for oppgaver som databasespørringer, API-anrop eller andre blokkeringsoperasjoner.