العبارة select في Golang: المهل وdefault وقنوات الإيقاف

انتظار عدة قنوات

تبدو select مثل switch، لكن كل حالة فيها إرسال أو استقبال على قناة. تتوقّف حتى تستطيع حالة ما المضي ثم تنفّذها.

package main

import (
	"fmt"
	"time"
)

func main() {
	fast := make(chan string)
	slow := make(chan string)

	go func() {
		time.Sleep(30 * time.Millisecond)
		slow <- "slow result"
	}()
	go func() {
		time.Sleep(10 * time.Millisecond)
		fast <- "fast result"
	}()

	for range 2 {
		select {
		case msg := <-fast:
			fmt.Println("from fast:", msg)
		case msg := <-slow:
			fmt.Println("from slow:", msg)
		}
	}
}

مع هذه التأخيرات تحصل select الأولى على النتيجة السريعة والثانية على البطيئة. لا يحتاج أي استقبال إلى انتظار القناة الأخرى. أما <-slow ثم <-fast فستعالجهما بترتيب ثابت أيًا كانت التي وصلت أولًا.

كيف تُقيَّم select:

1. تُقيَّم كل تعابير القنوات والقيم المراد إرسالها مرة واحدة، بترتيب الشيفرة، عند بدء select.
2. إذا جهزت حالة أو أكثر، تُختار إحداها عشوائيًا.
3. إذا لم تجهز أي حالة ووُجدت default، تُنفَّذ default.
4. وإلا تتوقّف الـ goroutine حتى تجهز حالة ما.

select {} الفارغة تتوقّف إلى الأبد. تراها أحيانًا في نهاية main في برامج يجري عملها الحقيقي في goroutines أخرى.

الاختيار العشوائي بين الحالات الجاهزة

عندما تجهز عدة حالات في الوقت نفسه، لا تفضّل select الأولى في الترتيب. يملأ هذا البرنامج قناتين مخزّنتين ثم ينفّذ select ألف مرة:

package main

import "fmt"

func main() {
	a := make(chan int, 1000)
	b := make(chan int, 1000)
	for range 1000 {
		a <- 1
		b <- 1
	}

	countA, countB := 0, 0
	for range 1000 {
		select {
		case <-a:
			countA++
		case <-b:
			countB++
		}
	}
	fmt.Println("both channels were picked:", countA > 0 && countB > 0)
	fmt.Println("total:", countA+countB)
}

يتغيّر التوزيع بين countA وcountB في كل تشغيل ويقترب من 500 لكل منهما. الاختيار العشوائي مقصود: يمنع قناة مزدحمة من تجويع الأخريات. إذا احتجت أولوية فانظر النمط لاحقًا.

عمليات دون توقّف مع default

مع حالة default لا تتوقّف select أبدًا. وهذا يحوّل الإرسال أو الاستقبال إلى عملية "محاولة":

package main

import "fmt"

func main() {
	queue := make(chan int, 2)

	for i := 1; i <= 3; i++ {
		select {
		case queue <- i:
			fmt.Println("queued", i)
		default:
			fmt.Println("queue full, dropped", i)
		}
	}

	for {
		select {
		case v := <-queue:
			fmt.Println("got", v)
		default:
			fmt.Println("queue empty")
			return
		}
	}
}

إسقاط العمل عندما يمتلئ المخزن هو طريقة تخفيف الحمل أو إرسال المقاييس دون إيقاف المستدعي أبدًا.

لا تضع default في select داخل حلقة for لمجرّد "فحص" القنوات مرارًا. عندما لا يكون شيء جاهزًا تدور الحلقة مستهلكة 100% من المعالج. توقّف بدلًا من ذلك، وأضف حالة مهلة إن احتجت الاستيقاظ دوريًا.

المهل

تعيد time.After(d) قناة تستقبل مرة واحدة بعد d. سابقها مع العمل الحقيقي:

package main

import (
	"errors"
	"fmt"
	"time"
)

var errTimeout = errors.New("timed out")

func fetch(delay time.Duration) (string, error) {
	result := make(chan string, 1) // buffered: the worker can finish even if nobody reads
	go func() {
		time.Sleep(delay) // pretend to call something slow
		result <- "data"
	}()

	select {
	case r := <-result:
		return r, nil
	case <-time.After(50 * time.Millisecond):
		return "", errTimeout
	}
}

func main() {
	for _, d := range []time.Duration{10 * time.Millisecond, 200 * time.Millisecond} {
		r, err := fetch(d)
		fmt.Printf("result=%q err=%v\n", r, err)
	}
}

يعيد الاستدعاء الأول "data". ويعيد الثاني خطأ المهلة بعد 50 ms، قبل أن ينتهي العامل بوقت طويل. لقناة النتيجة مخزن بحجم 1 عن قصد. عندما تفوز المهلة لا يستقبل أحد من result أبدًا؛ ومع قناة غير مخزّنة كانت goroutine العامل ستتوقّف على إرسالها إلى الأبد وتتسرّب.

في الحلقة تنشئ time.After مؤقّتًا جديدًا في كل تكرار، وهذا صحيح تمامًا لمهلة خمول لكل رسالة ("لا رسالة منذ ثانية"). أما لموعد نهائي كلي عبر عمليات كثيرة، فأنشئ مؤقّتًا أو سياقًا واحدًا قبل الحلقة. منذ Go 1.23 تُجمع المؤقّتات التي لم يعد يشير إليها شيء حتى لو لم تنطلق، فلم تعد time.After في حلقة تحتفظ بالذاكرة حتى ينطلق كل مؤقّت، كما كانت تفعل في الإصدارات الأقدم (يحتاج هذا go 1.23 أو أحدث في go.mod).

حلقات for-select وقنوات الإيقاف

الـ goroutine التي تعمل حتى يُطلب منها التوقّف هي حلقة for حول select فيها حالة للعمل وحالة للتوقّف:

package main

import "fmt"

func worker(jobs <-chan int, quit <-chan struct{}, done chan<- struct{}) {
	defer close(done)
	for {
		select {
		case j := <-jobs:
			fmt.Println("processing job", j)
		case <-quit:
			fmt.Println("worker: stopping")
			return
		}
	}
}

func main() {
	jobs := make(chan int)
	quit := make(chan struct{})
	done := make(chan struct{})

	go worker(jobs, quit, done)
	for i := 1; i <= 3; i++ {
		jobs <- i
	}
	close(quit) // closing wakes every goroutine that selects on quit
	<-done
	fmt.Println("main: worker has exited")
}

إغلاق quit بدل الإرسال عليها هو الأسلوب المعتاد: يراه كل مستقبل، الآن ولاحقًا، فتوقف close واحدة أي عدد من العمّال. وتتيح قناة done لـ main الانتظار حتى يعود العامل فعلًا.

في الشيفرة الحقيقية تكون قناة الإيقاف عادة context.Context: case <-ctx.Done():. تعمل بالطريقة نفسها (تعيد Done() قناة تُغلق عند الإلغاء) وتحمل أيضًا المواعيد النهائية وسبب التوقّف. صفحة context تشرحها.

break داخل select

تخرج break في حالة من حالات select من select، لا من for المحيطة. هذا مصدر شائع لحلقات لا تنتهي. استخدم return، أو ضع وسمًا على الحلقة:

package main

import "fmt"

func main() {
	nums := make(chan int)
	go func() {
		defer close(nums)
		for i := range 5 {
			nums <- i
		}
	}()

	sum := 0
loop:
	for {
		select {
		case n, ok := <-nums:
			if !ok {
				break loop // without the label this only leaves the select
			}
			sum += n
		}
	}
	fmt.Println("sum:", sum)
}

الأولوية بين القنوات

لأن select تختار عشوائيًا، لا يمكنك ترتيب الحالات داخل عبارة واحدة. لتجعل قناة تفوز كلما كان فيها شيء، افحصها أولًا وحدها:

for {
	select {
	case <-ctx.Done():
		return ctx.Err()
	default:
	}

	select {
	case <-ctx.Done():
		return ctx.Err()
	case job := <-jobs:
		handle(job)
	}
}

تعود select الأولى فورًا إذا كان الإلغاء قد حدث. ومن دونها قد يستمر تدفّق ثابت من المهام في الفوز بالاختيار العشوائي لفترة بعد إلغاء ctx.

القنوات nil تعطّل الحالة

الإرسال أو الاستقبال على قناة nil لا يجهز أبدًا، فالحالة على قناة nil معطّلة فعليًا. تعيين مدخل مغلق إلى nil هو طريقة التوقّف عن انتظاره مع متابعة الأخرى؛ وتعرض صفحة القنوات حلقة دمج مبنية بهذه الطريقة. والحيلة نفسها تشغّل المهلة وتطفئها: أبقِ var timeout <-chan time.Time مساوية لـ nil حتى تحتاجها، ثم أسند إليها time.After(d).

أخطاء شائعة

• توقّع ترتيب الشيفرة. الحالة الأولى في الترتيب لا تُفضَّل.
• حلقة مشغولة مع default. for { select { ... default: } } دون عمل تستهلك نواة معالج.
• تسريب الخاسر. عندما تفوز المهلة، يجب أن تبقى الـ goroutine التي كانت سترسل النتيجة قادرة على الانتهاء. أعطِ قناتها مخزنًا بحجم 1.
• break تخرج من select وحدها. استخدم وسمًا أو return.
• time.After واحدة لكل تكرار تُستخدم كموعد نهائي كلي. تبدأ من جديد في كل تكرار؛ أنشئ الموعد النهائي مرة واحدة خارج الحلقة.