الغوروتينات

الغوروتينات — Goroutines

تخيّل أنك في مطعم. في النموذج التقليدي، هناك نادل واحد يخدم طاولة واحدة في كل مرة — إذا طاولة طلبت شيئاً يأخذ وقتاً، كل الطاولات الأخرى تنتظر. في نموذج Go، هناك عشرات النوادل الخفيفين يخدمون كل الطاولات بالتوازي — وكل نادل لا يكلّف شيئاً تقريباً.

هذا هو مفهوم goroutine: خيط تنفيذ خفيف الوزن يعمل بالتزامن مع باقي البرنامج.

ما هي الـ goroutine؟

هي دالة تعمل بشكل متزامن مع دوال أخرى
أخف بكثير من خيوط نظام التشغيل (thread) — حوالي 2KB من الذاكرة مقابل ~1MB للخيط
يمكنك تشغيل آلاف أو ملايين منها بدون مشاكل
Go runtime يدير جدولتها (scheduling) تلقائياً

كلمة go

لتشغيل goroutine، أضف كلمة go قبل استدعاء الدالة:

main.go

package main

import (
    "fmt"
    "time"
)

// دالة تطبع رسائل — Function that prints messages
func printMessages(label string, count int) {
    for i := 1; i <= count; i++ {
        fmt.Printf("[%s] الرسالة %d\n", label, i)
        time.Sleep(100 * time.Millisecond)
    }
}

func main() {
    // تشغيل goroutine — Launch goroutine
    go printMessages("غوروتين-1", 3)
    go printMessages("غوروتين-2", 3)

    // الدالة الرئيسية تستمر — Main continues
    printMessages("الرئيسية", 3)

    // انتظار لرؤية النتائج — Wait to see results
    time.Sleep(500 * time.Millisecond)
}

Output:

لاحظ كيف أن الرسائل تتداخل — هذا لأنها تعمل بالتزامن! ترتيب الرسائل قد يتغير في كل تشغيل.

goroutine مع دالة مجهولة

main.go

package main

import (
    "fmt"
    "time"
)

func main() {
    // goroutine بدالة مجهولة — Anonymous function goroutine
    go func() {
        fmt.Println("مرحبا من goroutine مجهول!")
    }()

    // goroutine مع معاملات — With parameters
    for i := 1; i <= 3; i++ {
        go func(n int) {
            fmt.Printf("goroutine رقم %d\n", n)
        }(i) // مهم: مرّر i كمعامل! — Pass i as parameter!
    }

    time.Sleep(100 * time.Millisecond)
}

Output:

⚠️ الخطأ الكلاسيكي: متغير الحلقة

هذا من أشهر الأخطاء في Go (تم إصلاحه في Go 1.22 لكن يجب فهمه):

main.go

package main

import (
    "fmt"
    "time"
)

func main() {
    // ✅ الطريقة الصحيحة — تمرير كمعامل
    // Correct way — pass as parameter
    fmt.Println("الطريقة الصحيحة:")
    for i := 1; i <= 3; i++ {
        go func(n int) {
            fmt.Printf("  goroutine %d\n", n)
        }(i)
    }

    time.Sleep(100 * time.Millisecond)
}

Output:

دورة حياة goroutine

goroutine تنتهي عندما:

الدالة التي تعمل فيها تنتهي (return)
الدالة الرئيسية main تنتهي — عندها كل goroutines تتوقف فوراً!

هذا يعني أنك تحتاج طريقة لانتظار goroutines — وهنا تأتي القنوات (الدرس القادم) و sync.WaitGroup.

مثال عملي: تنزيل متوازي

main.go

package main

import (
    "fmt"
    "time"
)

// محاكاة تنزيل ملف — Simulate file download
func download(filename string, sizeMB int) {
    fmt.Printf("⬇️  بدء تنزيل %s (%dMB)...\n", filename, sizeMB)
    // محاكاة وقت التنزيل — Simulate download time
    time.Sleep(time.Duration(sizeMB*50) * time.Millisecond)
    fmt.Printf("✅ اكتمل تنزيل %s\n", filename)
}

func main() {
    start := time.Now()

    files := []struct {
        name string
        size int
    }{
        {"report.pdf", 5},
        {"photo.jpg", 3},
        {"video.mp4", 8},
        {"data.csv", 2},
    }

    // تنزيل متوازي — Parallel download
    fmt.Println("=== تنزيل متوازي ===")
    for _, f := range files {
        go download(f.name, f.size)
    }

    // انتظار اكتمال الكل — Wait for all to complete
    time.Sleep(500 * time.Millisecond)
    fmt.Printf("\nالوقت الكلي: %v\n", time.Since(start).Round(time.Millisecond))
    fmt.Println("(لو كان تسلسلياً لأخذ ~900ms!)")
}

Output:

كم goroutine يمكنك تشغيلها؟

main.go

package main

import (
    "fmt"
    "runtime"
    "sync/atomic"
    "time"
)

func main() {
    var count int64

    // تشغيل 10000 goroutine — Launch 10000 goroutines
    for i := 0; i < 10000; i++ {
        go func() {
            atomic.AddInt64(&count, 1)
            time.Sleep(10 * time.Millisecond)
        }()
    }

    time.Sleep(50 * time.Millisecond)
    fmt.Printf("goroutines نشطة: %d\n", runtime.NumGoroutine())
    fmt.Printf("goroutines أُطلقت: %d\n", atomic.LoadInt64(&count))
    fmt.Printf("أنوية المعالج: %d\n", runtime.NumCPU())
}

Output:

عشرة آلاف goroutine! جرّب ذلك مع threads في Java أو Python — ستواجه مشاكل. في Go، هذا عادي تماماً.

ملخص مهم

المفهوم	التفاصيل
`go f()`	يبدأ goroutine جديد
الحجم	~2KB (مقابل ~1MB للـ thread)
العدد	يمكن تشغيل الملايين
الجدولة	Go runtime يديرها تلقائياً
الإيقاف	تنتهي مع الدالة أو مع `main`
التحذير	`time.Sleep` ليس حلاً حقيقياً — استخدم القنوات أو WaitGroup

تحدي — Challenge

package main

import (
    "fmt"
    "time"
)

func task(id int) {
    time.Sleep(time.Duration(id*30) * time.Millisecond)
    fmt.Printf("مهمة %d اكتملت\n", id)
}

func main() {
    // شغّل task(1) و task(2) و task(3) كـ goroutines
    // اكتب الكود هنا

    time.Sleep(200 * time.Millisecond)
    fmt.Println("كل المهام اكتملت!")
}