Background Thread در توسعه موبایل: چیست، وظایف و روش‌های استفاده

Background Thread چیست

Background Thread — هر نخی در برنامه که Main Thread نیست و به UI دسترسی ندارد. وظیفه آن آزاد کردن نخ اصلی از عملیات سنگین است تا رابط کاربری پاسخگو باقی بماند. سیستم عامل نخ‌های پس‌زمینه را بین هسته‌های پردازنده توزیع می‌کند و امکان اجرای همزمان چندین وظیفه را فراهم می‌کند. iOS به طور خودکار pool نخ‌ها را از طریق GCD مدیریت می‌کند، Android — از طریق poolهای 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 برای مدیریت گروهی اولویت‌های نخ استفاده می‌کند.

Background Thread در iOS: GCD و DispatchQueue.global

DispatchQueue.global(qos:) — روش اصلی دریافت صف پس‌زمینه در iOS. GCD (Grand Central Dispatch) به طور خودکار pool نخ ایجاد می‌کند و وظایف را بین هسته‌ها توزیع می‌کند. فراخوانی 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"]

        // OperationQueue با maxConcurrentOperationCount = 2
        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 دو تصویر را به صورت موازی بارگیری می‌کند (maxConcurrentOperationCount = 2) با پس‌زمینه از طریق qualityOfService = .utility. روش GCD backgroundTaskWithQoS از صف جهانی با .userInitiated برای وظیفه‌ای که کاربر منتظر نتیجه آن است استفاده می‌کند. هر دو رویکرد با بازگشت به DispatchQueue.main برای به‌روزرسانی UI پایان می‌یابند — این یک الزام اجباری iOS است.

صف‌های پس‌زمینه Serial در مقابل Concurrent

GCD از دو نوع صف پشتیبانی می‌کند: serial (ترتیبی) و concurrent (موازی). صف‌های serial وظایف را یکی پس از دیگری اجرا می‌کنند — این برای دسترسی به یک منبع مشترک (فایل، پایگاه داده) بدون قفل مناسب است. صف‌های concurrent وظایف را به صورت موازی اجرا می‌کنند و آنها را بین هسته‌های آزاد توزیع می‌کنند. DispatchQueue.global — همیشه concurrent. برای ایجاد صف serial از DispatchQueue(label: "com.app.queue") استفاده کنید.

Background Thread در Android: Executors و Dispatchers

Android چندین سطح انتزاع برای نخ‌های پس‌زمینه ارائه می‌دهد. رویکرد کلاسیک — java.util.concurrent.Executors.newFixedThreadPool(n) یا Executors.newCachedThreadPool(). رویکرد مدرن — Kotlin Coroutines با Dispatchers.IO (برای ورودی/خروجی: شبکه، فایل‌ها، پایگاه داده) و Dispatchers.Default (برای وظایف سنگین CPU: مرتب‌سازی، پردازش تصاویر). WorkManager — برای وظایف پس‌زمینه تأخیری و تضمینی.

HandlerThread — کلاس مخصوص Android برای ایجاد نخ پس‌زمینه با Looper (صف پیام) خود. برخلاف Executors، HandlerThread اجازه ارسال پیام‌ها و Runnable را از طریق Handler می‌دهد. برای عملیاتی که نیاز به صف‌بندی دارند (مثلاً نوشتن ترتیبی در پایگاه داده) استفاده می‌شود. پس از استفاده باید 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) {
            // عملیات فایل — در pool پس‌زمینه اجرا می‌شود
            readFromFile()
        }
        // نتیجه به طور خودکار به Dispatchers.Main بازمی‌گردد
    }

    // وظیفه سنگین CPU روی Dispatchers.Default
    suspend fun processImage(pixels: IntArray): IntArray {
        return withContext(Dispatchers.Default) {
            // مرتب‌سازی، فیلتر کردن — روی Default-pool اجرا می‌شود
            pixels.sortedArray()
        }
    }

    private fun readFromFile(): String {
        Thread.sleep(1000) // شبیه‌سازی خواندن از فایل
        return "file_content"
    }

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

مثال DataRepository تکامل نخ‌های پس‌زمینه در Android را نشان می‌دهد. روش legacy loadDataLegacy از Executors.newFixedThreadPool(4) با Handler برای بازگشت به Main Thread استفاده می‌کند. روش مدرن loadDataCoroutines از withContext(Dispatchers.IO) استفاده می‌کند — کروتین در طول کار متوقف می‌شود، نخ را مسدود نمی‌کند و به طور خودکار در Main Thread از سر گرفته می‌شود. Dispatchers.Default برای عملیات CPU-bound (مرتب‌سازی، فیلتر کردن، تبدیل داده) توصیه می‌شود.

کروتین‌ها به عنوان استاندارد مدرن وظایف پس‌زمینه

Kotlin Coroutines — نه فقط یک روش کار با نخ‌ها، بلکه یک مدل اساساً متفاوت: وظایف ناهمزمان به یک نخ خاص متصل نیستند و می‌توانند بدون مسدودسازی معلق شوند (suspend). این بدان معناست که در حین کار پس‌زمینه، کروتین نخ را اشغال نمی‌کند، بلکه آن را برای وظایف دیگر آزاد می‌کند. مکانیزم suspension امکان اجرای صدها هزار وظیفه concurrent را در pool 4-8 نخ بدون thread starvation فراهم می‌کند.

سه dispatcher اصلی: Dispatchers.Main (UI، یک نخ), Dispatchers.IO (64 نخ به طور پیش‌فرض برای عملیات مسدودکننده: شبکه، فایل‌ها، پایگاه داده), Dispatchers.Default (برابر با تعداد هسته‌های CPU، برای محاسبات فشرده). با ترکیب آنها از طریق withContext، توسعه‌دهنده بین نخ‌ها بدون ایجاد callback جابه‌جا می‌شود. withContext یک تابع suspend است که تا زمانی که وظیفه انجام نشده، کنترل را بازنمی‌گرداند.

// کروتین‌ها: ترکیب وظایف پس‌زمینه
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-bound (شبکه)، روی Dispatchers.IO اجرا می‌شوند. processAvatar — CPU-bound (پردازش تصویر)، روی Dispatchers.Default اجرا می‌شود. await() کروتین را تا تکمیل همه وظایف معلق می‌کند. زمان کل اجرا برابر با حداکثر زمان بین سه وظیفه است (500 میلی‌ثانیه برای fetchPosts)، نه مجموع آنها. این مزیت کلیدی coroutines نسبت به اجرای ترتیبی است.

Structured concurrency: جلوگیری از نشت

Structured concurrency — اصلی که در آن هر کروتین یک scope والد دارد و لغو والد به طور خودکار کروتین‌های فرزند را لغو می‌کند. در Android lifecycleScope تمام کروتین‌ها را هنگام نابودی Activity لغو می‌کند. viewModelScope — هنگام پاکسازی ViewModel. این از نشت وظایف پس‌زمینه جلوگیری می‌کند: اگر کاربر صفحه را بست، کروتین پس‌زمینه به بارگیری داده‌هایی که دیگر به درد کسی نمی‌خورند ادامه نخواهد داد.

// 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)
}