القنوات في Golang: المخزّنة وغير المخزّنة والإغلاق وrange

الإرسال والاستقبال

القناة (channel) أنبوب ذو نوع محدّد بين الـ goroutines. ch <- v ترسل، و<-ch تستقبل. أنشئ القناة بـ make:

package main

import "fmt"

func main() {
	messages := make(chan string)

	go func() {
		messages <- "ping" // blocks until main receives
	}()

	msg := <-messages // blocks until the goroutine sends
	fmt.Println(msg)
}

القيمة الصفرية لنوع القناة هي nil، لذا فإن var ch chan string دون make تعطيك قناة تتوقّف إلى الأبد. أنشئ القنوات دائمًا بـ make.

القنوات غير المخزّنة تُزامِن

تنشئ make(chan T) قناة غير مخزّنة. الإرسال يتوقّف حتى يأخذ مستقبلٌ القيمة، والاستقبال يتوقّف حتى يقدّمها مرسلٌ. تلتقي الـ goroutine عند هذه النقطة، وهذا يجعل القناة غير المخزّنة أداة تزامن بقدر ما هي أنبوب بيانات. عندما تعود <-done في المثال التالي، تعرف أن العامل أنهى كل ما قبل الإرسال:

package main

import "fmt"

func main() {
	done := make(chan struct{})
	result := 0

	go func() {
		for i := 1; i <= 100; i++ {
			result += i
		}
		done <- struct{}{} // signal: finished
	}()

	<-done
	fmt.Println("sum:", result)
}

قراءة result في main آمنة هنا دون mutex. يضمن نموذج الذاكرة في Go أن كل ما فعله العامل قبل الإرسال يصبح مرئيًا لـ main بعد الاستقبال المقابل. النوع chan struct{} هو النوع المعتاد للإشارة المجرّدة، لأن struct{} لا يشغل أي ذاكرة.

القنوات المخزّنة

تعطي make(chan T, n) القناة مساحة لـ n قيمة. ينجح الإرسال دون مستقبل حتى يمتلئ المخزن، وينجح الاستقبال حتى يفرغ. تخرج القيم بالترتيب الذي دخلت به.

package main

import "fmt"

func main() {
	ch := make(chan int, 3)

	ch <- 10
	ch <- 20
	fmt.Println("len:", len(ch), "cap:", cap(ch))

	ch <- 30 // buffer now full; a fourth send here would block forever

	fmt.Println(<-ch, <-ch, <-ch)
	fmt.Println("len:", len(ch))
}

المخزن يفصل المرسل عن المستقبل حتى لا توقف الدفعات القصيرة المرسل. لكنه لا يعالج منتجًا أسرع دائمًا من مستهلكه؛ هو فقط يؤخّر اللحظة التي يتوقّف فيها المرسل. اختر حجم المخزن لسبب (عدد المرسلين، حجم دفعة معروف)، لا لإخفاء جمود.

len(ch) لقطة لحظية. قبل أن تتصرّف بناءً عليها قد تكون goroutine أخرى غيّرتها، فلا تستخدمها لتقرّر هل سيتوقّف الإرسال. استخدم لذلك select مع حالة default.

الإغلاق وrange

تخبر close(ch) المستقبلين بأن لا قيم أخرى ستُرسل. بعد الإغلاق:

• القيم الموجودة في المخزن ما زالت تُسلَّم،
• بعدها يعيد كل استقبال القيمة الصفرية فورًا،
• تُبلغ v, ok := <-ch أن ok == false،
• تنتهي for v := range ch.

package main

import "fmt"

func produce(n int) <-chan int {
	ch := make(chan int)
	go func() {
		defer close(ch) // the sender closes, when it is done
		for i := range n {
			ch <- i * i
		}
	}()
	return ch
}

func main() {
	for v := range produce(5) {
		fmt.Println(v)
	}

	ch := make(chan string, 1)
	ch <- "last"
	close(ch)
	v, ok := <-ch
	fmt.Printf("%q %v\n", v, ok)
	v, ok = <-ch
	fmt.Printf("%q %v\n", v, ok)
}

الاستقبال الأول بعد close ما زال يحصل على "last" مع ok == true. والثاني يحصل على القيمة الصفرية "" وfalse.

قواعد تسبّب panic:

• الإرسال على قناة مغلقة يسبّب panic برسالة send on closed channel،
• إغلاق قناة مغلقة مسبقًا يسبّب panic،
• إغلاق قناة nil يسبّب panic.

لذلك يغلق طرف الإرسال فقط، ومرة واحدة. مع عدة مرسلين لا يعرف أي منهم متى انتهى الآخرون؛ اجعل goroutine منفصلة تنتظر كل المرسلين (بـ sync.WaitGroup) وتغلق القناة بعد أن تعود Wait. الإغلاق مطلوب فقط عندما ينتظر مستقبلٌ النهاية. القناة غير المغلقة التي لا يشير إليها شيء يجمعها جامع النفايات مثل أي قيمة أخرى.

أنواع الاتجاه

يمكن للدالة أن تصرّح بأنها ترسل فقط أو تستقبل فقط على قناة، فيرفض المترجم العملية الأخرى.

يتحوّل chan T ضمنيًا إلى أي من النوعين المقيّدين عند تمريره إلى دالة. لهذا تستطيع produce في الأعلى أن تعيد <-chan int: يمكن للمستدعين المرور عليها بـ range لكن لا يمكنهم الإرسال إليها ولا إغلاقها. استخدم أنواع الاتجاه في كل معامل دالة يناسبها ذلك، فهي توثّق الملكية وتحوّل سوء الاستخدام إلى خطأ ترجمة.

الجمود (Deadlock)

إذا توقّفت كل goroutine ولم يعد هناك ما يوقظ أيًا منها، يُنهي وقت التشغيل البرنامج:

package main

import "fmt"

func main() {
	ch := make(chan int)
	ch <- 1 // no other goroutine exists to receive
	fmt.Println(<-ch)
}

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan send]:
main.main()
	/tmp/main.go:7 +0x38
exit status 2

يخبرك تفريغ الـ goroutines بالعملية العالقة (chan send هنا، أو chan receive أو sync.WaitGroup.Wait أو select). الأسباب المعتادة:

• إرسال على قناة غير مخزّنة دون مستقبل يعمل،
• range على قناة لا تُغلق أبدًا،
• عدّاد WaitGroup لا يصل إلى الصفر أبدًا،
• goroutine تنتظر كل منهما الأخرى.

لا يكتشف وقت التشغيل إلا الحالة التي تعلق فيها كل الـ goroutines. في خادم فيه goroutines أخرى حيّة (مستمع HTTP، أو ticker) لا يسبّب الخطأ نفسه أي انهيار؛ الـ goroutine العالقة تتسرّب فقط.

القنوات nil

الإرسال والاستقبال على قناة nil يتوقّفان إلى الأبد. يبدو ذلك بلا فائدة لكنه حيلة معروفة داخل select: تعيين متغيّر قناة إلى nil يعطّل حالتها. المثال التالي يدمج قناتين ويتوقّف عن الاستماع إلى كل منهما بعد إغلاقها:

package main

import "fmt"

func main() {
	a := make(chan int)
	b := make(chan int)
	go func() { defer close(a); a <- 1; a <- 2 }()
	go func() { defer close(b); b <- 10 }()

	sum := 0
	for a != nil || b != nil {
		select {
		case v, ok := <-a:
			if !ok {
				a = nil // a is finished: never select it again
				continue
			}
			sum += v
		case v, ok := <-b:
			if !ok {
				b = nil
				continue
			}
			sum += v
		}
	}
	fmt.Println("sum:", sum)
}

دون تعيينات nil تكون القناة المغلقة جاهزة دائمًا، وستدور الحلقة على قيم صفرية.

خط معالجة (pipeline)

تتركّب القنوات في خطوط معالجة: كل مرحلة goroutine تستقبل من قناة وترسل إلى التالية، وتغلق مخرجها عندما ينتهي مدخلها.

package main

import "fmt"

func generate(nums ...int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out)
		for _, n := range nums {
			out <- n
		}
	}()
	return out
}

func square(in <-chan int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out)
		for n := range in {
			out <- n * n
		}
	}()
	return out
}

func main() {
	total := 0
	for v := range square(square(generate(1, 2, 3))) {
		fmt.Println(v)
		total += v
	}
	fmt.Println("total:", total)
}

كل مرحلة تعمل بالتزامن، وترتيب المخرجات ثابت (1، 16، 81) لأن كل مرحلة goroutine واحدة تحافظ على الترتيب. الإغلاقات تتتابع: generate تغلق، فتنتهي حلقة range في square، فتغلق مخرجها، وهكذا حتى main.

نقطة الضعف في هذا الخط: لو توقّفت main عن القراءة مبكرًا، لتوقّفت المراحل على عمليات الإرسال إلى الأبد. خطوط المعالجة الحقيقية تأخذ context.Context أو قناة done وتستخدم select عليها بجوار كل إرسال.

قناة أم mutex

القنوات لنقل ملكية البيانات والإشارة إلى الأحداث. أما sync.Mutex فأبسط لحماية حالة مشتركة تقرؤها وتحدّثها goroutines كثيرة في مكانها، مثل ذاكرة تخزين مؤقت أو عدّاد. بنية بداخلها mutex أوضح غالبًا من goroutine تملك الحالة وتخدم الطلبات عبر القنوات. استخدم ما يجعل الشيفرة أقصر والملكية واضحة.

مرجع سريع