Siit saate teada, kuidas gorutiinid ja kanalid võimaldavad teie Go programmides tõhusat samaaegsust.

Samaaegsus on kaasaegse tarkvaraarenduse ülioluline aspekt, kuna see võimaldab programmidel tõhusalt toime tulla mitme ülesandega samaaegselt. Saate kirjutada programme, mis täidavad erinevaid toiminguid, mis parandavad jõudlust, reageerimisvõimet ja ressursside kasutamist.

Samaaegsus on üks funktsioone, mis vastutavad Go kiire kasutuselevõtu eest. Go sisseehitatud tuge samaaegseks programmeerimiseks peetakse lihtsaks, aidates samal ajal vältida tavalisi lõkse, nagu võistlustingimused ja ummikseisud.

Samaaegsus Go-s

Go pakub samaaegsuse tugevat tuge erinevate mehhanismide kaudu, mis kõik on saadaval selle standardses teegis ja tööriistaahelas. Mine programmidesse saavutada samaaegsust gorutiinide ja kanalite kaudu.

Gorutiinid on kerged, iseseisvalt täitvad funktsioonid, mis töötavad samaaegselt teiste samas aadressiruumis olevate gorutiinidega. Gorutiinid võimaldavad mitme ülesande samaaegset edenemist ilma selgesõnalise lõimehalduseta. Gorutiinid on operatsioonisüsteemi lõimedest kergemad ja Go suudab tõhusalt käitada tuhandeid või isegi miljoneid gorutiine samaaegselt.

instagram viewer

Kanalid on suhtlusmehhanismiks koordineerimiseks ja andmete jagamiseks gorutiinide vahel. Kanal on tüüpiline kanal, mis võimaldab gorutiinidel väärtusi saata ja vastu võtta. Kanalid pakuvad sünkroonimist, et tagada turvaline andmete jagamine gorutiinide vahel, vältides samal ajal võistlustingimusi ja muid levinud samaaegsusprobleeme.

Kombineerides gorutine ja kanaleid, pakub Go võimsat ja otsest samaaegsusmudelit, mis lihtsustab samaaegsete programmide arendamist, säilitades samas ohutuse ja tõhususe. Need mehhanismid võimaldavad teil hõlpsasti kasutada mitmetuumalised protsessorid ning luua väga skaleeritavaid ja tundlike rakendusi.

Kuidas kasutada Goroutines'i samaaegseks koodi täitmiseks

Go käitusaeg haldab gorutiine. Goroutine'il on oma pinu, mis võimaldab neil olla kerge jalajälg, mille algne virna suurus on mõne kilobaidi.

Go käitusaeg multipleksib goroutiinid mitmele OS-i lõimele. Go käitusaegne planeerija ajastab need saadaolevatele lõimedele, jaotades töökoormuse tõhusalt, võimaldades samaaegselt käivitada mitut gorutiini vähemal OS-lõimel.

Gorutiinide loomine on lihtne. Sa kasutad mine märksõna, millele järgneb funktsioonikutse gorutiinide deklareerimiseks.

funcpeamine() {
mine funktsioon1() // Funktsiooni 1 gorutiin loomine ja käivitamine
mine funktsioon2() // Funktsiooni 2 gorutiin loomine ja käivitamine
// ...
}


funcfunktsioon 1() {
// Funktsiooni1 kood
}
funcfunktsioon 2() {
// Funktsiooni2 kood
}

Kui programm kutsub funktsioon1() ja funktsioon2() koos mine märksõna, käivitab Go käitusaeg funktsioone samaaegselt gorutiinidena.

Siin on näide konsooli teksti prinditava gorutiini kasutamise kohta:

pakett peamine
importida (
"fmt"
"aeg"
)


funcprintTekst() {
jaoks mina := 1; mina <= 5; i++ {
 fmt. Println("Trüki teksti", i)
 aega. Magama (1 *aeg. Teine)
 }
}


funcpeamine() {
mine printText() // Käivitage gorutiini funktsiooni printText samaaegseks täitmiseks


// Täitke põhigorutiini muid ülesandeid
jaoks mina := 1; mina <= 5; i++ {
 fmt. Println("Teiste ülesannete täitmine", i)
 aega. Magama (500 *aeg. Millisekund)
 }
// Oodake, kuni gorutiin lõpeb
 aega. Magama (6 *aeg. Teine)
}

The printTekst funktsioon prindib korduvalt konsooli teksti a-ga jaoks tsükkel, mis jookseb viis korda pärast ühesekundilist viivitust iga lause vahel ajapakett.

The peamine funktsioon käivitab helistades gorutiini mine prindiTekst, mis käivitab printTekst funktsioon eraldi samaaegse gorutiinina, mis võimaldab funktsioonil käitada samaaegselt ülejäänud koodiga peamine funktsiooni.

Lõpuks tagamaks, et programm ei väljuks enne printTekst gorotiin lõpetab, aega. Magama funktsioon peatab põhigorutiini kuueks sekundiks. Reaalse maailma stsenaariumide korral kasutaksite sünkroonimismehhanisme, nagu kanalid või ooterühmad, et koordineerida gorutiinide täitmist.

Kanalite kasutamine suhtluseks ja sünkroonimiseks

Goroutines'il on sisseehitatud tugi suhtluseks ja kanalite kaudu sünkroonimiseks, muutes kirjutamise samaaegseks kood lihtsam kui traditsioonilised lõimed, mis nõuavad sageli käsitsi sünkroonimismehhanisme, nagu lukud ja semaforid.

Võite mõelda kanalitest kui andmevoo torujuhtmetest gorutiinide vahel. Üks gorutiin võib saata kanalisse väärtuse ja teine ​​gorutiin saab selle väärtuse kanalilt vastu võtta. See mehhanism tagab, et andmevahetus on ohutu ja sünkroniseeritud.

Sa kasutad operaator kanalite kaudu andmete saatmiseks ja vastuvõtmiseks.

Siin on näide, mis demonstreerib kanalite põhikasutust kahe gorutiini vaheliseks suhtluseks:

funcpeamine() {
// Looge stringi tüüpi puhverdamata kanal
 ch := tegema(chanstring)
// Gorutine 1: saadab kanalile sõnumi
minefunc() {
 ch "Tere, kanal!"
 }()
// Gorutine 2: võtab teate kanalilt vastu
 sõnum :=  fmt. Println (sõnum) // Väljund: Tere, kanal!
}

Kanal asukohas peamine funktsioon on puhverdamata kanal nimega ptk loodud koos tegema() funktsiooni. Esimene gorotiin saadab sõnumi "Tere, Kanal!" kanalisse, kasutades nuppu operaator ja teine ​​gorutiin saab sama operaatorit kasutades sõnumi kanalilt. Lõpuks, peamine funktsioon prindib vastuvõetud sõnumi konsooli.

Saate määrata trükitud kanaleid. Kanali tüübi määrate loomisel. Siin on näide, mis demonstreerib erinevate kanalitüüpide kasutamist.

funcpeamine() {
// Puhverdamata kanal
 ch1 := tegema(chanint)
// Puhverdatud kanal mahutavusega 3
 ch2 := tegema(chanstring, 3)


// Väärtuste saatmine ja vastuvõtmine kanalitest
 ch1 42// Väärtuse saatmine ch1-sse
 väärtus1 := // Väärtuse saamine ch1-st
 ch2 "Tere"// Saada väärtus ch2-sse
 väärtus2 := // Väärtuse saamine ch2-st
}

The peamine funktsioon loob kaks kanalit: ch1 on puhverdamata täisarvu kanal, while ch2 on puhverdatud stringkanal mahutavusega 3. Saate nendesse kanalitesse väärtusi saata ja vastu võtta, kasutades operaator (väärtused peavad olema määratud tüüpi).

Saate kasutada kanaleid sünkroonimismehhanismidena gorutiini täitmise koordineerimiseks, võimendades kanalitoimingute blokeerivat olemust.

funcpeamine() {
 ch := tegema(chanbool)
minefunc() {
 fmt. Println("Gorutine 1")
 ch tõsi// Signaali valmimine
 }()


minefunc() {
 // Oodake Goroutine 1 lõpetamissignaali
 fmt. Println("Gorutiin 2")
 }()
 // Oodake Goroutine 2 lõpetamissignaali
 fmt. Println("Peamine gorutiin")
}

The ptk kanal on tõeväärtus. Kaks gorutiini jooksevad samaaegselt peamine funktsiooni. Goroutine 1 annab selle lõppemisest märku, saates a tõsi väärtus kanalisse ptk. Goroutine 2 ootab lõpusignaali, saades kanalilt väärtuse. Lõpuks ootab põhigorutiini lõpetamissignaali gorutiinilt kaks.

Saate koos Giniga luua veebirakendusi

Saate luua suure jõudlusega veebirakendusi rakenduses Go with Gin, kasutades samal ajal Go samaaegsusfunktsioone.

Saate kasutada Gini HTTP-marsruutimise ja vahevara tõhusaks haldamiseks. Kasutage Go sisseehitatud samaaegsuse tuge, kasutades gorutine ja kanaleid selliste ülesannete jaoks nagu andmebaasipäringud, API-kutsed või muud blokeerimistoimingud.