Thread в мобильной разработке — что это, виды и управление потоками

Что такое Thread

Thread (поток выполнения) — это независимая последовательность инструкций, которую операционная система может запланировать на ядре CPU. Каждый процесс (приложение) содержит как минимум один поток — Main Thread. Дополнительные потоки создаются для параллельного выполнения задач. У каждого потока есть собственный программный стек (с локальными переменными), счётчик команд (PC) и регистры. Память кучи (heap) является общей для всех потоков процесса.

В мобильных ОС потоки планируются вытесняющей многозадачностью (preemptive multitasking): ОС может прервать выполнение потока в любой момент и передать управление другому (context switch). Переключение контекста — дорогостоящая операция (1-10 микросекунд), так как требует сохранения/восстановления регистров CPU, обновления TLB и сброса кешей. Именно поэтому чрезмерное количество потоков (сотни и тысячи) ухудшает производительность — ОС тратит больше времени на переключение, чем на выполнение.

Поток и процесс — разные понятия. Процесс — это экземпляр приложения с выделенной виртуальной памятью. Поток внутри процесса разделяет эту память с другими потоками. В Android каждый компонент приложения (Activity, Service, BroadcastReceiver) работает в одном процессе, но может выполняться в разных потоках. iOS-приложение также является одним процессом с возможностью создания дополнительных потоков через GCD или Thread.

Жизненный цикл потока: состояния и переходы

Каждый поток в Java/Kotlin (Android) и NSThread (iOS) проходит через пять состояний: New (создан), Runnable (готов к выполнению), Running (выполняется на CPU), Blocked/Waiting (ожидает ресурса или уведомления), Terminated (завершён). Переходы между состояниями управляются планировщиком ОС и синхронизационными примитивами. Разработчик может влиять на приоритет потока (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 (переключение контекста) — операция, при которой ОС сохраняет состояние текущего потока (регистры, PC, TLB) и загружает сохранённое состояние другого. В мобильных системах (Linux + ART, XNU для iOS) context switch занимает 1-10 микросекунд. Если поток выполняет задачу за 100 микросекунд, а context switch занимает 5, то 5% времени тратится впустую. Для минимизации context switch iOS использует GCD с work stealing, Android — пулы с fixedThreadCount.

Thread в Android: от Thread до Coroutines

Android прошёл эволюцию от низкоуровневого java.lang.Thread до современных корутин. Каждый уровень абстракции даёт больше возможностей с меньшими накладными расходами. Thread — базовый класс, но его прямое создание не рекомендуется: новый поток не управляется пулом, его трудно мониторить и отменять. AsyncTask (deprecated с API 30) был шагом вперёд, но страдал от утечек памяти и неудобной обработки конфигураций.

HandlerThread — специальный подкласс Thread с Looper, который может обрабатывать очередь сообщений. Используется для последовательного выполнения задач на фоновом потоке, например, запись данных в 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) создаёт пул из 4 потоков для параллельного выполнения до 10 задач. Kotlin Coroutines с Dispatchers.Default — современный, эффективный и безопасный способ.

HandlerThread: последовательные фоновые задачи

HandlerThread — специализированный подкласс Thread с встроенным Looper и очередью сообщений. Он создаётся вызовом 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)
    }
}

// Thread-safe коллекция через GCD barrier
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 {
            // protected code — потокобезопасно
            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") }
    }
}