मोबाइल डेवलपमेंट में Thread — यह क्या है, प्रकार और थ्रेड प्रबंधन

Thread क्या है

Thread (निष्पादन थ्रेड) — निर्देशों का एक स्वतंत्र अनुक्रम है, जिसे ऑपरेटिंग सिस्टम CPU कोर पर शेड्यूल कर सकता है। प्रत्येक प्रक्रिया (एप्लिकेशन) में कम से कम एक थ्रेड — Main Thread होता है। अतिरिक्त थ्रेड समानांतर कार्य निष्पादन के लिए बनाए जाते हैं। प्रत्येक थ्रेड का अपना प्रोग्राम स्टैक (स्थानीय चर के साथ), इंस्ट्रक्शन काउंटर (PC) और रजिस्टर होते हैं। हीप मेमोरी प्रक्रिया के सभी थ्रेड के लिए साझा होती है।

मोबाइल OS में थ्रेड प्रीएम्प्टिव मल्टीटास्किंग (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 का उपभोग नहीं करता, लेकिन मेमोरी (स्टैक) घेरता है। थ्रेड को दूसरे थ्रेड से बाधित (interrupted) किया जा सकता है, जिससे InterruptedException (Java) या isCancelled (Kotlin Coroutines) मिलता है।

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 से आधुनिक कोरूटीन तक का विकास किया है। एब्स्ट्रैक्शन का प्रत्येक स्तर कम ओवरहेड के साथ अधिक क्षमताएँ देता है। Thread — मूल वर्ग है, लेकिन इसका सीधा निर्माण अनुशंसित नहीं है: नया थ्रेड पूल द्वारा प्रबंधित नहीं होता, इसकी निगरानी और रद्द करना कठिन है। AsyncTask (API 30 से deprecated) एक कदम आगे था, लेकिन मेमोरी लीक और कॉन्फ़िगरेशन हैंडलिंग की असुविधा से ग्रस्त था।

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. कोरूटीन से Mutex — suspend-safe
    private val mutex = Mutex()
    suspend fun mutexOperation() {
        mutex.withLock {
            // सुरक्षित कोड — थ्रेड-सुरक्षित
            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") }
    }
}