În acest articol, vom explora modul de utilizare selectează declarația în Golang și oferiți exemple pentru a vă ajuta să obțineți paralelism, concurență și sincronizare în programele Go.
Cum se utilizează declarația Select în Golang?
Similar cu declarația switch, the selectează declarația ne permite să selectăm și să executăm o expresie dintre multe expresii, dar diferența principală între Selectați și comutatorul este că selectează declarația funcționează pe principiul așteptării, ceea ce înseamnă că selectează declarația nu se va executa până la finalizarea comunicării.
Aici, comunicarea se referă la trimiterea și primirea de date pe orice canal dat. Când comunicarea este finalizată, următoarea verificare este efectuată, permițându-ne să vedem că declarația selectă a limbii Go depinde în întregime de canal.
Sintaxă pentru instrucțiunea Select
Sintaxa simplă folosită pentru selectează declarația folosind limba Go este prezentată mai jos:
Selectați {
caz canal_1 :
// cod de executat când canalul_1 este gata
caz canal_2 :
// cod de executat când canalul_2 este gata
caz canalul_3 :
// cod de executat când canalul_3 este gata
caz canal_4 :
// cod de executat când canalul_4 este gata
Mod implicit :
// cod de executat dacă niciunul dintre canale nu este pregătit
}
Aici:
- Intr-un selectează declarația , fiecare caz reprezintă o operație de canal, care poate fi o operație de primire sau o operație de trimitere.
- The selectează declarația așteaptă până când unul dintre cazuri este gata și apoi îl rulează și instrucțiunea case asociată.
- Selectează aleatoriu canalul în cazul în care există mai multe canale gata de executat.
Cum se creează un canal în Golang
Pentru a crea un canal în Go, utilizatorii pot folosi funcția make urmată de chan cuvântul cheie și specificați tipul canalului, care poate fi int, șir sau altele.
cap := face ( tip chan )Implementați declarația Select în Golang
Aici, vom oferi câteva exemple pentru a vă ajuta să învățați elementele de bază ale utilizării selectează declarația în Golang.
Exemplul 1
Următorul exemplu de selectează declarația demonstrează cum funcționează atunci când ambele canale sunt gata de executare.
pachet principalimport 'fmt'
func principal ( ) {
pe unu := face ( chan int )
str := face ( chan string )
du-te chan_num ( pe unu )
du-te chan_str ( str )
Selectați {
caz Ch1 := <- pe unu :
fmt. Println ( „Date canal:” , Ch1 )
caz Ch2 := <- str :
fmt. Println ( „Date canal:” , Ch2 )
}
}
func chan_num ( num chan int ) {
pe unu <- 67
}
func chan_str ( str chan șir ) {
str <- 'Linux'
}
În exemplul de mai sus, am creat două canale, pe unu, și str și am folosit funcțiile Go chan_num() pentru a trimite date către canalul num și chan_str() pentru a trimite date pe canalul str. Deoarece programul conține două canale diferite, am folosit selectează declarația pentru a executa una dintre ele.
Caz Ch1 citește valoarea din canal num și îl afișează. La fel, cazul Ch2 returnează valoarea din str canal. Programul de mai sus returnează ieșirea canalului care este gata de utilizare. Ieșire
Exemplul 2
Dacă doriți să adăugați o întârziere la un canal și să returnați ieșirea unui alt canal, puteți utiliza timp.somn() funcţionează pe un canal specificat. Acest lucru vă permite să imprimați ieșirea celuilalt canal pe consolă. Iată un exemplu de astfel de caz.
pachet principalimport (
'fmt'
'timp'
)
func principal ( ) {
pe unu := face ( chan int )
str := face ( chan string )
du-te chan_num ( pe unu )
du-te chan_str ( str )
Selectați {
caz Ch1 := <- pe unu :
fmt. Println ( „Date canal:” , Ch1 )
caz Ch2 := <- str :
fmt. Println ( „Date canal:” , Ch2 )
}
}
func chan_num ( num chan int ) {
pe unu <- 67
}
func chan_str ( str chan șir ) {
timp . Dormi ( 5 * timp . Al doilea )
str <- 'Linux'
}
În codul de mai sus, am folosit timp.Somn() funcția în interiorul chan_str() funcţie. Doar canalul num este gata de execuție în primele 5 secunde. Drept urmare, selectează declarația rulează cazul Ch1 .
Ieșire
Notă: Puteți adăuga o întârziere la ambele canale pentru a întârzia execuția canalelor.
Concluzie
The selectează declarația în Go permite selectarea și executarea unei expresii din mai multe expresii folosind principiul wait, unde instrucțiunea nu se va executa până când comunicarea este finalizată. Orientările menționate mai sus includ selectează declarația sintaxă de bază și exemple.