select ਇੱਕ goroutine ਨੂੰ ਮਲਟੀਪਲ channel ਓਪਰੇਸ਼ੰਸ ਉੱਤੇ ਇੱਕੋ ਵਾਰ wait ਕਰਨ ਦੇਣ ਦਿੰਦਾ ਹੈ, ਜੋ ਵੀ ਪਹਿਲਾ ready ਹੋ ਉਹ ਅੱਗੇ ਵੱਧਦਾ ਹੈ। ਇਹ channels ਲਈ switch ਵਾਂਗ ਹੈ — concurrent ਓਪਰੇਸ਼ੰਸ, timeouts, ਅਤੇ cancellation ਨੂੰ coordinate ਕਰਨ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।
{
msg1 := <-ch1:
fmt.Println(, msg1)
msg2 := <-ch2:
fmt.Println(, msg2)
ch3 <- :
fmt.Println()
}
select ਉਦੋ ਤਕ block ਕਰਦਾ ਹੈ ਜਦੋ ਤਕ ਇਸ ਦੇ ਇੱਕ channel ਓਪਰੇਸ਼ਨ ਅੱਗੇ ਵੱਧ ਸਕਣ, ਫਿਰ ਉਹ case execute ਕਰਦਾ ਹੈ। ਜੇ ਕਈ ਇੱਕ ਵਾਰ ready ਹਾਂ, ਤਾਂ ਇਹ ਬੇਤਰਤੀਬੀ ਨਾਲ ਕਿਸੇ ਨੂੰ pick ਕਰਦਾ ਹੈ (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 ਨੂੰ pair ਕਰਨਾ ਇੱਕ timeout ਜੋੜਨ ਦਾ idiomatic way ਹੈ — ਜੇ ਨਤੀਜਾ ਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਅੱਗੇ ਵੱਧੋ, ਨਹੀਂ ਤਾਂ deadline ਤੋਂ ਬਾਅਦ ਛੱਡ ਦਿਓ। ਇਹ goroutines ਨੂੰ indefinitely block ਹੋਣ ਤੋਂ ਰੋਕਦਾ ਹੈ।
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 ਨੂੰ non-blocking ਬਣਾ ਦਿੰਦਾ ਹੈ: ਜੇ ਕੋਈ channel ready ਨਹੀਂ ਹੈ, default ਤੁਰੰਤ wait ਕਰਨ ਦੀ ਬਜਾਏ run ਕਰਦਾ ਹੈ।
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 ਲਈ listen ਕਰਨ ਦੇਣ ਦਿੰਦਾ ਹੈ — goroutines ਨੂੰ stoppable ਬਣਾਉਣ ਅਤੇ leaks ਤੋਂ ਬਚਣ ਦਾ standard way ਹੈ।
for {
select {
case data := <-dataCh: ...
case <-quit: return
}
}
select Go concurrency ਲਈ ਇੱਕ fundamental tool ਹੈ — ਇਹ ਹੀ ਹੈ ਜਿਸ ਦੁਆਰਾ goroutines ਮਲਟੀਪਲ channels ਨੂੰ coordinate ਕਰਦੇ ਹਨ, ਓਨ patterns ਨੂੰ enable ਕਰਦੇ ਹਨ ਜੋ real concurrent programs ਲਈ ਜ਼ਰੂਰੀ ਹਨ।
ਇਸ ਦੇ key uses ਸਮਾਲੋਚਨਾ ਹਨ: timeouts (time.After) indefinite blocking ਨੂੰ ਰੋਕਦੇ ਹਨ; non-blocking channel checks (default) stuck ਹੋਣ ਤੋਂ ਬਚਾਉਂਦੇ ਹਨ; ਅਤੇ ਖਾਸ ਤੌਰ 'ਤੇ cancellation (<-ctx.Done()) goroutines ਨੂੰ cleanly exit ਕਰਨ ਦਿੰਦਾ ਹੈ, ਜੋ goroutine leaks ਦੇ ਖਿਲਾਫ ਪ੍ਰਾਇਮਰੀ ਰੱਖਿਆ ਹੈ।
select ਤੋਂ ਬਿਨਾ, ਤੁਸੀਂ ਕਈ channels ਉੱਤੇ elegantly wait ਨਹੀਂ ਕਰ ਸਕਦੇ, deadlines implement ਨਹੀਂ ਕਰ ਸਕਦੇ, ਜਾਂ goroutines ਨੂੰ shutdown signals ਪ੍ਰਤਿ responsive ਨਹੀਂ ਬਣਾ ਸਕਦੇ।
select ਨੂੰ ਸਮਝਣਾ (ਇਸ ਦਾ blocking-until-ready ਵਿਵਹਾਰ, ready cases ਵਿਚਕਾਰ random choice, non-blocking ਲਈ default, ਅਤੇ timeout/cancellation idioms) robust, leak-free concurrent Go ਲਿਖਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ ਅਤੇ language ਵਿੱਚ core concurrency topics ਵਿਚੋਂ ਹੈ।