Thread in mobile development — what it is, types and thread management

What is Thread

Thread (execution thread) is an independent sequence of instructions that the operating system can schedule on a CPU core. Each process (application) contains at least one thread — the Main Thread. Additional threads are created for parallel task execution. Each thread has its own program stack (with local variables), program counter (PC) and registers. The heap memory is shared among all threads of the process.

In mobile operating systems, threads are scheduled using preemptive multitasking: the OS can interrupt a thread’s execution at any moment and hand control to another (context switch). Context switching is an expensive operation (1–10 microseconds) as it requires saving/restoring CPU registers, updating the TLB and flushing caches. This is why an excessive number of threads (hundreds or thousands) degrades performance — the OS spends more time switching than executing.

Thread vs Process — different concepts. A process is an instance of an application with allocated virtual memory. A thread within a process shares this memory with other threads. In Android, each application component (Activity, Service, BroadcastReceiver) works in one process but can execute on different threads. An iOS application is also a single process capable of creating additional threads through GCD or Thread.

Thread Lifecycle: States and Transitions

Each thread in Java/Kotlin (Android) and NSThread (iOS) goes through five states: New (created), Runnable (ready to execute), Running (executing on CPU), Blocked/Waiting (waiting for a resource or notification), Terminated (finished). Transitions between states are managed by the OS scheduler and synchronization primitives. The developer can influence thread priority (Thread.setPriority()) and its state (sleep, join, interrupt).

In Android, a thread enters the Blocked state when trying to acquire a busy monitor (synchronized), calling Object.wait() or Thread.sleep(). In iOS — when calling NSCondition.wait(), pthread_cond_wait() or dispatch_semaphore_wait(). In the Blocked state, the thread does not consume CPU but still occupies memory (stack). A thread can be interrupted from another thread, receiving InterruptedException (Java) or checking isCancelled (Kotlin Coroutines).

Context Switch and Its Cost

Context switch is an operation where the OS saves the current thread’s state (registers, PC, TLB) and loads the saved state of another. In mobile systems (Linux + ART, XNU for iOS) a context switch takes 1–10 microseconds. If a thread executes a task in 100 microseconds and a context switch takes 5, then 5% of time is wasted. To minimize context switching, iOS uses GCD with work stealing, Android uses pools with fixedThreadCount.

Thread in Android: From Thread to Coroutines

Android has evolved from low-level java.lang.Thread to modern coroutines. Each abstraction level provides more capabilities with lower overhead. Thread is the base class, but its direct creation is not recommended: a new thread is not managed by a pool, it’s hard to monitor and cancel. AsyncTask (deprecated since API 30) was a step forward, but suffered from memory leaks and inconvenient configuration handling.

HandlerThread is a special Thread subclass with Looper that can process a message queue. It is used for sequential execution of tasks on a background thread, for example, writing data to Room or files. HandlerThread is created by calling start(), after which messages and Runnable can be sent via Handler(handlerThread.looper). Calling handlerThread.quit() stops the Looper and terminates the thread.

// Android: Thread, HandlerThread and Executors
import android.os.Handler
import android.os.HandlerThread
import java.util.concurrent.Executors

class ThreadExample {

    // 1. Direct Thread creation (not recommended)
    fun directThread() {
        val thread = Thread(Runnable {
            Thread.sleep(1000)
            print("Direct thread executed")
        })
        thread.start()
    }

    // 2. HandlerThread for sequential background tasks
    fun handlerThreadExample() {
        val handlerThread = HandlerThread("BackgroundQueue")
        handlerThread.start()

        val handler = Handler(handlerThread.looper)
        handler.post {
            // Sequential execution on a background thread
            Thread.sleep(500)
            print("HandlerThread: task completed")
        }

        // Stopping the thread (executed when tasks are finished)
        handlerThread.quitSafely()
    }

    // 3. Executors — thread pool
    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 — modern standard
    suspend fun coroutineExample() = kotlinx.coroutines.withContext(
        kotlinx.coroutines.Dispatchers.Default
    ) {
        print("Coroutine on thread: ${Thread.currentThread().getName()}")
    }
}

The ThreadExample demonstrates all four levels of thread abstraction in Android. Direct Thread creation is the lowest-level and most inefficient approach. HandlerThread is useful for sequential background tasks. Executors.newFixedThreadPool(4) creates a pool of 4 threads for parallel execution of up to 10 tasks. Kotlin Coroutines with Dispatchers.Default is a modern, efficient and safe approach.

HandlerThread: Sequential Background Tasks

HandlerThread is a specialized Thread subclass with a built-in Looper and message queue. It is created by calling start(), after which Runnable and messages can be sent via Handler(handlerThread.looper). HandlerThread executes tasks strictly sequentially — the next task does not start until the previous one completes. This is convenient for writing data to Room or files, where operation order is critical. Calling quitSafely() stops the Looper after the current task completes.

import Foundation

class ThreadManager {

    // 1. Thread (low-level)
    func createThread() {
        let thread = Thread {
            // Code executing on a new thread
            print("Current thread: \(Thread.current)")
        }
        thread.name = "com.app.worker"
        thread.qualityOfService = .utility
        thread.start()
    }

    // 2. GCD — DispatchQueue
    func gcdExample() {
        // Concurrent queue
        let queue = DispatchQueue(label: "com.app.concurrent",
                                 qos: .utility,
                                 attributes: .concurrent)

        queue.async {
            print("GCD async task")
        }

        // Barrier for write synchronization
        queue.async(flags: .barrier) {
            // Exclusive access during write
            print("Barrier write: exclusive access")
        }
    }

    // 3. OperationQueue with dependencies
    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...")
        }

        // Dependencies: download -> process -> save
        process.addDependency(download)
        save.addDependency(process)

        queue.addOperations([download, process, save], waitUntilFinished: false)
    }
}

// Thread-safe collection via 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)
        }
    }
}

// Synchronization in Android/Kotlin
import java.util.concurrent.atomic.AtomicInteger
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

class Counter {

    // 1. AtomicInteger — for simple counters
    private val atomicCount = AtomicInteger(0)
    fun incrementAtomic() = atomicCount.incrementAndGet()

    // 2. synchronized — for critical sections
    @Synchronized
    fun synchronizedOperation() {
        // Only one thread at a time
        doWork()
    }

    // 3. Coroutine Mutex — suspend-safe
    private val mutex = Mutex()
    suspend fun mutexOperation() {
        mutex.withLock {
            // protected code — thread-safe
            doWork()
        }
    }

    private fun doWork() { /* critical section */ }
}

// Deadlock example: A locks B, B locks 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") }
    }
}