select ఒక goroutine ను multiple channel operations న ఏకకాలంలో వేచి ఉండటానికి అనుమతిస్తుంది, ఏది ముందుగా సిద్ధమైనా అది చేయుతుంది. ఇది channels కోసం switch లాంటిది — concurrent operations, timeouts, మరియు cancellation లను సమన్వయం చేయడానికి అవసరం.
{
msg1 := <-ch1:
fmt.Println(, msg1)
msg2 := <-ch2:
fmt.Println(, msg2)
ch3 <- :
fmt.Println()
}
select దాని channel operations కంటే ఎక్కువ కదలగలిగే వరకు blocked ఉంటుంది, ఆ తర్వాత ఆ case ను execute చేస్తుంది. కొన్ని ఒకసారి సిద్ధమైతే, ఇది ఒకటిని యాదృచ్ఛికంగా ఎంచుకుంటుంది (starvation నిరోధించడానికి).
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
}
work channel ను time.After తో జోడించడం అనేది timeout ను జోడించడానికి idiomatic మార్గం — ఫలితం వస్తే సాగండి, లేదా deadline తర్వాత పరిత్యాగం చేయండి. ఇది goroutines ను అనిర్దిష్టంగా blocking నుండి నిరోధిస్తుంది.
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
A default case select ను non-blocking చేస్తుంది: ఏ channel సిద్ధం కాకపోతే, 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() pattern ఒక goroutine ను work చేస్తున్నప్పుడు cancellation కోసం వినడానికి అనుమతిస్తుంది — goroutines ను stoppable చేయడానికి మరియు leaks నిరోధించడానికి ప్రామాణిక మార్గం.
for {
select {
case data := <-dataCh: ...
case <-quit: return
}
}
select Go concurrency కోసం ఒక ప్రాథమిక సాధనం — ఇది goroutines multiple channels ని సమన్వయం చేసే విధానం, ఇది నిజమైన concurrent programs కోసం అవసరమైన patterns ను సక్షమ చేస్తుంది.
ఇది key uses విమర్శనీయమైనవి: timeouts (time.After) అనిర్దిష్ట blocking నిరోధిస్తుంది; non-blocking channel checks (default) stuck నుండి నిరోధిస్తుంది; మరియు ముఖ్యంగా cancellation (<-ctx.Done()) goroutines ను cleanly exit చేయుటకు అనుమతిస్తుంది, ఇది goroutine leaks విరుద్ధ ప్రధాన రక్షణ.
select లేకుండా, మీరు several channels పై gracefully వేచిఉండలేరు, deadlines implement చేయలేరు, లేదా goroutines ను shutdown signals కు responsive చేయలేరు.
select ను అర్థం చేసుకోవడం (దాని blocking-until-ready behavior, ready cases లో random choice, non-blocking కోసం default, మరియు timeout/cancellation idioms) robust, leak-free concurrent Go ను రాయడానికి ముఖ్యమైనది మరియు ఈ భాషలో core concurrency topics లో ఉంది.