كيف يتعامل Go مع التزامن بشكل أفضل من نماذج الخيوط التقليدية

في هندسة البرمجيات الحديثة، لم يعد بناء التطبيقات التي يمكنها أداء مهام متعددة في وقت واحد ترفًا، بل أصبح متطلبًا أساسيًا. بدءًا من خوادم الويب عالية الإنتاجية ووصولاً إلى خدمات البث في الوقت الفعلي، يقع التزامن في قلب الأداء.

لعقود من الزمن، اعتمدت لغات البرمجة التقليدية مثل C++ وJava وPython على نماذج الترابط الأصلية لنظام التشغيل للتعامل مع المهام المتزامنة. ومع ذلك، عندما صممت Google Go (Golang) في أواخر العقد الأول من القرن الحادي والعشرين، اتخذت مسارًا مختلفًا جذريًا. بدلاً من الكشف عن سلاسل عمليات نظام التشغيل الأولية، قدم Go Goroutines وM:N Scholer المتخصص.

في هذه المقالة، سنفحص القيود المعمارية لنماذج الترابط التقليدية ونستكشف سبب كون تصميم التزامن الخاص بـ Go أكثر كفاءة وقابلية للتطوير وملاءمة للمطورين.

1. اختناقات الخيوط التقليدية (نموذج 1:1)

تستخدم معظم أنظمة وقت التشغيل التقليدية نموذج الترابط 1:1. في هذا النموذج، يتم تعيين كل مؤشر ترابط تم إنشاؤه في رمز مساحة المستخدم مباشرة إلى مؤشر ترابط واحد لمساحة kernel يديره نظام التشغيل (OS).

على الرغم من بساطته، إلا أن هذا التعيين بنسبة 1:1 يقدم ثلاث اختناقات خطيرة:

أ. الحمل الزائد للذاكرة (أحجام المكدسات الكبيرة)

يعد مؤشر ترابط نظام التشغيل موردًا ثقيلًا. افتراضيًا، تقوم أنظمة التشغيل بتخصيص حجم مكدس ثابت ومتجاور لكل مؤشر ترابط (عادةً 1 ميجابايت إلى 8 ميجابايت).

• إذا كنت تريد التعامل مع 10000 اتصال متزامن، فإن تخصيص 10000 سلسلة عمليات لنظام التشغيل سيتطلب ما بين 10 جيجابايت و80 جيجابايت من ذاكرة الوصول العشوائي فقط لذاكرة مكدس الخيوط فقط.
• وهذا يجعل التعامل مع التزامن العالي في ظل اتصال عالي أمرًا مكلفًا للغاية ومستحيلًا تقريبًا على أجهزة الخادم القياسية.

ب. ارتفاع تكاليف تبديل السياق

عندما يقوم نظام التشغيل بتبديل التنفيذ من مؤشر ترابط إلى آخر، فإنه يقوم بإجراء تبديل السياق. نظرًا لأن سلاسل عمليات نظام التشغيل تتم إدارتها بواسطة kernel، يتطلب تبديل السياق عبور حدود المستخدم kernel. يجب على وحدة المعالجة المركزية:

1. حفظ حالة السجلات الحالية.
2. مسح خطوط ذاكرة التخزين المؤقت لوحدة المعالجة المركزية وتحديث جداول الصفحات (المخازن المؤقتة للترجمة Lookaside).
3. انتقل إلى وضع kernel، وحدد الموضوع التالي، وقم بتحميل حالته المحفوظة.
4. العودة إلى وضع المستخدم.

تستغرق هذه الرحلة ذهابًا وإيابًا بأكملها حوالي 1 إلى 2 ميكروثانية، وهو ما يمثل مئات أو آلاف دورات وحدة المعالجة المركزية التي يتم إنفاقها فقط على النفقات الإدارية بدلاً من تنفيذ منطق العمل الفعلي.

ج. حدود جدولة نظام التشغيل

جدولة نظام التشغيل للأغراض العامة. فهو يتعامل مع سلاسل عمليات قاعدة البيانات، وسلاسل واجهة المستخدم، واتصالات الشبكة خفيفة الوزن بنفس أساليب الجدولة الاستدلالية. نظرًا لأنه لا يفهم السياق على مستوى التطبيق، فلا يمكنه تحسين الجدولة بناءً على ما إذا كان مؤشر الترابط محظورًا على مقبس الشبكة، أو في انتظار القفل الداخلي، أو إجراء حساب نشط.

2. حل Go: برنامج جدولة M:N (Goroutines)

يتجاوز Go قيود ترابط نظام التشغيل عن طريق تقديم Goroutines وتنفيذ جدولة وقت التشغيل الخاصة به. بدلاً من تعيين سلاسل الرسائل 1:1، يستخدم Go نموذج جدولة M:N حيث يتم إرسال goroutines M خفيفة الوزن إلى سلاسل عمليات نظام التشغيل الفعلية N.

تخضع هذه البنية لثلاثة عناصر هيكلية أساسية، يُشار إليها غالبًا باسم نموذج GMP:

• G (Goroutine): يمثل goroutine واحد. يتضمن مكدس تنفيذ goroutine وعداد البرنامج والحالة. G ليس سلسلة رسائل نظام التشغيل؛ إنها بنية Go بسيطة لا تكلف سوى حوالي 2 كيلو بايت من الذاكرة للتهيئة.
• M (الجهاز): يمثل خيط نظام التشغيل/النواة الفعلي. تتم إدارته بواسطة برنامج جدولة نظام التشغيل وهو مسؤول عن تنفيذ تعليمات كود الجهاز الخاصة بـ goroutines.
• P (المعالج): يمثل المعالج المنطقي أو سياق التنفيذ. يكون عدد مثيلات P افتراضيًا هو عدد مراكز وحدة المعالجة المركزية المنطقية على الجهاز المضيف (التي يتم التحكم فيها بواسطة GOMAXPROCS). يجب أن يحصل الجهاز M على معالج منطقي P لتشغيل كود Go.

لماذا يعتبر نموذج GMP متفوقًا

نظرًا لأن goroutines تتم إدارتها بالكامل في مساحة المستخدم من خلال وقت تشغيل Go:

1. المكدسات الديناميكية: يبدأ goroutine بمجموعة صغيرة من 2 كيلو بايت. وفقًا لمتطلبات التنفيذ، تنمو المكدس ديناميكيًا (تخصيص أجزاء ذاكرة متجاورة أكبر في الكومة) وتتقلص. يتيح ذلك لـ Go تشغيل مئات الآلاف من goroutines في وقت واحد على جهاز كمبيوتر محمول واحد.
2. مفاتيح السياق السريعة: يحدث التبديل بين goroutines بالكامل في مساحة المستخدم دون استدعاء محولات سياق kernel. يتم حفظ عداد البرنامج وعدد قليل من سجلات وحدة المعالجة المركزية فقط. يستغرق مفتاح تبديل سياق مساحة المستخدم هذا 10 إلى 100 نانو ثانية فقط — أي ما يقرب من 10x إلى 100x أسرع من محول مؤشر ترابط نظام التشغيل.

3. سرقة العمل وعدم حظر الإدخال/الإخراج

يستخدم وقت تشغيل Go آليتين متقدمتين للجدولة لضمان عدم استغلال مراكز وحدة المعالجة المركزية الفعلية بشكل كافٍ: سرقة العمل وSyscall Hand-off.

أ. خوارزمية سرقة العمل

يحتفظ كل معالج منطقي P بقائمة انتظار التشغيل المحلية الخاصة به من goroutines. بالإضافة إلى ذلك، هناك قائمة انتظار تشغيل عمومية لتجاوز السعة. إذا استنفد المعالج P جميع goroutines في قائمة انتظار التشغيل المحلية الخاصة به، فلن يدخل في وضع السكون. بدلاً من ذلك، يقوم بتنفيذ سرقة العمل: فهو يتحقق من المعالجات المنطقية الأخرى ويسرق نصف إجراءاتها الموضوعة في قائمة الانتظار لتحقيق التوازن بين عبء العمل عبر جميع مراكز وحدة المعالجة المركزية.

Local Queue P1: [ G1, G2, G3 ]  ---> Running on Thread M1
Local Queue P2: [ ]            ---> Running on Thread M2 (Idle)
                                     P2 steals G3 and G2 from P1!

ب. جهاز استطلاع الشبكة والإدخال/الإخراج غير المحظور

عندما يقوم goroutine بإجراء إدخال/إخراج للشبكة (على سبيل المثال، القراءة من اتصال قاعدة البيانات أو إجراء مكالمة HTTP)، فإن Go لا يحظر مؤشر ترابط نظام التشغيل الأساسي M.

بدلاً من ذلك، يقوم وقت تشغيل Go بتسجيل الكتلة باستخدام Network Poller المخصص (الذي يستخدم واجهات برمجة التطبيقات المتعددة الإرسال الفعالة الخاصة بنظام التشغيل مثل epoll على نظام Linux، أو kqueue على نظام macOS، أو IOCP على نظام Windows). تم فصل goroutine المحظور G عن مؤشر الترابط M وإيقافه في أداة استقصاء الشبكة.

يلتقط مؤشر الترابط M على الفور goroutine آخر قابل للتشغيل من قائمة الانتظار. بمجرد اكتمال حدث الإدخال/الإخراج، يقوم مُستقصي الشبكة بنقل G مرة أخرى إلى قائمة انتظار التشغيل النشطة لاستئناف التنفيذ.

4. القنوات مقابل الذاكرة المشتركة (نموذج CSP)

تقوم نماذج الخيوط التقليدية بتنسيق المهام المتزامنة من خلال مشاركة الذاكرة (على سبيل المثال، تمرير المؤشرات بين الخيوط). لمنع سباقات البيانات، يجب على المطورين إدارة الأقفال وكائنات المزامنة ومتغيرات الحالة يدويًا:

// Traditional Java Shared Memory Approach
synchronized(lock) {
    sharedResource.updateState();
}

هذا النموذج معروف بأنه عرضة للأخطاء، مما يؤدي في كثير من الأحيان إلى حالات توقف تام، وظروف السباق، واختناقات تماسك ذاكرة التخزين المؤقت.

تطبق Go النموذج الرسمي الاتصال بالعمليات المتسلسلة (CSP)، والذي يلخصه مثل Golang الشهير:

“لا تتواصل من خلال مشاركة الذاكرة، بل شارك الذاكرة من خلال التواصل.”

يوفر Go القنوات كأوليات من الدرجة الأولى. تعمل القنوات كقوائم انتظار آمنة للنوع تسمح لـ goroutines بإرسال واستقبال الرسائل لمزامنة التنفيذ ونقل ملكية البيانات.

5. التنفيذ العملي: الإجراءات والقنوات قيد التنفيذ

فيما يلي برنامج Go العملي الذي يوضح كيف يمكن لـ goroutines العاملة المتعددة معالجة المهام بشكل متزامن وإرجاع النتائج من خلال قناة، وإدارة تدفق البيانات بأمان دون أقفال.

package main

import (
	"fmt"
	"time"
)

// Task represents a unit of work
type Task struct {
	ID       int
	Duration time.Duration
}

// Result represents the outcome of a processed task
type Result struct {
	TaskID int
	Value  string
}

// worker processes incoming tasks from the jobs channel and sends results
func worker(id int, jobs <-chan Task, results chan<- Result) {
	for job := range jobs {
		fmt.Printf("Worker %d: Started processing job %d\n", id, job.ID)
		time.Sleep(job.Duration) // Simulate CPU/IO delay
		
		results <- Result{
			TaskID: job.ID,
			Value:  fmt.Sprintf("Processed by worker %d in %v", id, job.Duration),
		}
	}
}

func main() {
	// Create tasks
	tasks := []Task{
		{ID: 101, Duration: 200 * time.Millisecond},
		{ID: 102, Duration: 400 * time.Millisecond},
		{ID: 103, Duration: 100 * time.Millisecond},
		{ID: 104, Duration: 300 * time.Millisecond},
	}

	// Buffered channels prevent sender blocking
	jobs := make(chan Task, len(tasks))
	results := make(chan Result, len(tasks))

	// Spawn 3 concurrent worker goroutines
	for w := 1; w <= 3; w++ {
		go worker(w, jobs, results)
	}

	// Feed tasks into the job channel
	for _, task := range tasks {
		jobs <- task
	}
	close(jobs) // Closing tells workers no more jobs are coming

	// Collect and aggregate results
	for i := 0; i < len(tasks); i++ {
		res := <-results
		fmt.Printf("[RESULT] Job %d: %s\n", res.TaskID, res.Value)
	}
	close(results)
}

6. مقارنة البنية: سلاسل عمليات نظام التشغيل مقابل Goroutines

خاتمة

من خلال فصل التزامن عن نموذج الترابط الأولي لنظام التشغيل، حل Go مشكلات القياس الأساسية للبنيات الخلفية الحديثة.

تعمل Goroutines على تمكين التزامن الهائل مع الحد الأدنى من الحمل على الذاكرة، ويعمل برنامج جدولة M:N على تحسين استخدام وحدة المعالجة المركزية من خلال سرقة العمل دون تكاليف تبديل سياق kernel، وتوفر القنوات نموذجًا آمنًا ومعبرًا للتزامن.

سواء كنت تقوم ببناء خدمات صغيرة أو أنظمة موزعة كبيرة، تضمن بنية التزامن المضمنة في Go أن يظل تطبيقك سريع الاستجابة، وفعالاً في استخدام الموارد، وسهل الصيانة.

استكشف المزيد من الرؤى المتعلقة بتطوير البرامج وهندسة الواجهة الخلفية على مدونة Gaznix →