মোবাইল ডেভেলপমেন্টে 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") }
    }
}