„Go“ lygiagretumo įvadas

Lygiagretumas yra esminis šiuolaikinės programinės įrangos kūrimo aspektas, nes jis leidžia programoms efektyviai atlikti kelias užduotis vienu metu. Galite rašyti programas, kurios vykdo įvairias operacijas, pagerinančias našumą, reagavimą ir išteklių panaudojimą.

Lygiagretumas yra viena iš funkcijų, atsakingų už greitą „Go“ pritaikymą. „Go“ integruotas lygiagrečio programavimo palaikymas laikomas nesudėtingu ir padeda išvengti įprastų spąstų, pvz., lenktynių sąlygų ir aklavietės.

Lygiagretumas Go

„Go“ užtikrina tvirtą lygiagretumo palaikymą įvairiais mechanizmais, kuriuos galima rasti standartinėje bibliotekoje ir įrankių grandinėje. Eikite į programas pasiekti sutapimą per gorutinas ir kanalus.

Gorutines yra lengvos, nepriklausomai vykdančios funkcijos, kurios veikia kartu su kitomis gorutinomis toje pačioje adresų erdvėje. „Goroutines“ leidžia vienu metu atlikti kelias užduotis be aiškaus gijų valdymo. „Goroutines“ yra lengvesnės nei operacinės sistemos gijos, o „Go“ vienu metu gali efektyviai paleisti tūkstančius ar net milijonus gorutinų.

Kanalai yra komunikacijos mechanizmas, skirtas koordinuoti ir dalytis duomenimis tarp gorutinų. Kanalas yra įvestas kanalas, leidžiantis gorutines siųsti ir gauti vertes. Kanalai teikia sinchronizavimą, kad būtų užtikrintas saugus duomenų dalijimasis tarp gorutinų, kartu užkertant kelią lenktynių sąlygoms ir kitoms įprastoms lygiagretumo problemoms.

Sujungdama gorutinas ir kanalus, „Go“ suteikia galingą ir paprastą lygiagretumo modelį, kuris supaprastina lygiagrečių programų kūrimą išlaikant saugumą ir efektyvumą. Šie mechanizmai leidžia lengvai naudotis kelių branduolių procesoriai ir kurti labai keičiamo dydžio ir reaguojančias programas.

Kaip naudoti „Goroutines“ vienu metu vykdomam kodui

„Go“ vykdymo laikas valdo gorutinas. „Goroutines“ turi savo krūvą, leidžiančią jiems turėti lengvą pėdsaką, o pradinis kelių kilobaitų krūvos dydis.

„Go“ vykdymo laikas „Goroutines“ yra multipleksuojamas į keletą OS gijų. „Go“ vykdymo laiko planavimo priemonė suplanuoja jas į turimas gijas, efektyviai paskirstydama darbo krūvį, leisdama vienu metu vykdyti kelias gorutinas mažesnėse OS gijose.

Sukurti gorutinas paprasta. Jūs naudosite eik raktinis žodis, po kurio seka funkcijos iškvietimas, kad paskelbtų gorutinas.

funcpagrindinis() {
eik funkcija1() // Sukurti ir vykdyti funkcija1 gorutiną
eik funkcija2() // Sukurti ir vykdyti funkcija2 gorutiną
// ...
}
funcfunkcija1() {
// Funkcijos1 kodas
}
funcfunkcija2() {
// Funkcijos2 kodas
}

Kai programa iškviečia funkcija1() ir funkcija2() su eik raktinį žodį, „Go“ vykdymo laikas atlieka funkcijas vienu metu kaip gorutinas.

Štai pavyzdys, kaip naudoti gorutiną, kuri spausdina tekstą į konsolę:

paketą pagrindinis
importuoti (
"fmt"
"laikas"
)
funcspausdintiTekstas() {
dėl aš := 1; aš <= 5; i++ {
 fmt. Println(„Teksto spausdinimas“, i)
 laikas. Miegas (1 * laikas. antra)
 }
}
funcpagrindinis() {
eik printText() // Paleiskite gorutiną, kad vienu metu būtų vykdoma funkcija printText
// Atlikite kitas užduotis pagrindinėje gorutinoje
dėl aš := 1; aš <= 5; i++ {
 fmt. Println(„Atlikti kitas užduotis“, i)
 laikas. Miegas (500 * laikas. Milisekundė)
 }
// Palaukite, kol gorutina baigsis
 laikas. Miegas (6 * laikas. antra)
}

The spausdintiTekstas funkcija pakartotinai spausdina tam tikrą tekstą į konsolę su a dėl ciklas, kuris vykdomas penkis kartus po vienos sekundės delsos tarp kiekvieno teiginio su laiko paketą.

The pagrindinis funkcija skambinant pradeda gorutiną eik spausdintiText, kuris paleidžia spausdintiTekstas veikia kaip atskira lygiagreti gorutina, leidžianti funkcijai vykdyti kartu su likusia kodo dalimi pagrindinis funkcija.

Galiausiai, norėdami užtikrinti, kad programa neišeis prieš spausdintiTekstas gorutinos apdaila, laikas. Miegoti funkcija pristabdo pagrindinę gorutiną šešioms sekundėms. Realiuose scenarijuose naudotumėte sinchronizavimo mechanizmus, pvz., kanalus arba laukimo grupes, kad koordinuotumėte gorutinų vykdymą.

Kanalų naudojimas komunikacijai ir sinchronizavimui

„Goroutines“ turi integruotą komunikacijos ir sinchronizavimo kanalais palaikymą, todėl rašymas vyksta vienu metu kodą lengviau nei tradicinės gijos, kurioms dažnai reikia rankinio sinchronizavimo mechanizmų, pvz., užraktų ir semaforai.

Galite galvoti apie kanalus kaip duomenų srauto tarp gorutinų vamzdynus. Viena gorutina gali nusiųsti reikšmę į kanalą, o kita – gauti tą reikšmę iš kanalo. Šis mechanizmas užtikrina, kad duomenų mainai būtų saugūs ir sinchronizuoti.

Jūs naudosite operatorius gali siųsti ir gauti duomenis kanalais.

Štai pavyzdys, parodantis pagrindinį kanalų naudojimą ryšiui tarp dviejų gorutinų:

funcpagrindinis() {
// Sukurkite nebuferinį kanalą, kurio tipas yra eilutė
 ch := padaryti(chanstyga)
// 1 Gorutine: siunčia pranešimą į kanalą
eikfunc() {
 ch "Sveikas, Kanalai!"
 }()
// 2 gorutina: gauna pranešimą iš kanalo
 žinutė :=  fmt. Spausdinti (žinutė) // Išvestis: Sveiki, kanale!
}

Kanalas, esantis pagrindinis funkcija yra nebuferinis kanalas, pavadintas sk sukurta su padaryti () funkcija. Pirmoji gorutina siunčia žinutę "Labas, kanale!" į kanalą naudodami operatorius, o antroji gorutina gauna pranešimą iš kanalo naudodama tą patį operatorių. Galiausiai, pagrindinis funkcija išspausdina gautą pranešimą į konsolę.

Galite nustatyti įvestus kanalus. Kurdami nurodysite kanalo tipą. Štai pavyzdys, parodantis skirtingų tipų kanalų naudojimą:

funcpagrindinis() {
// Nebuferinis kanalas
 ch1 := padaryti(chantarpt)
// Buferinis kanalas, kurio talpa 3
 ch2 := padaryti(chanstyga, 3)
// Reikšmių siuntimas ir gavimas iš kanalų
 ch1 42// Nusiųskite reikšmę į ch1
 reikšmė1 := // Gauti reikšmę iš ch1
 ch2 "Sveiki"// Nusiųskite reikšmę į ch2
 reikšmė2 := // Gauti reikšmę iš ch2
}

The pagrindinis funkcija sukuria du kanalus: ch1 yra nebuferinis sveikųjų skaičių kanalas, while ch2 yra buferinis stygų kanalas, kurio talpa yra 3. Galite siųsti ir gauti reikšmes į šiuos kanalus ir iš jų naudodami operatorius (reikšmės turi būti nurodyto tipo).

Galite naudoti kanalus kaip sinchronizavimo mechanizmus gorutinos vykdymui koordinuoti, pasinaudodami kanalo operacijų blokavimo pobūdžiu.

funcpagrindinis() {
 ch := padaryti(chanbool)
eikfunc() {
 fmt. Println(„Gorutine 1“)
 ch tiesa// Signalo užbaigimas
 }()
eikfunc() {
 // Palaukite užbaigimo signalo iš „Goroutine 1“.
 fmt. Println("Gorutine 2")
 }()
 // Palaukite užbaigimo signalo iš „Goroutine 2“.
 fmt. Println(„Pagrindinė gorutina“)
}

The sk kanalas yra loginis. Vienu metu vyksta dvi gorutinos pagrindinis funkcija. „Goroutine 1“ praneša apie jos pabaigą siųsdama a tiesa vertę į kanalą sk. „Goroutine 2“ laukia pabaigos signalo, gaudama reikšmę iš kanalo. Galiausiai pagrindinė gorutina laukia užbaigimo signalo iš antrosios gorutinos.

Galite kurti žiniatinklio programas „Go With Gin“.

Galite kurti didelio našumo žiniatinklio programas naudodami „Go with Gin“, išnaudodami „Go“ lygiagretumo funkcijas.

Galite naudoti Gin, kad efektyviai tvarkytumėte HTTP maršrutą ir tarpinę programinę įrangą. Pasinaudokite įtaisytuoju „Go“ lygiagretumo palaikymu, naudodami gorutinas ir kanalus tokioms užduotims kaip duomenų bazės užklausos, API iškvietimai ar kitos blokavimo operacijos.