القنوات

القنوات — Channels

القنوات هي الطريقة الرسمية للتواصل بين goroutines في Go. تخيّلها كأنابيب: goroutine واحد يُرسل قيمة من طرف، و goroutine آخر يستقبلها من الطرف الآخر.

القنوات تحل مشكلتين:

التواصل — تمرير البيانات بين goroutines
التزامن — ضمان ترتيب العمليات

إنشاء قناة واستخدامها

main.go

package main

import "fmt"

func main() {
    // إنشاء قناة — Create a channel
    ch := make(chan string)

    // إرسال من goroutine — Send from goroutine
    go func() {
        ch <- "السلام عليكم من goroutine!"
    }()

    // استقبال في main — Receive in main
    msg := <-ch
    fmt.Println(msg)
}

Output:

كيف تعمل القناة غير المُخزّنة — Unbuffered Channel

القناة غير المُخزّنة (الافتراضية) تعمل كنقطة تسليم مباشرة:

المُرسل ينتظر حتى يكون هناك مُستقبل
المُستقبل ينتظر حتى يكون هناك مُرسل
يتم التبادل في نفس اللحظة — هذا يُسمى synchronization

main.go

package main

import (
    "fmt"
    "time"
)

// عامل يُنجز مهمة — Worker that completes a task
func worker(id int, done chan bool) {
    fmt.Printf("عامل %d: بدأ العمل...\n", id)
    time.Sleep(time.Duration(id*100) * time.Millisecond)
    fmt.Printf("عامل %d: أنهى العمل ✅\n", id)
    done <- true // إشارة الإنجاز — Signal completion
}

func main() {
    done := make(chan bool)

    go worker(1, done)
    go worker(2, done)
    go worker(3, done)

    // انتظار إنجاز الثلاثة — Wait for all three
    for i := 0; i < 3; i++ {
        <-done
    }
    fmt.Println("كل العمال أنهوا عملهم!")
}

Output:

القنوات المُخزّنة — Buffered Channels

القناة المُخزّنة لها سعة — المُرسل لا ينتظر إلا إذا امتلأت القناة:

main.go

package main

import "fmt"

func main() {
    // قناة بسعة 3 — Buffered channel with capacity 3
    ch := make(chan string, 3)

    // الإرسال لا يُعيق لأن هناك مساحة
    // Sends don't block because there's room
    ch <- "رسالة 1"
    ch <- "رسالة 2"
    ch <- "رسالة 3"
    // ch <- "رسالة 4"  // هذا سيُعيق! القناة ممتلئة — Would block! Channel full

    fmt.Println("السعة:", cap(ch))
    fmt.Println("العدد الحالي:", len(ch))

    // الاستقبال — Receive
    fmt.Println(<-ch)
    fmt.Println(<-ch)
    fmt.Println(<-ch)
}

Output:

متى تستخدم كل نوع؟

النوع	متى
غير مُخزّن	تريد تزامناً مضموناً (تسليم مباشر)
مُخزّن	تريد فصل المُرسل عن المُستقبل (مثل قائمة مهام)

التكرار على قناة — Range over Channel

main.go

package main

import "fmt"

// مولّد الأرقام — Number generator
func generateNumbers(max int, ch chan int) {
    for i := 1; i <= max; i++ {
        ch <- i
    }
    close(ch) // أغلق القناة عند الانتهاء — Close when done
}

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

    go generateNumbers(5, ch)

    // range يتوقف تلقائياً عند إغلاق القناة
    // range stops automatically when channel is closed
    for n := range ch {
        fmt.Printf("استقبلت: %d\n", n)
    }
    fmt.Println("القناة أُغلقت، انتهى التكرار")
}

Output:

قواعد الإغلاق:

فقط المُرسل يغلق القناة — أبداً المُستقبل
الإرسال لقناة مغلقة يسبب panic
الاستقبال من قناة مغلقة يُرجع القيمة الصفرية فوراً

اتجاه القناة — Channel Direction

يمكنك تحديد اتجاه القناة في معاملات الدوال لزيادة الأمان:

main.go

package main

import "fmt"

// يُرسل فقط — Send only
func producer(ch chan<- int) {
    for i := 1; i <= 5; i++ {
        ch <- i * 10
    }
    close(ch)
}

// يستقبل فقط — Receive only
func consumer(ch <-chan int) {
    for val := range ch {
        fmt.Printf("استهلكت: %d\n", val)
    }
}

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

    go producer(ch)
    consumer(ch)
}

Output:

⚠️ الجمود — Deadlock

الجمود يحدث عندما ينتظر الجميع ولا أحد يعمل:

// ❌ جمود! main ينتظر ولا أحد يُرسل
ch := make(chan int)
<-ch  // deadlock!

// ❌ جمود! main يُرسل ولا أحد يستقبل (قناة غير مُخزّنة)
ch := make(chan int)
ch <- 42  // deadlock!

Go يكتشف الجمود ويُوقف البرنامج برسالة: fatal error: all goroutines are asleep - deadlock!

نمط عملي: خط أنابيب — Pipeline Pattern

main.go

package main

import "fmt"

// مرحلة 1: توليد الأرقام — Stage 1: Generate numbers
func generate(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        for _, n := range nums {
            out <- n
        }
        close(out)
    }()
    return out
}

// مرحلة 2: تربيع — Stage 2: Square
func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n * n
        }
        close(out)
    }()
    return out
}

// مرحلة 3: طباعة — Stage 3: Print
func print(in <-chan int) {
    for n := range in {
        fmt.Println(n)
    }
}

func main() {
    // ربط المراحل — Chain stages
    nums := generate(2, 3, 4, 5)
    squares := square(nums)
    print(squares)

    // أو بسطر واحد — Or in one line
    // print(square(generate(2, 3, 4, 5)))
}

Output:

تحدي — Challenge

package main

import "fmt"

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

    // أرسل مربعات 1 إلى 10 عبر القناة في goroutine
    // ثم أغلق القناة — اكتب الكود هنا
    go func() {
        // اكتب الكود هنا
        close(ch)
    }()

    // اجمع الكل — Sum all
    sum := 0
    for n := range ch {
        sum += n
    }
    fmt.Printf("المجموع: %d\n", sum)
}