select एक goroutine को एकाधिक चैनल ऑपरेशन पर एक साथ प्रतीक्षा करने देता है, जो पहले तैयार हो उसके साथ आगे बढ़ता है। यह चैनलों के लिए switch जैसा है — समवर्ती संचालन, timeout और रद्दीकरण को समन्वय करने के लिए आवश्यक है।
{
msg1 := <-ch1:
fmt.Println(, msg1)
msg2 := <-ch2:
fmt.Println(, msg2)
ch3 <- :
fmt.Println()
}
select तब तक अवरुद्ध रहता है जब तक इसके चैनल ऑपरेशन में से एक आगे बढ़ सकता है, फिर वह case को निष्पादित करता है। यदि कई एक साथ तैयार हों, तो यह एक को बेतरतीब ढंग से चुनता है (भूखमरी को रोकता है)।
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 जोड़ने का idiomatic तरीका है — यदि परिणाम आता है तो आगे बढ़ें, अन्यथा समयसीमा के बाद छोड़ दें। यह 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 case 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 को रोकने योग्य बनाने और leaks से बचने का मानक तरीका।
for {
select {
case data := <-dataCh: ...
case <-quit: return
}
}
select Go concurrency के लिए एक मौलिक उपकरण है — यह इस तरह है कि goroutine एकाधिक चैनलों को समन्वय करते हैं, जो वास्तविक समवर्ती प्रोग्राम के लिए आवश्यक पैटर्न को सक्षम करते हैं।
इसके मुख्य उपयोग गंभीर हैं: timeout (time.After) अनिश्चित अवरुद्धता को रोकते हैं; गैर-अवरुद्ध चैनल checks (default) फंसे रहने से बचाते हैं; और विशेष रूप से रद्दीकरण (<-ctx.Done()) goroutine को깔끔하ी से बाहर निकलने देता है, जो goroutine leaks के विरुद्ध प्राथमिक रक्षा है।
बिना select के, आप कई चैनलों पर elegant तरीके से प्रतीक्षा नहीं कर सकते, deadline implement नहीं कर सकते, या goroutine को shutdown signals के प्रति responsive नहीं बना सकते।
select को समझना (इसका blocking-until-ready behavior, ready cases में random choice, non-blocking के लिए default, और timeout/cancellation idioms) मजबूत, leak-free concurrent Go लिखने के लिए आवश्यक है और भाषा में core concurrency topics में से एक है।