دليل سهل جداً
لتزامن Swift

الكود غير المتزامن: async/await

معظم ما تفعله التطبيقات هو الانتظار. جلب البيانات من خادم - انتظر الرد. قراءة ملف من القرص - انتظر البايتات. استعلام قاعدة بيانات - انتظر النتائج.

قبل نظام التزامن في Swift، كنت تعبر عن هذا الانتظار باستخدام callbacks أو delegates أو Combine. كلها تعمل، لكن الـ callbacks المتداخلة تصبح صعبة المتابعة، وCombine له منحنى تعليمي حاد.

async/await يعطي Swift طريقة جديدة للتعامل مع الانتظار. بدلاً من الـ callbacks، تكتب كوداً يبدو متسلسلاً - يتوقف مؤقتاً، ينتظر، ويستأنف. خلف الكواليس، يدير runtime الـ Swift هذه التوقفات بكفاءة. لكن جعل تطبيقك يبقى متجاوباً أثناء الانتظار يعتمد على أين يعمل الكود، وهو ما سنغطيه لاحقاً.

الدالة غير المتزامنة هي دالة قد تحتاج إلى التوقف مؤقتاً. تضع علامة async عليها، وعندما تستدعيها، تستخدم await لتقول "توقف هنا حتى ينتهي هذا":

func fetchUser(id: Int) async throws -> User {
    let url = URL(string: "https://api.example.com/users/\(id)")!
    let (data, _) = try await URLSession.shared.data(from: url)  // يتعلق هنا
    return try JSONDecoder().decode(User.self, from: data)
}

// استدعاؤها
let user = try await fetchUser(id: 123)
// الكود هنا يعمل بعد اكتمال fetchUser

كودك يتوقف مؤقتاً عند كل await - هذا يسمى التعليق. عندما ينتهي العمل، يستأنف كودك من حيث توقف. التعليق يعطي Swift الفرصة للقيام بعمل آخر أثناء الانتظار.

الانتظار لـ عدة أشياء

ماذا لو احتجت جلب عدة أشياء؟ يمكنك انتظارها واحدة تلو الأخرى:

let avatar = try await fetchImage("avatar.jpg")
let banner = try await fetchImage("banner.jpg")
let bio = try await fetchBio()

لكن هذا بطيء - كل واحدة تنتظر السابقة لتنتهي. استخدم async let لتشغيلها بالتوازي:

func loadProfile() async throws -> Profile {
    async let avatar = fetchImage("avatar.jpg")
    async let banner = fetchImage("banner.jpg")
    async let bio = fetchBio()

    // الثلاثة جميعاً يجلبون بالتوازي!
    return Profile(
        avatar: try await avatar,
        banner: try await banner,
        bio: try await bio
    )
}

كل async let يبدأ فوراً. الـ await يجمع النتائج.

إدارة العمل: المهام

المهمة هي وحدة عمل غير متزامن يمكنك إدارتها. كتبت دوال async، لكن المهمة هي ما يشغلها فعلاً. إنها كيف تبدأ كوداً async من كود متزامن، وتعطيك التحكم في ذلك العمل: انتظر نتيجته، ألغه، أو اتركه يعمل في الخلفية.

لنقل أنك تبني شاشة ملف شخصي. حمّل الصورة عندما تظهر الواجهة باستخدام معدّل .task، الذي يُلغى تلقائياً عندما تختفي الواجهة:

struct ProfileView: View {
    @State private var avatar: Image?

    var body: some View {
        Group {
            if let avatar {
                avatar
            } else {
                ProgressView()
            }
        }
        .task { avatar = await downloadAvatar() }
    }
}

إذا كان المستخدمون يمكنهم التبديل بين الملفات الشخصية، استخدم .task(id:) لإعادة التحميل عندما يتغير الاختيار:

struct ProfileView: View {
    var userID: String
    @State private var avatar: Image?

    var body: some View {
        Group {
            if let avatar {
                avatar
            } else {
                ProgressView()
            }
        }
        .task(id: userID) { avatar = await downloadAvatar(for: userID) }
    }
}

عندما ينقر المستخدم على "حفظ"، أنشئ مهمة يدوياً:

Button("Save") {
    Task { await saveProfile() }
}

الوصول لنتائج المهام

عندما تنشئ Task، تحصل على مقبض. استخدم .value للانتظار واسترجاع النتيجة:

let handle = Task {
    return await fetchUserData()
}
let userData = await handle.value  // يتوقف حتى تكتمل المهمة

هذا مفيد عندما تحتاج النتيجة لاحقاً، أو عندما تريد تخزين مقبض المهمة وانتظاره في مكان آخر.

ماذا لو احتجت تحميل الصورة والسيرة والإحصائيات كلها مرة واحدة؟ استخدم TaskGroup لجلبها بالتوازي:

try await withThrowingTaskGroup(of: Void.self) { group in
    group.addTask { avatar = try await downloadAvatar(for: userID) }
    group.addTask { bio = try await fetchBio(for: userID) }
    group.addTask { stats = try await fetchStats(for: userID) }
    try await group.waitForAll()
}

المهام داخل المجموعة هي مهام فرعية، مرتبطة بالأب. بعض الأشياء لتعرفها:

• الإلغاء ينتشر: ألغِ الأب، وجميع الأبناء يُلغون أيضاً
• الأخطاء: خطأ مُلقى يلغي الأشقاء ويُعاد إلقاؤه، لكن فقط عندما تستهلك النتائج بـ next() أو waitForAll() أو التكرار
• ترتيب الاكتمال: النتائج تصل عندما تنتهي المهام، ليس بالترتيب الذي أضفتها به
• ينتظر الجميع: المجموعة لا ترجع حتى يكتمل كل طفل أو يُلغى

هذا هو التزامن المنظم: عمل منظم في شجرة سهلة الفهم والتنظيف.

أين تعمل الأشياء: من الخيوط إلى نطاقات العزل

حتى الآن تحدثنا عن متى يعمل الكود (async/await) وكيف ننظمه (المهام). الآن: أين يعمل، وكيف نبقيه آمناً؟

العالم القديم: خيارات كثيرة، بدون أمان

قبل نظام التزامن في Swift، كان لديك عدة طرق لإدارة التنفيذ:

كل هذه عملت، لكن الأمان كان عليك بالكامل. المترجم لم يستطع المساعدة إذا نسيت الإرسال إلى main، أو إذا طابوران وصلا لنفس البيانات في وقت واحد.

المشكلة: سباقات البيانات

سباق البيانات يحدث عندما يصل خيطان لنفس الذاكرة في نفس الوقت، وواحد منهم على الأقل يكتب:

var count = 0

DispatchQueue.global().async { count += 1 }
DispatchQueue.global().async { count += 1 }

// سلوك غير محدد: تعطل، فساد ذاكرة، أو قيمة خاطئة

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

التحول: من الخيوط إلى العزل

نموذج التزامن في Swift يسأل سؤالاً مختلفاً. بدلاً من "على أي خيط يجب أن يعمل هذا؟"، يسأل: "من المسموح له بالوصول لهذه البيانات؟"

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

نطاقات العزل الثلاثة

1. MainActor

@MainActor هو actor عالمي يمثل نطاق عزل الخيط الرئيسي. إنه خاص لأن أطر واجهة المستخدم (UIKit، AppKit، SwiftUI) تتطلب الوصول للخيط الرئيسي.

@MainActor
class ViewModel {
    var items: [Item] = []  // محمي بعزل MainActor
}

عندما تضع علامة @MainActor على شيء، أنت لا تقول "أرسل هذا للخيط الرئيسي." أنت تقول "هذا ينتمي لنطاق عزل الـ main actor." المترجم يفرض أن أي شيء يصل إليه يجب أن يكون على MainActor أو يستخدم await لعبور الحدود.

2. Actors

الـ actor يحمي حالته القابلة للتغيير. يضمن أن قطعة واحدة فقط من الكود يمكنها الوصول لبياناته في وقت واحد:

actor BankAccount {
    var balance: Double = 0

    func deposit(_ amount: Double) {
        balance += amount  // آمن: الـ actor يضمن الوصول الحصري
    }
}

// من الخارج، يجب أن تنتظر لعبور الحدود
await account.deposit(100)

الـ Actors ليست خيوطاً. الـ actor هو حدود عزل. runtime الـ Swift يقرر أي خيط ينفذ كود الـ actor فعلاً. أنت لا تتحكم بذلك، ولا تحتاج لذلك.

3. Nonisolated

الكود الموسوم بـ nonisolated يخرج من عزل الـ actor. يمكن استدعاؤه من أي مكان بدون await، لكنه لا يستطيع الوصول لحالة الـ actor المحمية:

actor BankAccount {
    var balance: Double = 0

    nonisolated func bankName() -> String {
        "Acme Bank"  // لا وصول لحالة الـ actor، آمن للاستدعاء من أي مكان
    }
}

let name = account.bankName()  // لا حاجة لـ await

// يعمل على MainActor (الافتراضي)
func updateUI() async { }

// يعمل على خيط خلفي (اختياري)
@concurrent func processLargeFile() async { }

ما الذي يمكنه عبور نطاقات العزل: Sendable

نطاقات العزل تحمي البيانات، لكن في النهاية تحتاج لتمرير البيانات بينها. عندما تفعل، Swift يتحقق إذا كان ذلك آمناً.

فكر في الأمر: إذا مررت مرجعاً لفئة قابلة للتغيير من actor لآخر، كلا الـ actors يمكنهما تعديلها في نفس الوقت. هذا بالضبط سباق البيانات الذي نحاول منعه. لذا Swift يحتاج أن يعرف: هل هذه البيانات يمكن مشاركتها بأمان؟

الجواب هو بروتوكول Sendable. إنه علامة تخبر المترجم "هذا النوع آمن للتمرير عبر حدود العزل":

• أنواع Sendable يمكنها العبور بأمان (أنواع القيمة، البيانات غير القابلة للتغيير، الـ actors)
• أنواع Non-Sendable لا يمكنها (الفئات ذات الحالة القابلة للتغيير)

// Sendable - إنه نوع قيمة، كل مكان يحصل على نسخة
struct User: Sendable {
    let id: Int
    let name: String
}

// Non-Sendable - إنها فئة ذات حالة قابلة للتغيير
class Counter {
    var count = 0  // مكانان يعدلان هذا = كارثة
}

جعل الأنواع Sendable

Swift يستنتج تلقائياً Sendable للعديد من الأنواع:

• Structs و enums مع خصائص Sendable فقط هي ضمنياً Sendable
• الـ Actors دائماً Sendable لأنها تحمي حالتها الخاصة
• أنواع @MainActor هي Sendable لأن MainActor يسلسل الوصول

للفئات، الأمر أصعب. فئة يمكنها المطابقة لـ Sendable فقط إذا كانت final وجميع خصائصها المخزنة غير قابلة للتغيير:

final class APIConfig: Sendable {
    let baseURL: URL      // غير قابل للتغيير
    let timeout: Double   // غير قابل للتغيير
}

إذا كان لديك فئة آمنة للخيوط بوسائل أخرى (أقفال، atomics)، يمكنك استخدام @unchecked Sendable لتخبر المترجم "ثق بي":

final class ThreadSafeCache: @unchecked Sendable {
    private let lock = NSLock()
    private var storage: [String: Data] = [:]
}

كيف يُورَث العزل

رأيت أن نطاقات العزل تحمي البيانات، وSendable يتحكم فيما يعبر بينها. لكن كيف ينتهي الكود في نطاق عزل في الأصل؟

عندما تستدعي دالة أو تنشئ closure، العزل يتدفق عبر كودك. مع Approachable Concurrency، تطبيقك يبدأ على MainActor، وذلك العزل ينتشر للكود الذي تستدعيه، إلا إذا غيّره شيء صراحةً. فهم هذا التدفق يساعدك على التنبؤ أين يعمل الكود ولماذا المترجم أحياناً يشتكي.

استدعاءات الدوال

عندما تستدعي دالة، عزلها يحدد أين تعمل:

@MainActor func updateUI() { }      // دائماً تعمل على MainActor
func helper() { }                    // ترث عزل المستدعي
@concurrent func crunch() async { }  // صراحةً تعمل بعيداً عن الـ actor

مع Approachable Concurrency، معظم كودك يرث عزل MainActor. الدالة تعمل حيث يعمل المستدعي، إلا إذا خرجت صراحةً.

الـ Closures

الـ Closures ترث العزل من السياق الذي عُرّفت فيه:

@MainActor
class ViewModel {
    func setup() {
        let closure = {
            // ترث MainActor من ViewModel
            self.updateUI()  // آمن، نفس العزل
        }
        closure()
    }
}

هذا لماذا closures الـ Button في SwiftUI يمكنها تحديث @State بأمان: ترث عزل MainActor من الواجهة.

المهام

Task { } ترث عزل الـ actor من حيث أُنشئت:

@MainActor
class ViewModel {
    func doWork() {
        Task {
            // ترث عزل MainActor
            self.updateUI()  // آمن، لا حاجة لـ await
        }
    }
}

هذا عادةً ما تريده. المهمة تعمل على نفس الـ actor مثل الكود الذي أنشأها.

كسر الوراثة: Task.detached

أحياناً تريد مهمة لا ترث أي سياق:

@MainActor
class ViewModel {
    func doHeavyWork() {
        Task.detached {
            // لا عزل actor، تعمل على التجمع التعاوني
            let result = await self.expensiveCalculation()
            await MainActor.run {
                self.data = result  // قفز صريح للخلف
            }
        }
    }
}

الحفاظ على العزل في أدوات async

أحياناً تكتب دالة async عامة تقبل closure - غلاف، مساعد إعادة المحاولة، نطاق معاملة. المستدعي يمرر closure، ودالتك تنفذها. بسيط، أليس كذلك؟

func measure<T>(
    _ label: String,
    block: () async throws -> T
) async rethrows -> T {
    let start = ContinuousClock.now
    let result = try await block()
    print("\(label): \(ContinuousClock.now - start)")
    return result
}

لكن عندما تستدعي هذا من سياق @MainActor، Swift يشتكي:

ماذا يحدث؟ الـ closure الخاص بك يلتقط حالة من MainActor، لكن measure هي nonisolated. Swift يرى closure غير Sendable يعبر حدود العزل - بالضبط ما صُمم لمنعه.

الحل الأبسط هو nonisolated(nonsending). هذا يخبر Swift أن الدالة يجب أن تبقى على أي منفذ استدعاها:

nonisolated(nonsending)
func measure<T>(
    _ label: String,
    block: () async throws -> T
) async rethrows -> T {
    let start = ContinuousClock.now
    let result = try await block()
    print("\(label): \(ContinuousClock.now - start)")
    return result
}

الآن الدالة بأكملها تعمل على منفذ المستدعي. استدعها من MainActor، تبقى على MainActor. استدعها من actor مخصص، تبقى هناك. الـ closure لا يعبر حدود العزل أبداً، لذا لا حاجة لفحص Sendable.

إذا كنت تحتاج وصولاً صريحاً للـ actor، استخدم معامل #isolation بدلاً من ذلك:

func measure<T>(
    isolation: isolated (any Actor)? = #isolation,
    _ label: String,
    block: () async throws -> T
) async rethrows -> T {
    let start = ContinuousClock.now
    let result = try await block()
    print("\(label): \(ContinuousClock.now - start)")
    return result
}

كلا النهجين ضروريان لبناء أدوات async تبدو طبيعية عند الاستخدام. بدونهما، سيحتاج المستدعون لجعل closures الخاصة بهم @Sendable أو القفز عبر حلقات لإرضاء المترجم.

جمع كل شيء معاً

لنتراجع ونرى كيف تتناسب جميع القطع.

التزامن في Swift قد يشعر بالكثير من المفاهيم: async/await، Task، الـ actors، MainActor، Sendable، نطاقات العزل. لكن هناك فكرة واحدة فقط في المركز: العزل يُورَث افتراضياً.

مع Approachable Concurrency مفعّل، تطبيقك يبدأ على MainActor. هذه نقطة بدايتك. من هناك:

• كل دالة تستدعيها ترث ذلك العزل
• كل closure تنشئها تلتقط ذلك العزل
• كل Task { } تطلقها ترث ذلك العزل

لا تحتاج لوضع تعليقات توضيحية على أي شيء. لا تحتاج للتفكير في الخيوط. كودك يعمل على MainActor، والعزل ينتشر عبر برنامجك تلقائياً.

عندما تحتاج للخروج من تلك الوراثة، تفعل ذلك صراحةً:

• @concurrent تقول "شغّل هذا على خيط خلفي"
• actor يقول "هذا النوع له نطاق عزل خاص به"
• Task.detached { } يقول "ابدأ من جديد، لا ترث شيئاً"

وعندما تمرر بيانات بين نطاقات العزل، Swift يتحقق أنها آمنة. هذا ما Sendable لأجله: وضع علامة على الأنواع التي يمكنها العبور بأمان عبر الحدود.

هذا كل شيء. هذا النموذج بالكامل:

1. العزل ينتشر من MainActor عبر كودك
2. تخرج صراحةً عندما تحتاج عمل خلفي أو حالة منفصلة
3. Sendable يحرس الحدود عندما تعبر البيانات بين النطاقات

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

إلى أين من هنا

الأخبار الجيدة: لا تحتاج لإتقان كل شيء دفعة واحدة.

معظم التطبيقات تحتاج فقط الأساسيات. ضع علامة على ViewModels بـ @MainActor، استخدم async/await لاستدعاءات الشبكة، وأنشئ Task { } عندما تحتاج بدء عمل async من نقر زر. هذا كل شيء. هذا يتعامل مع 80% من التطبيقات الحقيقية. المترجم سيخبرك إذا احتجت المزيد.

عندما تحتاج عملاً متوازياً، استخدم async let لجلب عدة أشياء مرة واحدة، أو TaskGroup عندما يكون عدد المهام ديناميكياً. تعلم التعامل مع الإلغاء بلطف. هذا يغطي التطبيقات ذات تحميل البيانات المعقد أو الميزات في الوقت الفعلي.

الأنماط المتقدمة تأتي لاحقاً، إذا أبداً. actors مخصصة للحالة القابلة للتغيير المشتركة، @concurrent للمعالجة المكثفة على المعالج، فهم عميق لـ Sendable. هذا كود الأطر، Swift من جانب الخادم، تطبيقات سطح المكتب المعقدة. معظم المطورين لا يحتاجون هذا المستوى أبداً.

احذر: الأخطاء الشائعة

التفكير أن async = خلفية

// هذا لا يزال يحجب الخيط الرئيسي!
@MainActor
func slowFunction() async {
    let result = expensiveCalculation()  // عمل متزامن = حجب
    data = result
}

async تعني "يمكن أن يتوقف مؤقتاً." العمل الفعلي لا يزال يعمل أينما يعمل. استخدم @concurrent (Swift 6.2) أو Task.detached للعمل المكثف على المعالج.

إنشاء actors كثيرة جداً

// مفرط الهندسة
actor NetworkManager { }
actor CacheManager { }
actor DataManager { }

// أفضل - معظم الأشياء يمكنها العيش على MainActor
@MainActor
class AppState { }

تحتاج actor مخصص فقط عندما يكون لديك حالة قابلة للتغيير مشتركة لا يمكنها العيش على MainActor. قاعدة Matt Massicotte: أدخل actor فقط عندما (1) لديك حالة non-Sendable، (2) العمليات على تلك الحالة يجب أن تكون ذرية، و(3) تلك العمليات لا يمكنها العمل على actor موجود. إذا لم تستطع تبريره، استخدم @MainActor بدلاً من ذلك.

جعل كل شيء Sendable

ليس كل شيء يحتاج لعبور الحدود. إذا كنت تضيف @unchecked Sendable في كل مكان، تراجع واسأل إذا كانت البيانات فعلاً تحتاج للانتقال بين نطاقات العزل.

استخدام MainActor.run عندما لا تحتاجه

// غير ضروري
Task {
    let data = await fetchData()
    await MainActor.run {
        self.data = data
    }
}

// أفضل - فقط اجعل الدالة @MainActor
@MainActor
func loadData() async {
    self.data = await fetchData()
}

MainActor.run نادراً ما يكون الحل الصحيح. إذا كنت تحتاج عزل MainActor، ضع تعليق @MainActor على الدالة بدلاً من ذلك. أوضح والمترجم يمكنه مساعدتك أكثر. شاهد رأي Matt في هذا.

حجب تجمع الخيوط التعاوني

// لا تفعل هذا أبداً - يخاطر بالجمود
func badIdea() async {
    let semaphore = DispatchSemaphore(value: 0)
    Task {
        await doWork()
        semaphore.signal()
    }
    semaphore.wait()  // يحجب خيطاً تعاونياً!
}

تجمع الخيوط التعاوني في Swift له خيوط محدودة. حجب واحد بـ DispatchSemaphore أو DispatchGroup.wait() أو استدعاءات مماثلة يمكن أن يسبب جموداً. إذا كنت تحتاج ربط كود متزامن وغير متزامن، استخدم async let أو أعد الهيكلة للبقاء غير متزامن بالكامل.

func doWork() async {

    // هذا سيرجع عندما ترجع جميع المهام الفرعية، تلقي خطأ، أو يتم إلغاؤها
    let result = try await withThrowingTaskGroup() { group in
        group.addTask {
            try await self.performAsyncOperation1()
        }
        group.addTask {
            try await self.performAsyncOperation2()
        }
        // انتظر واجمع نتائج المهام هنا
    }
}

func performAsyncOperation1() async throws -> Int {
    return 1
}
func performAsyncOperation2() async throws -> Int {
    return 2
}

var sum = 0
for await result in group {
    sum += result
}
// sum == 3

struct ContentView: View {

    @State private var shouldLoadImage = false

    var body: some View {
        Button("اضغط هنا!") {
            // بدّل العلَم
            shouldLoadImage = !shouldLoadImage
        }
        // الـ View تدير المهمة الفرعية
        // تبدأ قبل عرض الواجهة
        // وتتوقف عندما تختفي الواجهة
        .task(id: shouldLoadImage) {
            // عندما تتغير قيمة العلَم، SwiftUI يعيد تشغيل المهمة
            guard shouldLoadImage else { return }
            await loadImage()
        }
    }
}

ورقة الغش: مرجع سريع

قراءة إضافية

مهارة وكيل الذكاء الاصطناعي

هل تريد أن يفهم مساعد البرمجة بالذكاء الاصطناعي Swift Concurrency؟ نقدم ملف SKILL.md الذي يحزم هذه النماذج الذهنية لوكلاء الذكاء الاصطناعي مثل Claude Code و Codex و Amp و OpenCode وغيرها.

مهارات أخرى

• مهارة Swift Concurrency Agent مفتوحة المصدر من Antoine

كيفية الاستخدام

اختر وكيلك ونفّذ الأوامر:

# مهارة شخصية (جميع مشاريعك)
mkdir -p ~/.claude/skills/swift-concurrency
curl -o ~/.claude/skills/swift-concurrency/SKILL.md https://fuckingapproachableswiftconcurrency.com/SKILL.md
# مهارة المشروع (هذا المشروع فقط)
mkdir -p .claude/skills/swift-concurrency
curl -o .claude/skills/swift-concurrency/SKILL.md https://fuckingapproachableswiftconcurrency.com/SKILL.md

# تعليمات عامة (جميع مشاريعك)
curl -o ~/.codex/AGENTS.md https://fuckingapproachableswiftconcurrency.com/SKILL.md
# تعليمات المشروع (هذا المشروع فقط)
curl -o AGENTS.md https://fuckingapproachableswiftconcurrency.com/SKILL.md

# تعليمات المشروع (موصى به)
curl -o AGENTS.md https://fuckingapproachableswiftconcurrency.com/SKILL.md

# قواعد عامة (جميع مشاريعك)
mkdir -p ~/.config/opencode
curl -o ~/.config/opencode/AGENTS.md https://fuckingapproachableswiftconcurrency.com/SKILL.md
# قواعد المشروع (هذا المشروع فقط)
curl -o AGENTS.md https://fuckingapproachableswiftconcurrency.com/SKILL.md

تتضمن المهارة تشبيه مبنى المكاتب، وأنماط العزل، ودليل Sendable، والأخطاء الشائعة، وجداول المرجع السريع. سيستخدم وكيلك هذه المعرفة تلقائياً عند العمل مع كود Swift Concurrency.