موبائل ڈیولپمنٹ میں Thread — یہ کیا ہے، اقسام اور تھریڈ مینجمنٹ

Thread کیا ہے

Thread (عملدرآمد کا دھاگہ) — ہدایات کا ایک آزاد سلسلہ ہے جسے آپریٹنگ سسٹم CPU کور پر شیڈول کر سکتا ہے۔ ہر عمل (ایپلیکیشن) میں کم از کم ایک تھریڈ ہوتا ہے — Main Thread۔ کاموں کے متوازی عملدرآمد کے لیے اضافی تھریڈز بنائے جاتے ہیں۔ ہر تھریڈ کا اپنا سافٹ ویئر اسٹیک (مقامی متغیرات کے ساتھ)، پروگرام کاؤنٹر (PC) اور رجسٹر ہوتے ہیں۔ Heap میموری عمل کے تمام تھریڈز کے لیے مشترکہ ہوتی ہے۔

موبائل آپریٹنگ سسٹمز میں، تھریڈز کو preemptive multitasking کے ذریعے شیڈول کیا جاتا ہے: OS کسی بھی وقت تھریڈ کے عملدرآمد کو روک سکتا ہے اور کنٹرول دوسرے تھریڈ کو منتقل کر سکتا ہے (context switch)۔ سیاق و سباق کی تبدیلی ایک مہنگی کارروائی ہے (1-10 مائیکرو سیکنڈ)، کیونکہ اس کے لیے CPU رجسٹرز کو محفوظ/بحال کرنا، TLB کو اپ ڈیٹ کرنا اور کیشے صاف کرنا ضروری ہوتا ہے۔ اسی لیے تھریڈز کی ضرورت سے زیادہ تعداد (سینکڑوں اور ہزاروں) کارکردگی کو خراب کرتی ہے — OS عملدرآمد سے زیادہ وقت سیاق و سباق کی تبدیلی میں صرف کرتا ہے۔

تھریڈ اور عمل — مختلف تصورات ہیں۔ عمل مختص ورچوئل میموری کے ساتھ ایپلیکیشن کی ایک مثال ہے۔ عمل کے اندر تھریڈ اس میموری کو دوسرے تھریڈز کے ساتھ شیئر کرتا ہے۔ Android میں، ایپلیکیشن کا ہر جزو (Activity، Service، BroadcastReceiver) ایک عمل میں کام کرتا ہے لیکن مختلف تھریڈز پر عملدرآمد کر سکتا ہے۔ iOS ایپلیکیشن بھی ایک واحد عمل ہے جس میں GCD یا Thread کے ذریعے اضافی تھریڈز بنانے کی صلاحیت ہے۔

تھریڈ لائف سائیکل: حالتیں اور منتقلیاں

ہر تھریڈ Java/Kotlin (Android) اور NSThread (iOS) میں پانچ حالتوں سے گزرتا ہے: New (بنایا گیا)، Runnable (عملدرآمد کے لیے تیار)، Running (CPU پر چل رہا)، Blocked/Waiting (وسیلہ یا اطلاع کا انتظار)، Terminated (ختم ہوگیا)۔ حالتوں کے درمیان منتقلیاں OS شیڈولر اور سنکرونائزیشن پریمیٹیو کے ذریعے منظم کی جاتی ہیں۔ ڈویلپر تھریڈ کی ترجیح (Thread.setPriority()) اور اس کی حالت (sleep، join، interrupt) کو متاثر کر سکتا ہے۔

Android میں، ایک تھریڈ Blocked حالت میں اس وقت جاتا ہے جب وہ مصروف مانیٹر (synchronized) حاصل کرنے کی کوشش کرتا ہے، Object.wait() یا Thread.sleep() کال کرتا ہے۔ iOS میں — NSCondition.wait()، pthread_cond_wait() یا dispatch_semaphore_wait() کال کرنے پر۔ Blocked حالت میں، تھریڈ CPU استعمال نہیں کرتا لیکن میموری (اسٹیک) پر قبضہ کرتا ہے۔ ایک تھریڈ دوسرے تھریڈ سے InterruptedException (Java) حاصل کرکے یا isCancelled (Kotlin Coroutines) چیک کرکے روکا جا سکتا ہے (interrupted)۔

Context Switch اور اس کی قیمت

Context switch (سیاق و سباق کی تبدیلی) — وہ کارروائی جس میں OS موجودہ تھریڈ کی حالت (رجسٹر، PC، TLB) محفوظ کرتا ہے اور دوسرے تھریڈ کی محفوظ کردہ حالت لوڈ کرتا ہے۔ موبائل سسٹمز میں (Linux + ART، iOS کے لیے XNU)، context switch 1-10 مائیکرو سیکنڈ لیتا ہے۔ اگر کوئی تھریڈ 100 مائیکرو سیکنڈ میں کام مکمل کرتا ہے اور context switch 5 لیتا ہے، تو 5% وقت ضائع ہوتا ہے۔ Context switch کو کم سے کم کرنے کے لیے iOS work stealing کے ساتھ GCD استعمال کرتا ہے، Android — fixedThreadCount کے ساتھ پولز۔

Android میں Thread: Thread سے Coroutines تک

Android نچلی سطح کے java.lang.Thread سے جدید coroutines تک ترقی کر چکا ہے۔ تجرید کی ہر سطح کم اضافی اخراجات کے ساتھ زیادہ صلاحیتیں فراہم کرتی ہے۔ Thread بنیادی کلاس ہے، لیکن اسے براہ راست بنانا تجویز نہیں کیا جاتا: نیا تھریڈ پول کے زیر انتظام نہیں ہوتا، اس کی نگرانی اور منسوخی مشکل ہے۔ AsyncTask (API 30 سے متروک) ایک قدم آگے تھا لیکن میموری لیک اور کنفیگریشنز کے غیر آسان انتظام کا شکار تھا۔

HandlerThread Looper کے ساتھ Thread کی ایک خاص ذیلی کلاس ہے، جو پیغامات کی قطار پر کارروائی کر سکتی ہے۔ یہ پس منظر کے تھریڈ پر ترتیب وار کاموں کے عملدرآمد کے لیے استعمال ہوتا ہے، مثال کے طور پر Room یا فائلوں میں ڈیٹا لکھنا۔ HandlerThread start() کال کرکے بنایا جاتا ہے، اس کے بعد Handler(handlerThread.looper) کے ذریعے پیغامات اور Runnable بھیجے جا سکتے ہیں۔ 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) 10 تک کاموں کے متوازی عملدرآمد کے لیے 4 تھریڈز کا پول بناتا ہے۔ Kotlin Coroutines Dispatchers.Default کے ساتھ — ایک جدید، موثر اور محفوظ طریقہ۔

HandlerThread: ترتیب وار پس منظر کے کام

HandlerThread — بلٹ ان Looper اور پیغام کی قطار کے ساتھ Thread کی ایک خصوصی ذیلی کلاس ہے۔ یہ 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 async task")
        }

        // تحریر سنکرونائزیشن کے لیے Barrier
        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)
    }
}

// GCD barrier کے ذریعے thread-safe مجموعہ
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. Coroutines سے 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") }
    }
}