من fullstack تعرف مشكلة C10K وحلّ Node لها: خيط واحد، event loop، عدم حجب أبدًا. تلك إجابة مشروعة — لكنها تتجنب التزامن الحقيقي بدل حلّ مشاكله. هذا الإقليم يعطيك الإجابة الأخرى: خيوط نظام تشغيل حقيقية، تنفيذ متوازٍ فعليًا على أنوية متعددة — لكن بلا الكابوس الذي يعرفه كل من كتب خيوطًا في C. والمفاجأة: البديهيتان اللتان بنيتَهما من الإقليم ٠١ لذاكرة خيط واحد فقط — ستكتشف الآن أنهما كانتا، طوال الوقت، تحلّان مشكلة أكبر بكثير.

الدرس ١: جرّب، قبل أن تُقال لك القاعدة

اللغز التأسيسي

use std::thread;

fn main() {
    let mut data = vec![1, 2, 3];
    let h1 = thread::spawn(move || { data.push(4); });
    let h2 = thread::spawn(move || { data.push(5); });  // ماذا يقول المترجم؟
    h1.join().unwrap();
    h2.join().unwrap();
}

use std::rc::Rc;
use std::cell::RefCell;
let data = Rc::new(RefCell::new(vec![1, 2, 3]));
let d1 = Rc::clone(&data);
let h1 = thread::spawn(move || { d1.borrow_mut().push(4); });  // ارفض! اقرأ لماذا

القاعدة التي كانت موجودة طوال الوقت

توقف وتأمّل ما حدث للتو: لم تحتج اللغة قاعدة جديدة واحدة للتزامن. البديهية الأولى (مالك واحد) رفضت السباق الأول. تصميم Rc (غير ذرّي عمدًا، لأن الذرّية لها ثمن أداء لا مبرر لدفعه في سياق خيط واحد) رفض الثاني. هذه هي "الصدفة": قواعد صُمِّمت بالكامل لحل مشاكل ذاكرة داخل خيط واحد — تبيّن أن سباق البيانات بين خيطين هو، من منظور نوع القيمة، نفس المشكلة تمامًا: أكثر من "مالك" فعّال لنفس الذاكرة، أحدهم يكتب. البديهيتان لا تعرفان الفرق بين "خيطين" و"نطاقين متداخلين في نفس الخيط" — وهذا هو سرّ المتانة.

الدرس ٢: Send وSync — الاسم الرسمي لما رأيتَه للتو

pub unsafe auto trait Send {}   // (تقريب توضيحي لتعريفها الفعلي)
pub unsafe auto trait Sync {}

هاتان سمتان (traits) بلا أي طريقة — علامتان محضتان:

• Send: يجوز نقل ملكية هذه القيمة إلى خيط آخر بأمان.
• Sync: يجوز مشاركة &T لهذه القيمة بين خيوط بأمان (تعريفًا: T هي Sync إذا وفقط إذا &T هي Send).

الكلمة auto تعني: المترجم يشتقّهما بنيويًا بلا derive صريح — أي نوع كل حقوله Send هو Send تلقائيًا؛ وينسحب العكس أيضًا: نوع فيه حقل واحد ليس Send (كعدّاد Rc غير الذرّي) يصير تلقائيًا غير Send، بلا أي إعلان سلبي صريح مطلوب منك. هذا فرق عن #[derive(...)] من الإقليم ٠٤ (ذاك توليد كود تطلبه صراحةً؛ هذا استنتاج بنيوي يحدث سواء طلبتَه أو لا). تقريبًا كل نوع "عادي" Send + Sync تلقائيًا؛ Rc استثناء متعمَّد (non-auto عبر آلية داخلية تعطّل الاستنتاج له تحديدًا)، ومؤشرات خام (سترى في ٠٩) استثناء آخر.

thread::spawn يشترط إغلاقًا 'static + Send — الآن تقرأ هذا التوقيع بمعنى كامل: 'static لأن الخيط قد يعيش أطول من مُستدعيه (الإقليم ٠٥)، Send لأن ملكية كل ما التُقِط ستُنقَل فعليًا لخيط آخر.

الدرس ٣: Arc<T> وMutex<T> — التوءمان الذرّيان لـ Rc وRefCell

الحل ليس نوعًا جديد المفهوم — إنه نفس نمط الإقليم ٠٧، بنسخة مصمَّمة لتحمل تعديلًا متزامنًا فعليًا بأمان:

use std::sync::{Arc, Mutex};
use std::thread;

let data = Arc::new(Mutex::new(vec![1, 2, 3]));
let mut handles = vec![];
for i in 4..=5 {
    let d = Arc::clone(&data);
    handles.push(thread::spawn(move || {
        d.lock().unwrap().push(i);   // .lock() تُرجع Result — Mutex قد "يتسمم"
    }));
}
for h in handles { h.join().unwrap(); }
println!("{:?}", *data.lock().unwrap());

.lock() تُرجع Result<MutexGuard<T>, PoisonError<...>> — Result من الإقليم ٠٣ مجددًا. لماذا قد يفشل قفل؟ التسميم (poisoning): لو انهار (panic) خيط وهو حامل للقفل، يُعلَّم الـ Mutex "مسموم" — أي خيط لاحق يحاول قفله يستلم Err بدل الانتظار الأبدي على بيانات ربما تُركت في منتصف تحديث غير مكتمل. هذا ميزة أمان، لا عيب: صمت مثل هذا الفشل كان ليعني بيانات تالفة منطقيًا تُقرأ بثقة زائفة.

الدرس ٤: القنوات — "لا تتشارك الذاكرة للتواصل؛ تواصل لتتشارك الذاكرة"

بديل معماري لا يشارك ذاكرة أصلًا — يُرسل قيمًا مملوكة بالكامل بين الخيوط:

use std::sync::mpsc;
use std::thread;

let (tx, rx) = mpsc::channel();
thread::spawn(move || {
    tx.send(String::from("hello from thread")).unwrap();
});
let msg = rx.recv().unwrap();
println!("{msg}");

mpsc = multiple producer, single consumer (tx قابلة للاستنساخ بـ .clone() لمرسلين عدة؛ rx واحد فقط). tx.send(v) ينقل ملكية v فعليًا عبر القناة — بعد الإرسال، v ميتة في خيط المرسِل تمامًا كأي move عادي من الإقليم ٠١. لا يمكنك عمليًا أن تُسابق نفسك على قيمة أرسلتَها، لأن لا طريقة نحوية للوصول إليها بعد الإرسال. البديهية الأولى تحرس القنوات أيضًا، بلا أي كود إضافي خاص بالتزامن.

اختر بين Arc<Mutex<T>> والقنوات بذوق مكتسب لا بقاعدة صارمة: حالة مشتركة يقرؤها ويكتبها الجميع بكثرة ← غالبًا Mutex أوضح؛ تدفّق بيانات باتجاه واحد بين مراحل معالجة (بايبلاين) ← القنوات أوضح نيّة وأصعب في كسرها بالخطأ.

الألغاز

let counter = 0;
let mut handles = vec![];
for _ in 0..10 {
    handles.push(thread::spawn(move || { counter += 1; }));
}

الخلاصة

• العقدة الجديدة: Send/Sync (سمتان تلقائيتان بلا طرق)، Arc/ Mutex (توءما Rc/RefCell الذرّيان)، thread::spawn، والقنوات (mpsc) كبديل لمشاركة الذاكرة.
• الوصلة للخلف: هذا الإقليم بأكمله لم يقدّم قاعدة أمان واحدة جديدة فعليًا — كل ما رأيتَه امتداد مباشر لملكية ٠١، استعارة ٠٢، وتفاوض ٠٧. "تزامن بلا خوف" ليس شعارًا تسويقيًا؛ إنه وصف دقيق لكون التزامن هنا حالة خاصة من مشكلة عامة حلّتها اللغة قبل أن تفكر أصلًا في الخيوط.
• الوصلة للأمام: خيوط نظام التشغيل حقيقية لكنها مكلفة — ميغابايت من الـ stack لكل خيط، وتبديل سياق (context switch) يُدار بواسطة نواة النظام. عشرة آلاف اتصال متزامن بعشرة آلاف خيط هو بالضبط الجدار الذي اصطدم به Node واختار event loop بدل تسلّقه (fullstack). فهل يملك Rust — التي رفضت GC ورفضت runtime مدمجًا — حلًّا لعشرة آلاف اتصال بلا عشرة آلاف خيط؟