موبائل ڈویلپمنٹ میں Background Thread: یہ کیا ہے، کام اور استعمال کے طریقے

Background Thread کیا ہے

Background Thread — ایپلیکیشن میں کوئی بھی تھریڈ جو Main Thread نہیں ہے اور اسے UI تک رسائی نہیں ہے۔ اس کا کام مین تھریڈ کو بھاری آپریشنز سے آزاد کرنا ہے تاکہ انٹرفیس ردعمل دیتا رہے۔ آپریٹنگ سسٹم پس منظر کے تھریڈز کو CPU کورز پر تقسیم کرتا ہے، متعدد کاموں کو متوازی طور پر انجام دینے کی اجازت دیتا ہے۔ iOS خود بخود GCD کے ذریعے تھریڈ پول کا انتظام کرتا ہے، Android Java Executors پولز کے ذریعے۔

Main Thread کے برعکس، جو واقعات کو ترتیب وار (ایک کے بعد ایک) پروسیس کرتا ہے، پس منظر کے تھریڈز متوازی طور پر چل سکتے ہیں، صرف CPU کورز کی تعداد سے محدود۔ مثال کے طور پر، 8 کور والے ڈیوائس پر بغیر نمایاں سستی کے 8 متوازی پس منظر کے کام چلائے جا سکتے ہیں۔ تاہم، تھریڈز کی ضرورت سے زیادہ تعداد (سیکڑوں) thread starvation — کورز کے لیے مقابلہ اور سیاق و سباق کی تبدیلی (context switch) کے بڑھتے ہوئے اوور ہیڈ کا باعث بنتی ہے۔

Quality of Service (QoS) — iOS میکانزم جو پس منظر کے کام کی ترجیح متعین کرنے کی اجازت دیتا ہے۔ اقدار: .userInteractive (سب سے زیادہ، تقریباً Main Thread)، .userInitiated (صارف نتیجہ کا انتظار کر رہا ہے)، .default (معیاری)، .utility (صارف براہ راست انتظار نہیں کر رہا)، .background (سب سے کم، مطابقت پذیری اور اشاریہ سازی کے لیے)۔ Android میں، مساوی Thread.setPriority() 1 سے 10 تک ہے، لیکن Android تھریڈ کی ترجیحات کے گروپ انتظام کے لیے cgroups بھی استعمال کرتا ہے۔

iOS میں Background Thread: GCD اور DispatchQueue.global

DispatchQueue.global(qos:) — iOS میں پس منظر کی قطار حاصل کرنے کا بنیادی طریقہ ہے۔ GCD (Grand Central Dispatch) خود بخود تھریڈ پول بناتا ہے اور کاموں کو کورز پر تقسیم کرتا ہے۔ DispatchQueue.global(qos: .background).async {} کال سب سے کم ترجیح کے ساتھ پس منظر کی قطار میں ایک بلاک بھیجتی ہے۔ ان کاموں کے لیے جن کے نتیجے کی فوری ضرورت ہے، .userInitiated یا .utility استعمال کریں۔

OperationQueue — GCD پر ایک اعلیٰ سطح کا تجرید جو آپریشنز کے درمیان انحصار، زیادہ سے زیادہ بیک وقت آپریشنز کی تعداد (maxConcurrentOperationCount) اور ترجیحات متعین کرنے کی اجازت دیتا ہے۔ OperationQueue پیچیدہ ملٹی ٹاسکنگ زنجیروں کے لیے آسان ہے: فائل ڈاؤن لوڈ کریں → ڈیکمپریس کریں → کیشے میں محفوظ کریں۔ ڈیفالٹ طور پر، OperationQueue پس منظر کے تھریڈز استعمال کرتا ہے جب تک کہ دوسری صورت میں متعین نہ کیا گیا ہو۔

import UIKit

class ImageDownloader {

    func downloadImagesSequentially() {
        let urls = ["https://example.com/1.png", "https://example.com/2.png"]

        // maxConcurrentOperationCount = 2 کے ساتھ OperationQueue
        let queue = OperationQueue()
        queue.maxConcurrentOperationCount = 2
        queue.qualityOfService = .utility

        for urlString in urls {
            queue.addOperation {
                guard let url = URL(string: urlString),
                      let data = try? Data(contentsOf: url)
                else { return }

                DispatchQueue.main.async {
                    print("لوڈ ہو گیا: \(url.lastPathComponent)")
                }
            }
        }
    }

    // GCD: مختلف QoS کے ساتھ عالمی پس منظر کی قطار
    func backgroundTaskWithQoS() {
        DispatchQueue.global(qos: .userInitiated).async {
            // اعلی ترجیح — صارف نتیجہ کا انتظار کر رہا ہے
            let result = self.heavyComputation()
            DispatchQueue.main.async {
                self.showResult(result)
            }
        }
    }

    private func heavyComputation() -> String {
        Thread.sleep(forTimeInterval: 2) // کام کی نقل
        return "حساب کا نتیجہ"
    }

    private func showResult(_ result: String) {
        print("Result on Main: \(result)")
    }
}

مثال میں، OperationQueue qualityOfService = .utility کے ذریعے پس منظر QoS کے ساتھ دو تصاویر متوازی طور پر لوڈ کرتا ہے (maxConcurrentOperationCount = 2)۔ GCD طریقہ backgroundTaskWithQoS .userInitiated کے ساتھ ایک عالمی قطار استعمال کرتا ہے جس کے نتیجے کا صارف انتظار کر رہا ہے۔ دونوں طریقے UI کو اپ ڈیٹ کرنے کے لیے DispatchQueue.main پر واپس آ کر ختم ہوتے ہیں — یہ iOS میں ایک لازمی ضرورت ہے۔

سیریل بمقابلہ کنکرنٹ پس منظر کی قطاریں

GCD دو قسم کی قطاروں کو سپورٹ کرتا ہے: سیریل (ترتیب وار) اور کنکرنٹ (بیک وقت)۔ سیریل قطاریں ایک کے بعد ایک کام انجام دیتی ہیں — یہ بغیر لاک کے مشترکہ وسائل (فائل، DB) تک رسائی کے لیے آسان ہے۔ کنکرنٹ قطاریں کاموں کو متوازی طور پر انجام دیتی ہیں، انہیں دستیاب کورز پر تقسیم کرتی ہیں۔ DispatchQueue.global ہمیشہ کنکرنٹ ہوتی ہے۔ سیریل قطار بنانے کے لیے، DispatchQueue(label: "com.app.queue") استعمال کریں۔

Android میں Background Thread: Executors اور Dispatchers

Android پس منظر کے تھریڈز کے لیے تجرید کی کئی سطحیں فراہم کرتا ہے۔ کلاسک طریقہ java.util.concurrent.Executors.newFixedThreadPool(n) یا Executors.newCachedThreadPool() ہے۔ جدید طریقہ Kotlin Coroutines ہے جس میں Dispatchers.IO (I/O کے لیے: نیٹ ورک، فائلیں، DB) اور Dispatchers.Default (CPU گہرے کاموں کے لیے: ترتیب، تصویری پروسیسنگ) شامل ہیں۔ WorkManager تاخیری اور ضمانتی پس منظر کے کاموں کے لیے ہے۔

HandlerThread — اپنے Looper (پیغام کی قطار) کے ساتھ پس منظر کا تھریڈ بنانے کے لیے ایک خاص Android کلاس ہے۔ Executors کے برعکس، HandlerThread Handler کے ذریعے پیغامات اور Runnable بھیجنے کی اجازت دیتا ہے۔ یہ ان آپریشنز کے لیے استعمال ہوتا ہے جنہیں قطار میں لگانے کی ضرورت ہوتی ہے (مثلاً، ترتیب وار DB تحریر)۔ استعمال کے بعد، وسائل کو آزاد کرنے کے لیے quit() یا quitSafely() کال کرنا ضروری ہے۔

// Android: Executors اور Coroutines Dispatchers
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import java.util.concurrent.Executors

class DataRepository {

    private val ioExecutor = Executors.newFixedThreadPool(4)

    // Executors کے ذریعے کلاسک طریقہ
    fun loadDataLegacy(callback: (String) -> Unit) {
        ioExecutor.execute {
            val result = readFromFile()
            val handler = android.os.Handler(android.os.Looper.getMainLooper())
            handler.post { callback(result) }
        }
    }

    // Coroutines کے ذریعے جدید طریقہ
    suspend fun loadDataCoroutines(): String {
        return withContext(Dispatchers.IO) {
            // فائل آپریشن — پس منظر کے پول میں انجام دے رہا ہے
            readFromFile()
        }
        // نتیجہ خود بخود Dispatchers.Main پر واپس آتا ہے
    }

    // Dispatchers.Default پر CPU گہرا کام
    suspend fun processImage(pixels: IntArray): IntArray {
        return withContext(Dispatchers.Default) {
            // ترتیب، فلٹرنگ — Default پول پر انجام دے رہا ہے
            pixels.sortedArray()
        }
    }

    private fun readFromFile(): String {
        Thread.sleep(1000) // فائل سے پڑھنے کی نقل
        return "file_content"
    }

    fun cleanup() {
        ioExecutor.shutdown()
    }
}

DataRepository کی مثال Android میں پس منظر کے تھریڈز کے ارتقاء کو ظاہر کرتی ہے۔ لیگیسی طریقہ loadDataLegacy Main Thread پر واپس آنے کے لیے Handler کے ساتھ Executors.newFixedThreadPool(4) استعمال کرتا ہے۔ جدید loadDataCoroutines withContext(Dispatchers.IO) استعمال کرتا ہے — coroutine تھریڈ کو بلاک کیے بغیر انجام دہی کے دوران معطل ہو جاتا ہے اور خود بخود Main Thread پر دوبارہ شروع ہو جاتا ہے۔ Dispatchers.Default CPU باؤنڈ آپریشنز (ترتیب، فلٹرنگ، ڈیٹا تبدیلی) کے لیے تجویز کیا جاتا ہے۔

پس منظر کے کاموں کے جدید معیار کے طور پر Coroutines

Kotlin Coroutines — تھریڈز کے ساتھ کام کرنے کا صرف ایک طریقہ نہیں، بلکہ ایک بنیادی طور پر مختلف ماڈل ہے: غیر متزلزل کام کسی مخصوص تھریڈ سے منسلک نہیں ہوتے اور بغیر بلاک کیے معطل ہو سکتے ہیں۔ اس کا مطلب ہے کہ پس منظر میں رہتے ہوئے، coroutine تھریڈ پر قبضہ نہیں کرتا بلکہ اسے دوسرے کاموں کے لیے آزاد کرتا ہے۔ معطلی کا طریقہ کار 4–8 تھریڈز کے پول پر thread starvation کے بغیر لاکھوں بیک وقت کاموں کو چلانے کی اجازت دیتا ہے۔

تین اہم ڈسپیچر: Dispatchers.Main (UI، ایک تھریڈ)، Dispatchers.IO (ڈیفالٹ طور پر 64 تھریڈز بلاک کرنے والے آپریشنز کے لیے: نیٹ ورک، فائلیں، DB)، Dispatchers.Default (CPU کورز کی تعداد کے برابر، گہرے حسابات کے لیے)۔ withContext کے ذریعے ان کو ملا کر، ڈویلپر کال بیک بنائے بغیر تھریڈز کے درمیان سوئچ کرتا ہے۔ withContext ایک suspend فنکشن ہے جو کام مکمل ہونے تک کنٹرول واپس نہیں کرتا۔

// Coroutines: پس منظر کے کاموں کی تشکیل
import kotlinx.coroutines.async
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.delay

suspend fun loadUserProfile(userId: String): UserProfile =
    coroutineScope {
        // مختلف ذرائع سے متوازی ڈیٹا لوڈنگ
        val user = async(Dispatchers.IO) { fetchUser(userId) }
        val posts = async(Dispatchers.IO) { fetchPosts(userId) }
        val avatar = async(Dispatchers.Default) {
            processAvatar(fetchAvatar(userId))
        }

        // await() — تمام کاموں کے مکمل ہونے تک معطل رہتا ہے
        UserProfile(
            user = user.await(),
            posts = posts.await(),
            avatar = avatar.await()
        )
    }

data class UserProfile(
    val user: String,
    val posts: List<String>,
    val avatar: ByteArray
)

suspend fun fetchUser(id: String): String { delay(300); return "User:$id" }
suspend fun fetchPosts(id: String): List<String> { delay(500); return listOf("Post1") }
suspend fun fetchAvatar(id: String): ByteArray { delay(200); return ByteArray(1024) }
suspend fun processAvatar(data: ByteArray): ByteArray { delay(100); return data }

loadUserProfile فنکشن async کے ذریعے تین متوازی پس منظر کے کام شروع کرتا ہے۔ fetchUser اور fetchPosts IO باؤنڈ (نیٹ ورک) ہیں، Dispatchers.IO پر انجام پاتے ہیں۔ processAvatar CPU باؤنڈ (تصویری پروسیسنگ) ہے، Dispatchers.Default پر انجام پاتا ہے۔ await() تمام کاموں کے مکمل ہونے تک coroutine کو معطل کرتا ہے۔ کل انجام دہی کا وقت تین کاموں کے درمیان زیادہ سے زیادہ وقت (fetchPosts کے لیے 500 ms) کے برابر ہے، ان کے مجموعے کے نہیں۔ یہ ترتیب وار انجام دہی پر coroutines کا ایک اہم فائدہ ہے۔

ساختی ہم آہنگی: رساو کی روک تھام

Structured concurrency — ایک اصول جہاں ہر coroutine کا ایک والدین کا دائرہ کار ہوتا ہے، اور والدین کو منسوخ کرنے سے بچوں کے coroutines خود بخود منسوخ ہو جاتے ہیں۔ Android میں، lifecycleScope Activity تباہ ہونے پر تمام coroutines کو منسوخ کر دیتا ہے۔ viewModelScope ViewModel صاف ہونے پر ایسا کرتا ہے۔ یہ پس منظر کے کاموں کے رساو کو روکتا ہے: اگر صارف اسکرین بند کر دیتا ہے، تو پس منظر میں رہتے ہوئے coroutine ان ڈیٹا کو لوڈ کرنا جاری نہیں رکھے گا جن کی اب ضرورت نہیں ہے۔

// Coroutines کے ساتھ WorkManager
import android.content.Context
import androidx.work.*
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext

class SyncWorker(
    appContext: Context,
    workerParams: WorkerParameters
) : CoroutineWorker(appContext, workerParams) {

    override suspend fun doWork(): Result {
        // Dispatchers.Default پر انجام دے رہا ہے (ڈیفالٹ)
        return withContext(Dispatchers.IO) {
            try {
                syncDataToServer()
                Result.success()
            } catch (e: Exception) {
                if (runAttemptCount < 3) Result.retry() else Result.failure()
            }
        }
    }

    private suspend fun syncDataToServer() {
        // مطابقت پذیری کی نقل
        delay(1000)
    }
}

// پابندیوں کے ساتھ WorkManager کام شروع کرنا
fun scheduleSync(context: Context) {
    val constraints = Constraints.Builder()
        .setRequiredNetworkType(NetworkType.CONNECTED)
        .setRequiresBatteryNotLow(true)
        .build()

    val syncWork = OneTimeWorkRequestBuilder<SyncWorker>()
        .setConstraints(constraints)
        .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 10, java.util.concurrent.TimeUnit.SECONDS)
        .build()

    WorkManager.getInstance(context).enqueue(syncWork)
}