التزامن في Swift: الخيوط، المهام الخفيفة و async/await — كيف لا تفقد صوابك

مقدمة: لماذا لا يتجمد هاتف iPhone الخاص بك أثناء تمرير الشاشة؟

هل تساءلت يومًا لماذا لا تتباطأ تطبيقات iOS الحديثة، حتى عندما تقوم بتحميل عشرات الصور في وقت واحد، ومعالجة النقرات وكتابة البيانات في قاعدة البيانات؟ الإجابة بسيطة — التزامن. في عالم Swift (وليس فقط) هذا هو أحد أكثر المواضيع سخونة. وإذا كنت تكتب بلغة Swift ولكنك لا تزال مرتبكًا بين الخيوط والمهام الخفيفة و async/await الجديدة — مرحبًا بك في النادي. اليوم سنقوم بترتيب كل شيء، ليجعل كودك يطير بدلاً من أن يزحف.

في هذه المقالة، لن نقوم فقط بسرد التعريفات الجافة. سننظر إلى أمثلة حقيقية، ونقارن بين الأساليب ونجيب على السؤال الرئيسي: ماذا تختار لمشروعك — GCD القديم الجيد أم Swift Concurrency الجديد؟

الخيوط: الأساس الذي يقوم عليه كل شيء

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

في Swift، كانت الأداة الرئيسية للعمل مع الخيوط لفترة طويلة هي Grand Central Dispatch (GCD). كنت ببساطة تنشئ قائمة انتظار وترسل إليها إغلاقًا:

DispatchQueue.global(qos: .background).async {\n    // عمل ثقيل في الخلفية\n    let result = heavyComputation()\n    DispatchQueue.main.async {\n        // تحديث واجهة المستخدم على الخيط الرئيسي\n        self.label.text = result\n    }\n}

كل شيء بسيط، أليس كذلك؟ لكن GCD له تفاصيل دقيقة:

\n
• أنت مسؤول عن العودة إلى الخيط الرئيسي (من السهل نسيان ذلك والحصول على تعطل).
\n
• لا يوجد دعم مدمج لإلغاء المهام (يجب كتابة علامات يدويًا).
\n
• من الصعب معالجة سلاسل العمليات التابعة دون تداخل الإغلاقات (ما يسمى بـ "callback hell").
\n

ومع ذلك، لا يزال GCD حيًا ويُستخدم في المشاريع القديمة. لكن Swift الحديث يقدم شيئًا أكثر أناقة بكثير.

المهام الخفيفة في Swift؟ لا، هذا ليس Go

عند الحديث عن المهام الخفيفة (goroutines)، عادةً ما يتذكر المرء Go. في Swift لا يوجد نظير مباشر للمهام الخفيفة، ولكن هناك مهام خفيفة الوزن (tasks) تتصرف بشكل مشابه جدًا. إنها غير مرتبطة بخيط معين — النظام نفسه يقرر على أي خيط ينفذ المهمة، ويمكنه تبديلها بين الخيوط دون إنشاء خيوط جديدة لكل استدعاء.

على عكس الخيوط التي "تزن" حوالي 8 كيلوبايت من المكدس لكل منها، فإن مهام Swift Concurrency لا تزن شيئًا تقريبًا. يمكنك تشغيل آلاف المهام دون خطر تجاوز الذاكرة. هذا هو "التزامن بدون ألم".

انظر كيف يبدو هذا:

Task {\n    let image = await downloadImage(from: url)\n    await MainActor.run {\n        self.imageView.image = image\n    }\n}

هل لاحظت؟ لا يوجد DispatchQueue.main.async. فقط await MainActor.run. نظيف، مفهوم، آمن.

async/await: الثورة التي حدثت

مع إصدار Swift 5.5، ظهر دعم مدمج لـ async/await. هذا ليس مجرد سكر نحوي — إنه تغيير في النموذج. الآن يمكنك كتابة كود غير متزامن كما لو كان متزامنًا، ولكن دون حظر الخيط.

الإعلان عن دالة غير متزامنة بسيط:

func fetchUserData() async throws -> User {\n    let url = URL(string: "https://api.example.com/user")!\n    let (data, _) = try await URLSession.shared.data(from: url)\n    return try JSONDecoder().decode(User.self, from: data)\n}

واستدعاؤها أسهل:

Task {\n    do {\n        let user = try await fetchUserData()\n        print("User nam