Thread در توسعه موبایل — چیست، انواع و مدیریت نخ‌ها

Thread چیست

Thread (نخ اجرا) — توالی مستقل از دستورالعمل‌ها است که سیستم‌عامل می‌تواند آن را بر روی هسته CPU زمان‌بندی کند. هر فرایند (اپلیکیشن) حداقل یک نخ دارد — Main Thread. نخ‌های اضافی برای اجرای موازی وظایف ایجاد می‌شوند. هر نخ پشته برنامه مخصوص خود (با متغیرهای محلی)، شمارنده دستور (PC) و رجیسترها را دارد. حافظه heap برای همه نخ‌های فرایند مشترک است.

در سیستم‌عامل‌های موبایل، نخ‌ها با چندوظیفگی پیشگیرانه (preemptive multitasking) زمان‌بندی می‌شوند: سیستم‌عامل می‌تواند در هر لحظه اجرای نخ را قطع کرده و کنترل را به نخ دیگری بدهد (context switch). تعویض زمینه عملیات پرخرجی است (1–10 میکروثانیه)، زیرا نیاز به ذخیره‌سازی/بازیابی رجیسترهای CPU، به‌روزرسانی TLB و پاک‌سازی کش‌ها دارد. دقیقاً به همین دلیل تعداد بیش از حد نخ‌ها (صدها و هزارها) عملکرد را بدتر می‌کند — سیستم‌عامل زمان بیشتری را صرف تعویض می‌کند تا اجرا.

نخ و فرایند مفاهیم متفاوتی هستند. فرایند نمونه‌ای از اپلیکیشن با حافظه مجازی اختصاصی است. نخ داخل فرایند این حافظه را با سایر نخ‌ها به اشتراک می‌گذارد. در اندروید هر کامپوننت اپلیکیشن (Activity، Service، BroadcastReceiver) در یک فرایند کار می‌کند، اما می‌تواند در نخ‌های مختلف اجرا شود. اپلیکیشن iOS نیز یک فرایند واحد است که امکان ایجاد نخ‌های اضافی از طریق GCD یا Thread را دارد.

چرخه حیات نخ: حالت‌ها و انتقال‌ها

هر نخ در Java/Kotlin (اندروید) و NSThread (iOS) پنج حالت را طی می‌کند: New (ایجاد شده)، Runnable (آماده اجرا)، Running (در حال اجرا بر روی CPU)، Blocked/Waiting (منتظر منبع یا اعلان)، Terminated (پایان‌یافته). انتقال‌ها بین حالت‌ها توسط زمان‌بند سیستم‌عامل و ابزارهای همگام‌سازی مدیریت می‌شود. توسعه‌دهنده می‌تواند بر اولویت نخ (Thread.setPriority()) و حالت آن (sleep، join، interrupt) تأثیر بگذارد.

در اندروید نخ در هنگام تلاش برای تصاحب مانیتور اشغال‌شده (synchronized)، فراخوانی Object.wait() یا Thread.sleep() به حالت Blocked می‌رود. در iOS — هنگام فراخوانی NSCondition.wait()، pthread_cond_wait() یا dispatch_semaphore_wait(). در حالت Blocked نخ CPU مصرف نمی‌کند، اما حافظه (پشته) اشغال می‌کند. نخ می‌تواند از نخ دیگر قطع شود (interrupted)، با دریافت InterruptedException (جاوا) یا بررسی isCancelled (Kotlin Coroutines).

تعویض زمینه و هزینه آن

Context switch (تعویض زمینه) — عملیاتی است که در آن سیستم‌عامل وضعیت نخ فعلی (رجیسترها، PC، TLB) را ذخیره کرده و وضعیت ذخیره‌شده نخ دیگر را بارگذاری می‌کند. در سیستم‌های موبایل (Linux + ART، XNU برای iOS) تعویض زمینه 1–10 میکروثانیه طول می‌کشد. اگر نخ وظیفه‌ای را در 100 میکروثانیه اجرا کند و تعویض زمینه 5 طول بکشد، 5٪ از زمان هدر می‌رود. برای به حداقل رساندن تعویض زمینه، iOS از GCD با work stealing و اندروید از پول‌هایی با fixedThreadCount استفاده می‌کند.

Thread در اندروید: از Thread تا Coroutines

اندروید از java.lang.Thread سطح پایین تا کوروتین‌های مدرن تکامل یافته است. هر سطح انتزاع امکانات بیشتری با هزینه‌های اضافی کمتر می‌دهد. Thread کلاس پایه است، اما ایجاد مستقیم آن توصیه نمی‌شود: نخ جدید توسط پول مدیریت نمی‌شود، نظارت و لغو آن دشوار است. AsyncTask (deprecated از API 30) گامی رو به جلو بود، اما از نشت حافظه و مدیریت نامناسب پیکربندی رنج می‌برد.

HandlerThread — زیرکلاس ویژه Thread با Looper است که می‌تواند صف پیام‌ها را پردازش کند. برای اجرای ترتیبی وظایف در نخ پس‌زمینه استفاده می‌شود، مثلاً نوشتن داده در Room یا فایل‌ها. HandlerThread با فراخوانی start() ایجاد می‌شود، پس از آن از طریق Handler(handlerThread.looper) می‌توان پیام و Runnable ارسال کرد. فراخوانی handlerThread.quit() Looper را متوقف و نخ را خاتمه می‌دهد.

// اندروید: 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("نخ مستقیم اجرا شد")
        })
        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 هر چهار سطح انتزاع نخ را در اندروید نشان می‌دهد. ایجاد مستقیم Thread — پایین‌ترین سطح و ناکارآمدترین رویکرد است. HandlerThread برای وظایف ترتیبی در پس‌زمینه مفید است. Executors.newFixedThreadPool(4) پولی از 4 نخ برای اجرای موازی حداکثر 10 وظیفه ایجاد می‌کند. Kotlin Coroutines با Dispatchers.Default — روشی مدرن، کارآمد و ایمن است.

HandlerThread: وظایف ترتیبی پس‌زمینه

HandlerThread — زیرکلاس تخصصی Thread با Looper داخلی و صف پیام است. با فراخوانی start() ایجاد می‌شود، پس از آن از طریق Handler(handlerThread.looper) می‌توان Runnable و پیام ارسال کرد. 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")
        }

        // Barrier برای همگام‌سازی نوشتن
        queue.async(flags: .barrier) {
            // دسترسی انحصاری هنگام نوشتن
            print("Barrier write: دسترسی انحصاری")
        }
    }

    // 3. OperationQueue با وابستگی‌ها
    func operationQueueExample() {
        let queue = OperationQueue()
        queue.maxConcurrentOperationCount = 2
        queue.qualityOfService = .background

        let download = BlockOperation {
            print("در حال دانلود...")
        }
        let process = BlockOperation {
            print("در حال پردازش...")
        }
        let save = BlockOperation {
            print("در حال ذخیره...")
        }

        // وابستگی‌ها: download -> process -> save
        process.addDependency(download)
        save.addDependency(process)

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

// مجموعه thread-safe از طریق GCD barrier
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 — thread-safe
            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") }
    }
}