Background Thread mobil ishlab chiqishda: bu nima, vazifalar va foydalanish usullari

Background Thread nima

Background Thread — ilovada Main Thread bo'lmagan va UI-ga kirish imkoniga ega bo'lmagan har qanday oqim. Uning vazifasi asosiy oqimni og'ir operatsiyalardan ozod qilishdir, shunda interfeys javob beruvchan bo'lib qoladi. Operatsion tizim fon oqimlarini protsessor yadrolari bo'ylab taqsimlab, bir nechta vazifalarni parallel bajarishga imkon beradi. iOS avtomatik ravishda GCD orqali oqimlar hovuzini boshqaradi, Android — Java Executors hovuzlari orqali.

Main Thread-dan farqli o'laroq, voqealarni ketma-ket qayta ishlaydigan (birma-bir), fon oqimlari parallel bajarilishi mumkin, faqat CPU yadrolari soni bilan cheklangan. Masalan, 8 yadroli qurilmada sezilarli sekinlashuvsiz 8 tagacha parallel fon vazifasini ishga tushirish mumkin. Biroq, haddan tashqari ko'p oqimlar (yuzlab) thread starvation-ga olib keladi — yadrolar uchun raqobat va kontekst almashtirish (context switch) uchun qo'shimcha xarajatlarning oshishi.

Quality of Service (QoS) — iOS mexanizmi, fon vazifasining ustuvorligini belgilashga imkon beradi. Qiymatlar: .userInteractive (eng yuqori, deyarli Main Thread), .userInitiated (foydalanuvchi natijani kutadi), .default (standart), .utility (foydalanuvchi bevosita kutmaydi), .background (eng past, sinxronizatsiya va indekslash uchun). Android-da analog Thread.setPriority() 1 dan 10 gacha, ammo Android shuningdek oqim ustuvorliklarini guruhli boshqarish uchun cgroups dan foydalanadi.

iOS-da Background Thread: GCD va DispatchQueue.global

DispatchQueue.global(qos:) — iOS-da fon navbatini olishning asosiy usuli. GCD (Grand Central Dispatch) avtomatik ravishda oqimlar hovuzini yaratadi va vazifalarni yadrolar bo'ylab taqsimlaydi. DispatchQueue.global(qos: .background).async {} chaqiruvi bajarish blokini eng past ustuvorlikdagi fon navbatiga yuboradi. Natijasi darhol kerak bo'lgan vazifalar uchun .userInitiated yoki .utility dan foydalaning.

OperationQueue — GCD ustidagi yuqori darajadagi abstraksiya bo'lib, operatsiyalar o'rtasidagi bog'liqliklarni, bir vaqtda bajariladigan operatsiyalarning maksimal sonini (maxConcurrentOperationCount) va ustuvorliklarni belgilashga imkon beradi. OperationQueue murakkab ko'p vazifali zanjirlar uchun qulay: faylni yuklab olish -> ochish -> keshda saqlash. Odatiy bo'lib, OperationQueue boshqacha ko'rsatilmagan bo'lsa, fon oqimlaridan foydalanadi.

import UIKit

class ImageDownloader {

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

        // OperationQueue maxConcurrentOperationCount = 2 bilan
        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("Yuklandi: \(url.lastPathComponent)")
                }
            }
        }
    }

    // GCD: turli QoS bilan global fon navbati
    func backgroundTaskWithQoS() {
        DispatchQueue.global(qos: .userInitiated).async {
            // Yuqori ustuvorlik — foydalanuvchi natijani kutadi
            let result = self.heavyComputation()
            DispatchQueue.main.async {
                self.showResult(result)
            }
        }
    }

    private func heavyComputation() -> String {
        Thread.sleep(forTimeInterval: 2) // ish simulyatsiyasi
        return "Hisoblash natijasi"
    }

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

Misolda OperationQueue ikkita rasmni parallel yuklaydi (maxConcurrentOperationCount = 2) fon bilan qualityOfService = .utility orqali. GCD metodi backgroundTaskWithQoS foydalanuvchi natijasini kutayotgan vazifa uchun .userInitiated bilan global navbatdan foydalanadi. Ikkala yondashuv UI yangilash uchun DispatchQueue.main-ga qaytish bilan tugaydi — bu iOS-ning majburiy talabidir.

Serial vs Concurrent fon navbatlari

GCD ikki turdagi navbatni qo'llab-quvvatlaydi: serial (ketma-ket) va concurrent (parallel). Serial navbatlar vazifalarni birma-bir bajaradi — bu blokirovkalarsiz umumiy resursga (fayl, Ma'lumotlarBazasi) kirish uchun qulay. Concurrent navbatlar vazifalarni parallel bajaradi, ularni bo'sh yadrolarga taqsimlaydi. DispatchQueue.global — har doim concurrent. Serial navbat yaratish uchun DispatchQueue(label: "com.app.queue") dan foydalaning.

Android-da Background Thread: Executors va Dispatchers

Android fon oqimlari uchun bir nechta abstraksiya darajalarini taqdim etadi. Klassik yondashuv — java.util.concurrent.Executors.newFixedThreadPool(n) yoki Executors.newCachedThreadPool(). Zamonaviy — Kotlin Coroutines Dispatchers.IO (kirish-chiqish uchun: tarmoq, fayllar, Ma'lumotlarBazasi) va Dispatchers.Default (CPU intensiv vazifalar uchun: saralash, tasvir qayta ishlash). WorkManager — kechiktirilgan va kafolatlangan fon vazifalari uchun.

HandlerThread — o'z Looper (xabar navbati) bilan fon oqimi yaratish uchun maxsus Android klassi. Executors-dan farqli o'laroq, HandlerThread Handler orqali xabarlar va Runnable yuborishga imkon beradi. Navbatga qo'yishni talab qiladigan operatsiyalar uchun ishlatiladi (masalan, ma'lumotlar bazasiga ketma-ket yozish). Foydalanishdan keyin resurslarni bo'shatish uchun HandlerThread-da quit() yoki quitSafely() chaqirilishi kerak.

// Android: Executors va Coroutines Dispatchers
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import java.util.concurrent.Executors

class DataRepository {

    private val ioExecutor = Executors.newFixedThreadPool(4)

    // Executors orqali klassik yondashuv
    fun loadDataLegacy(callback: (String) -> Unit) {
        ioExecutor.execute {
            val result = readFromFile()
            val handler = android.os.Handler(android.os.Looper.getMainLooper())
            handler.post { callback(result) }
        }
    }

    // Coroutines orqali zamonaviy yondashuv
    suspend fun loadDataCoroutines(): String {
        return withContext(Dispatchers.IO) {
            // Fayl operatsiyasi — fon hovuzida bajariladi
            readFromFile()
        }
        // Natija avtomatik ravishda Dispatchers.Main-ga qaytadi
    }

    // Dispatchers.Default da CPU intensiv vazifa
    suspend fun processImage(pixels: IntArray): IntArray {
        return withContext(Dispatchers.Default) {
            // Saralash, filtrlash — Default hovuzida bajariladi
            pixels.sortedArray()
        }
    }

    private fun readFromFile(): String {
        Thread.sleep(1000) // fayldan o'qish simulyatsiyasi
        return "file_content"
    }

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

DataRepository misoli Android-da fon oqimlarining evolyutsiyasini ko'rsatadi. Legacy metod loadDataLegacy Main Thread-ga qaytish uchun Executors.newFixedThreadPool(4) bilan Handler dan foydalanadi. Zamonaviy loadDataCoroutines withContext(Dispatchers.IO) dan foydalanadi — korutin ish vaqtida to'xtaydi, oqimni bloklamaydi va avtomatik ravishda Main Thread-da tiklanadi. Dispatchers.Default CPU-bound operatsiyalari uchun tavsiya etiladi (saralash, filtrlash, ma'lumotlarni transformatsiya qilish).

Korutinlar fon vazifalarining zamonaviy standarti sifatida

Kotlin Coroutines — shunchaki oqimlar bilan ishlash usuli emas, balki tubdan farqli model: asinxron vazifalar muayyan oqimga bog'liq emas va bloklamasdan to'xtab qolishi mumkin (suspend). Bu shuni anglatadiki, fon ishi vaqtida korutin oqimni egallab olmaydi, balki uni boshqa vazifalar uchun bo'shatadi. Suspension mexanizmi thread starvation holda 4-8 oqim hovuzida yuz minglab concurrent vazifalarni bajarishga imkon beradi.

Uchta asosiy dispatcher: Dispatchers.Main (UI, bitta oqim), Dispatchers.IO (odatiy bo'lib 64 oqim bloklovchi operatsiyalar uchun: tarmoq, fayllar, Ma'lumotlarBazasi), Dispatchers.Default (CPU yadrolari soniga teng, intensiv hisoblashlar uchun). Ularni withContext orqali birlashtirib, dasturchi callback yaratmasdan oqimlar o'rtasida o'tadi. withContext — vazifa bajarilmaguncha boshqaruvni qaytarmaydigan suspend funksiyadir.

// Korutinlar: fon vazifalari kompozitsiyasi
import kotlinx.coroutines.async
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.delay

suspend fun loadUserProfile(userId: String): UserProfile =
    coroutineScope {
        // Turli manbalardan parallel ma'lumot yuklash
        val user = async(Dispatchers.IO) { fetchUser(userId) }
        val posts = async(Dispatchers.IO) { fetchPosts(userId) }
        val avatar = async(Dispatchers.Default) {
            processAvatar(fetchAvatar(userId))
        }

        // await() — barcha vazifalar tugaguncha to'xtaydi
        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 funksiyasi async orqali uchta parallel fon vazifasini ishga tushiradi. fetchUser va fetchPosts — IO-bound (tarmoq), Dispatchers.IO da bajariladi. processAvatar — CPU-bound (tasvirni qayta ishlash), Dispatchers.Default da bajariladi. await() barcha vazifalar tugaguncha korutinni to'xtatadi. Umumiy bajarish vaqti uchta vazifa orasidagi maksimal vaqtga teng (fetchPosts uchun 500 ms), ularning yig'indisiga emas. Bu coroutines-ning ketma-ket bajarishga nisbatan asosiy ustunligidir.

Structured concurrency: oqishlarning oldini olish

Structured concurrency — har bir korutin ota-scope ga ega bo'lgan va ota-ona bekor qilinishi avtomatik ravishda bolakay korutinlarni bekor qiladigan prinsip. Android-da lifecycleScope Activity yo'q qilinganda barcha korutinlarni bekor qiladi. viewModelScope — ViewModel tozalanganda. Bu fon vazifalarining oqishining oldini oladi: agar foydalanuvchi ekranni yopgan bo'lsa, fon korutini endi hech kimga kerak bo'lmagan ma'lumotlarni yuklashni davom ettirmaydi.

// WorkManager korutinlar bilan
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 da bajariladi (odatiy)
        return withContext(Dispatchers.IO) {
            try {
                syncDataToServer()
                Result.success()
            } catch (e: Exception) {
                if (runAttemptCount < 3) Result.retry() else Result.failure()
            }
        }
    }

    private suspend fun syncDataToServer() {
        // Sinxronizatsiya simulyatsiyasi
        delay(1000)
    }
}

// Cheklovlar bilan WorkManager vazifasini ishga tushirish
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)
}