Uvod v sočasnost v Go

Sočasnost je ključen vidik sodobnega razvoja programske opreme, saj omogoča programom, da učinkovito obravnavajo več nalog hkrati. Napišete lahko programe, ki izvajajo različne operacije, ki vodijo do izboljšane zmogljivosti, odzivnosti in izkoriščenosti virov.

Sočasnost je ena od lastnosti, odgovornih za hitro sprejetje Go-ja. Go-jeva vgrajena podpora za sočasno programiranje velja za preprosto, hkrati pa pomaga pri izogibanju pogostim pastem, kot so pogoji tekmovanja in zastoji.

Sočasnost v Go

Go zagotavlja robustno podporo za sočasnost prek različnih mehanizmov, ki so vsi na voljo v njegovi standardni knjižnici in orodni verigi. Go programi doseči sočasnost prek goroutin in kanalov.

Goroutine so lahke, neodvisno izvajajoče se funkcije, ki se izvajajo sočasno z drugimi goroutine v istem naslovnem prostoru. Goroutine omogočajo sočasno izvajanje več nalog brez izrecnega upravljanja niti. Goroutine so lažje od niti operacijskega sistema in Go lahko učinkovito poganja na tisoče ali celo milijone goroutin hkrati.

Kanali so komunikacijski mehanizem za koordinacijo in izmenjavo podatkov med goroutinami. Kanal je tipiziran kanal, ki goroutinam omogoča pošiljanje in prejemanje vrednosti. Kanali zagotavljajo sinhronizacijo za zagotovitev varne izmenjave podatkov med goroutinami, hkrati pa preprečujejo pogoje tekmovanja in druge pogoste težave s sočasnostjo.

Z združevanjem goroutin in kanalov Go zagotavlja zmogljiv in enostaven model sočasnosti, ki poenostavlja razvoj sočasnih programov, hkrati pa ohranja varnost in učinkovitost. Ti mehanizmi vam omogočajo enostavno uporabo večjedrni procesorji in zgraditi visoko razširljive in odzivne aplikacije.

Kako uporabljati goroutine za sočasno izvajanje kode

Izvajalno okolje Go upravlja goroutine. Goroutine imajo svoj sklad, kar jim omogoča lahek odtis z začetno velikostjo sklada nekaj kilobajtov.

Goroutine so multipleksirane v več niti OS z izvajalnim okoljem Go. Razporejevalnik izvajalnega časa Go jih razporedi na razpoložljive niti z učinkovito porazdelitvijo delovne obremenitve, kar omogoča hkratno izvajanje več podprogramov na manj niti OS.

Ustvarjanje goroutin je preprosto. Uporabili boste pojdi ključna beseda, ki ji sledi klic funkcije za razglasitev goroutin.

funkglavni() {
pojdi funkcija1() // Ustvari in izvedi goroutine za funkcijo1
pojdi funkcija2() // Ustvari in izvedi goroutine za funkcijo2
// ...
}
funkfunkcija1() {
// Koda za funkcijo1
}
funkfunkcija2() {
// Koda za funkcijo2
}

Ko program prikliče funkcija1() in funkcija2() z pojdi ključno besedo, izvajalno okolje Go izvaja funkcije sočasno kot goroutines.

Tukaj je primer uporabe goroutine, ki natisne besedilo na konzolo:

paket glavni
uvoz (
"fmt"
"čas"
)
funkprintText() {
za jaz := 1; jaz <= 5; i++ {
 fmt. Println("Tiskanje besedila", jaz)
 čas. spanje(1 * čas. drugič)
 }
}
funkglavni() {
pojdi printText() // Zagon goroutine za sočasno izvajanje funkcije printText
// Izvedite druge naloge v glavni rutini
za jaz := 1; jaz <= 5; i++ {
 fmt. Println("Opravljanje drugih nalog", jaz)
 čas. spanje(500 * čas. milisekunda)
 }
// Počakajte, da se goroutina konča
 čas. spanje(6 * čas. drugič)
}

The printText funkcija večkrat natisne nekaj besedila na konzolo z a za zanke, ki se zažene petkrat z enosekundnim zamikom med vsakim stavkom z časovni paket.

The glavni funkcija zažene goroutino s klicem pojdi printText, ki zažene printText deluje kot ločena sočasna gorrutina, ki omogoča, da se funkcija izvaja sočasno s preostalo kodo v glavni funkcijo.

Končno, da zagotovite, da se program ne zapre pred printText goroutine konča, the čas. spi funkcija zaustavi glavno rutino za šest sekund. V realnih scenarijih bi za usklajevanje izvajanja goroutin uporabili sinhronizacijske mehanizme, kot so kanali ali čakalne skupine.

Uporaba kanalov za komunikacijo in sinhronizacijo

Goroutine imajo vgrajeno podporo za komunikacijo in sinhronizacijo prek kanalov, zaradi česar je pisanje sočasno kodo lažjo kot tradicionalne niti, ki pogosto zahtevajo ročne mehanizme za sinhronizacijo, kot so ključavnice in semaforji.

Kanale si lahko predstavljate kot cevovode za pretok podatkov med goroutinami. Ena gorrutina lahko pošlje vrednost v kanal, druga gorrutina pa lahko to vrednost sprejme iz kanala. Ta mehanizem zagotavlja, da je izmenjava podatkov varna in sinhronizirana.

Uporabili boste operater za pošiljanje in prejemanje podatkov prek kanalov.

Tukaj je primer, ki prikazuje osnovno uporabo kanalov za komunikacijo med dvema rutinama:

funkglavni() {
// Ustvari kanal brez medpomnjenja tipa niz
 ch := narediti(kanvrvica)
// Goroutine 1: pošlje sporočilo v kanal
pojdifunk() {
 ch "Pozdravljen, kanal!"
 }()
// Goroutine 2: Prejme sporočilo iz kanala
 sporočilo :=  fmt. Println (sporočilo) // Izhod: Pozdravljeni, kanal!
}

Kanal v glavni funkcija je kanal brez medpomnjenja z imenom pogl ustvarjen z narediti () funkcijo. Prva goroutina pošlje sporočilo "Hello, Channel!" v kanal z uporabo drugi goroutine pa sprejme sporočilo iz kanala z istim operatorjem. Končno, glavni funkcija natisne prejeto sporočilo na konzolo.

Določite lahko vnesene kanale. Vrsto kanala boste določili ob ustvarjanju. Tukaj je primer, ki prikazuje uporabo različnih vrst kanalov:

funkglavni() {
// Unbuffered kanal
 ch1 := narediti(kanint)
// Medpomnilnik kanal z zmogljivostjo 3
 ch2 := narediti(kanvrvica, 3)
// Pošiljanje in prejemanje vrednosti iz kanalov
 ch1 42// Pošlji vrednost v ch1
 vrednost1 := // Prejmi vrednost iz ch1
 ch2 "Zdravo"// Pošlji vrednost v ch2
 vrednost2 := // Prejmi vrednost iz ch2
}

The glavni funkcija ustvari dva kanala: ch1 je celoštevilski kanal brez medpomnjenja, medtem ko ch2 je medpomnilniški nizovni kanal s kapaciteto 3. V te kanale lahko pošiljate in prejemate vrednosti z uporabo (vrednosti morajo biti podanega tipa).

Kanale lahko uporabite kot sinhronizacijske mehanizme za usklajevanje izvajanja goroutine z izkoriščanjem blokirajoče narave kanalskih operacij.

funkglavni() {
 ch := narediti(kanbool)
pojdifunk() {
 fmt. Println("Gorutina 1")
 ch prav// Zaključek signala
 }()
pojdifunk() {
 // Počakajte na zaključni signal iz Goroutine 1
 fmt. Println("Gorutina 2")
 }()
 // Počakajte na zaključni signal iz Goroutine 2
 fmt. Println("Glavna goroutina")
}

The pogl kanal je logični. Dve goroutini tečeta hkrati v glavni funkcijo. Goroutine 1 signalizira svoj zaključek s pošiljanjem a prav vrednost v kanal pogl. Goroutine 2 čaka na zaključni signal tako, da prejme vrednost iz kanala. Končno glavna podprograma čaka na zaključni signal iz podprograma dva.

V Go With Gin lahko sestavite spletne aplikacije

V Go with Gin lahko ustvarite visoko zmogljive spletne aplikacije, pri tem pa izkoristite funkcije sočasnosti Go.

Gin lahko uporabite za učinkovito upravljanje HTTP usmerjanja in vmesne programske opreme. Izkoristite vgrajeno podporo za sočasnost Go z uporabo goroutin in kanalov za opravila, kot so poizvedbe po bazi podatkov, klici API-ja ali druge operacije blokiranja.