select એક goroutine ને બહુવિધ ચેનલ ઓપરેશન પર એક સાથે રાહ જોવા દે છે, જે પ્રથમ તૈયાર છે તે સાથે આગળ વધે છે. તે ચેનલો માટે switch જેવું છે — સમવર્તી ક્રિયાકલાપો, timeout અને રદ્દીકરણને સમન્વય કરવા માટે આવશ્યક છે.
{
msg1 := <-ch1:
fmt.Println(, msg1)
msg2 := <-ch2:
fmt.Println(, msg2)
ch3 <- :
fmt.Println()
}
select તેની ચેનલ ક્રિયાકલાપમાંથી એક આગળ વધી શકે ત્યાં સુધી અટકી જાય છે, પછી તે કેસ ચલાવે છે. જો એક સાથે કેટલાક તૈયાર હોય, તો તે એક અવ્યવસ્થિત રીતે પસંદ કરે છે (ભુખમરી રોકે છે).
select {
case result := <-workCh:
fmt.Println("got result:", result)
case <-time.After(2 * time.Second): // fires after 2 seconds
fmt.Println("timed out") // don't wait forever
}
કાર્ય ચેનલને time.After સાથે જોડવું timeout ઉમેરવાની idiom રીત છે — જો પરિણામ આવે તો આગળ વધો, અન્યથા સમયમર્યાદા પછી છોડી દો. આ goroutine ને અનિશ્ચિત સમય માટે અટકતા અટકાવે છે.
select {
case msg := <-ch:
fmt.Println("received:", msg)
default:
fmt.Println("no message ready") // runs immediately if no case is ready
}
// with a default case, select NEVER blocks — it's a non-blocking check
લ default કેસ select ને બિન-બ્લોકિંગ બનાવે છે: જો કોઈ ચેનલ તૈયાર ન હોય, તો રાહ જોવાને બદલે default તરત ચલાવવામાં આવે છે.
func worker(ctx context.Context, jobs <-chan int) {
for {
select {
case job := <-jobs:
process(job)
case <-ctx.Done(): // context cancelled or timed out
fmt.Println("shutting down:", ctx.Err())
return // clean exit — prevents goroutine leak
}
}
}
case <-ctx.Done() પેટર્ન একটি goroutine ને કાર્ય કરતી વખતે રદ્દીકરણ માટે સાંભળવાની મંજૂરી આપે છે — goroutine ને બંધ કરી શકાય તેવું બનાવવા અને લિક રોકવાનું માનક રીત.
for {
select {
case data := <-dataCh: ...
case <-quit: return
}
}
select Go સમવર્તી માટે એક મૂળભૂત સાધન છે — તે તે રીતે છે કે જેમાં goroutine બહુવિધ ચેનલને સમન્વય કરે છે, વાસ્તવિક સમવર્તી પ્રોગ્રામો માટે આવશ્યક પેટર્ન સક્ષમ કરે છે.
તેનો મુખ્ય ઉપયોગ વિવેચક છે: timeout (time.After) અનિશ્ચિત બ્લોકીંગ રોકે છે; બિન-બ્લોકિંગ ચેનલ તપાસ (default) અટકાયેલ થતા અટકાવે છે; અને ખાસ કરીને રદ્દીકરણ (<-ctx.Done()) goroutine ને સ્વચ્છ રીતે બંધ કરવાની મંજૂરી આપે છે, જે goroutine લિક માટે મુખ્ય રક્ષણ છે.
બિના select ના, તમે કેટલાક ચેનલો પર કમનસીબીથી રાહ જોઈ શકતા નથી, સમયમર્યાદા લાગુ કરી શકતા નથી, અથવા goroutine ને શટડાઉન સિગ્નલોને પ્રતિક્રિયાશીલ કરી શકતા નથી.
select ને સમજવું (તેનું બ્લોક-સુધી-તૈયાર વર્તન, તૈયાર કેસોમાં અવ્યવસ્થિત પસંદગી, બિન-બ્લોકીંગ માટે default, અને timeout/રદ્દીકરણ idiom) મજબૂત, લિક-મુક્ત સમવર્તી Go લખવા માટે આવશ્યક છે અને તે ભાષામાં મુખ્ય સમવર્તી વિષયોમાંથી એક છે.