الخيط (Thread) في تطوير التطبيقات المحمولة — ما هو، الأنواع وإدارة الخيوط

ما هو Thread

Thread (خيط التنفيذ) هو تسلسل مستقل من التعليمات الذي يمكن لنظام التشغيل جدولته على نواة وحدة المعالجة المركزية. يحتوي كل عملية (تطبيق) على خيط واحد على الأقل — الخيط الرئيسي (Main Thread). يتم إنشاء خيوط إضافية لتنفيذ المهام بالتوازي. لكل خيط مكونه الخاص بالبرنامج (مع المتغيرات المحلية)، عداد الأوامر (PC) والمسجلات. ذاكرة الكومة (heap) مشتركة بين جميع خيوط العملية.

في أنظمة التشغيل المحمولة، تتم جدولة الخيوط باستخدام تعدد المهام الاستباقي (preemptive multitasking): يمكن لنظام التشغيل مقاطعة تنفيذ الخيط في أي لحظة وتسليم التحكم إلى آخر (تبديل السياق). تبديل السياق هي عملية مكلفة (1–10 ميكروثانية) لأنها تتطلب حفظ/استعادة مسجلات وحدة المعالجة المركزية، تحديث TLB وتفريغ الذاكرة المخبئة. لذلك فإن العدد المفرط من الخيوط (المئات أو الآلاف) يقلل من الأداء — يقضي نظام التشغيل وقتًا أكثر في التبديل من التنفيذ.

الخيط مقابل العملية — مفاهيم مختلفة. العملية هي نسخة من تطبيق بذاكرة افتراضية مخصصة. الخيط داخل العملية يشارك هذه الذاكرة مع الخيوط الأخرى. في Android، كل مكون من مكونات التطبيق (Activity، Service، BroadcastReceiver) يعمل في عملية واحدة ولكن يمكنه التنفيذ على خيوط مختلفة. تطبيق iOS هو أيضًا عملية واحدة قادرة على إنشاء خيوط إضافية من خلال GCD أو Thread.

دورة حياة الخيط: الحالات والانتقالات

كل خيط في Java/Kotlin (Android) و NSThread (iOS) يمر بخمس حالات: جديد (New)، قابل للتنفيذ (Runnable)، قيد التنفيذ (Running)، محجوب/منتظر (Blocked/Waiting)، منهي (Terminated). تتم إدارة الانتقالات بين الحالات بواسطة مجدول نظام التشغيل وأدوات المزامنة. يمكن للمطور التأثير على أولوية الخيط (Thread.setPriority()) وحالته (sleep، join، interrupt).

في Android، يدخل الخيط إلى حالة Blocked عند محاولة الحصول على مراقب مشغول (synchronized)، أو استدعاء Object.wait() أو Thread.sleep(). في iOS — عند استدعاء NSCondition.wait()، pthread_cond_wait() أو dispatch_semaphore_wait(). في حالة Blocked، لا يستهلك الخيط وحدة المعالجة المركزية ولكنه لا يزال يشغل ذاكرة (مكون). يمكن مقاطعة الخيط من خيط آخر، والحصول على InterruptedException (Java) أو التحقق من isCancelled (Kotlin Coroutines).

تبديل السياق وتكلفته

تبديل السياق هي عملية حيث يقوم نظام التشغيل بحفظ حالة الخيط الحالي (المسجلات، PC، TLB) وتحميل الحالة المحفوظة لخيط آخر. في الأنظمة المحمولة (Linux + ART، XNU لـ iOS) يستغرق تبديل السياق 1–10 ميكروثانية. إذا كان الخيط ينفذ مهمة خلال 100 ميكروثانية ويستغرق تبديل السياق 5، فإن 5% من الوقت يضيع. لتقليل تبديل السياق، يستخدم iOS GCD مع work stealing، ويستخدم Android مجموعات مع fixedThreadCount.

Thread في Android: من Thread إلى Coroutines

Android تطور من java.lang.Thread منخفض المستوى إلى الكوروتينات الحديثة. كل مستوى تجريد يوفر قدرات أكبر مع تكلفة أقل. Thread هو الفئة الأساسية، ولكن لا يوصى بإنشائه مباشرة: الخيط الجديد لا يتم إدارته بواسطة مجموعة، ومن الصعب مراقبته وإلغاؤه. كان AsyncTask (مهجور منذ API 30) خطوة إلى الأمام، ولكنه عانى من تسرب الذاكرة ومعالجة غير مريحة للتكوينات.

HandlerThread هو فئة فرعية خاصة من Thread مع Looper يمكنه معالجة طابور الرسائل. يستخدم للتنفيذ التسلسلي للمهام على خيط خلفي، على سبيل المثال، كتابة البيانات إلى Room أو الملفات. يتم إنشاء HandlerThread باستدعاء start()، بعدها يمكن إرسال الرسائل و Runnable عبر Handler(handlerThread.looper). يقوم handlerThread.quit() بإيقاف Looper وإنهاء الخيط.

// Android: Thread، HandlerThread و Executors
import android.os.Handler
import android.os.HandlerThread
import java.util.concurrent.Executors

class ThreadExample {

    // 1. إنشاء Thread مباشر (غير موصى به)
    fun directThread() {
        val thread = Thread(Runnable {
            Thread.sleep(1000)
            print("Direct thread executed")
        })
        thread.start()
    }

    // 2. HandlerThread للمهام التسلسلية في الخلفية
    fun handlerThreadExample() {
        val handlerThread = HandlerThread("BackgroundQueue")
        handlerThread.start()

        val handler = Handler(handlerThread.looper)
        handler.post {
            // تنفيذ تسلسلي على خيط خلفي
            Thread.sleep(500)
            print("HandlerThread: تمت المهمة")
        }

        // إيقاف الخيط (يتم التنفيذ عندما تنتهي المهام)
        handlerThread.quitSafely()
    }

    // 3. Executors — مجموعة خيوط
    fun executorExample() {
        val executor = Executors.newFixedThreadPool(4)
        for (i in 1..10) {
            executor.execute {
                print("Task $i on thread ${Thread.currentThread().getName()}")
            }
        }
        executor.shutdown()
    }

    // 4. Kotlin Coroutines — المعيار الحديث
    suspend fun coroutineExample() = kotlinx.coroutines.withContext(
        kotlinx.coroutines.Dispatchers.Default
    ) {
        print("Coroutine on thread: ${Thread.currentThread().getName()}")
    }
}

يوضح مثال ThreadExample المستويات الأربعة لتجريد الخيوط في Android. الإنشاء المباشر لـ Thread هو النهج الأكثر انخفاضًا وأقلها كفاءة. HandlerThread مفيد للمهام التسلسلية في الخلفية. Executors.newFixedThreadPool(4) ينشئ مجموعة من 4 خيوط لتنفيذ ما يصل إلى 10 مهام بالتوازي. Kotlin Coroutines مع Dispatchers.Default هو نهج حديث، فعال وآمن.

HandlerThread: مهام تسلسلية في الخلفية

HandlerThread هو فئة فرعية متخصصة من Thread مع Looper مضمن وطابور رسائل. يتم إنشاؤه باستدعاء start()، بعدها يمكن إرسال Runnable ورسائل عبر Handler(handlerThread.looper). ينفذ HandlerThread المهام بشكل تسلسلي تمامًا — لا تبدأ المهمة التالية حتى تكتمل السابقة. هذا مفيد لكتابة البيانات إلى Room أو الملفات، حيث يكون ترتيب العمليات حاسمًا. يقوم quitSafely() بإيقاف Looper بعد اكتمال المهمة الحالية.

import Foundation

class ThreadManager {

    // 1. Thread (منخفض المستوى)
    func createThread() {
        let thread = Thread {
            // تم تنفيذ الكود على خيط جديد
            print("Current thread: \(Thread.current)")
        }
        thread.name = "com.app.worker"
        thread.qualityOfService = .utility
        thread.start()
    }

    // 2. GCD — DispatchQueue
    func gcdExample() {
        // طابور متزامن
        let queue = DispatchQueue(label: "com.app.concurrent",
                                 qos: .utility,
                                 attributes: .concurrent)

        queue.async {
            print("GCD async task")
        }

        // حاجز لمزامنة الكتابة
        queue.async(flags: .barrier) {
            // وصول حصري أثناء الكتابة
            print("Barrier write: exclusive access")
        }
    }

    // 3. OperationQueue مع التبعيات
    func operationQueueExample() {
        let queue = OperationQueue()
        queue.maxConcurrentOperationCount = 2
        queue.qualityOfService = .background

        let download = BlockOperation {
            print("Downloading...")
        }
        let process = BlockOperation {
            print("Processing...")
        }
        let save = BlockOperation {
            print("Saving...")
        }

        // التبعيات: download -> process -> save
        process.addDependency(download)
        save.addDependency(process)

        queue.addOperations([download, process, save], waitUntilFinished: false)
    }
}

// مجموعة thread-safe عبر حاجز GCD
class ThreadSafeArray<T> {
    private var array: [T] = []
    private let queue = DispatchQueue(label: "com.app.concurrent",
                                       attributes: .concurrent)

    var count: Int {
        return queue.sync { array.count } // concurrent read
    }

    func append(_ element: T) {
        queue.async(flags: .barrier) { // exclusive write
            self.array.append(element)
        }
    }
}

// المزامنة في Android/Kotlin
import java.util.concurrent.atomic.AtomicInteger
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

class Counter {

    // 1. AtomicInteger — للعدادات البسيطة
    private val atomicCount = AtomicInteger(0)
    fun incrementAtomic() = atomicCount.incrementAndGet()

    // 2. synchronized — للمقاطع الحرجة
    @Synchronized
    fun synchronizedOperation() {
        // خيط واحد فقط في كل مرة
        doWork()
    }

    // 3. Mutex من الكوروتينات — suspend-safe
    private val mutex = Mutex()
    suspend fun mutexOperation() {
        mutex.withLock {
            // protected code — آمن للخيوط
            doWork()
        }
    }

    private fun doWork() { /* critical section */ }
}

// مثال deadlock: A يحجب B، B يحجب A
class DeadlockExample {
    private val lockA = Any()
    private val lockB = Any()

    fun methodA() = synchronized(lockA) {
        Thread.sleep(100)
        synchronized(lockB) { print("OK") }
    }

    fun methodB() = synchronized(lockB) {
        Thread.sleep(100)
        synchronized(lockA) { print("OK") }
    }
}