모바일 개발에서 Thread — 개념, 유형 및 스레드 관리

Thread란

Thread(실행 스레드) — 운영체제가 CPU 코어에 스케줄할 수 있는 명령어의 독립적인 시퀀스입니다. 각 프로세스(애플리케이션)에는 최소 하나의 스레드인 Main Thread가 포함됩니다. 추가 스레드는 작업의 병렬 실행을 위해 생성됩니다. 각 스레드는 자체 프로그램 스택(지역 변수 포함), 프로그램 카운터(PC) 및 레지스터를 가집니다. 힙 메모리는 프로세스의 모든 스레드가 공유합니다.

모바일 OS에서는 스레드가 선점형 멀티태스킹(preemptive multitasking)으로 스케줄됩니다: OS는 언제든지 스레드 실행을 중단하고 다른 스레드에 제어권을 넘길 수 있습니다(컨텍스트 스위치). 컨텍스트 스위치는 CPU 레지스터 저장/복원, TLB 업데이트, 캐시 플러시가 필요하므로 비용이 큰 작업입니다(1-10마이크로초). 이것이 과도한 수의 스레드(수백, 수천)가 성능을 저하시키는 이유입니다 — OS가 실행보다 전환에 더 많은 시간을 소비합니다.

스레드와 프로세스 — 다른 개념입니다. 프로세스는 전용 가상 메모리를 가진 애플리케이션 인스턴스입니다. 프로세스 내의 스레드는 이 메모리를 다른 스레드와 공유합니다. Android에서 애플리케이션의 각 구성 요소(Activity, Service, BroadcastReceiver)는 하나의 프로세스에서 작동하지만 다른 스레드에서 실행될 수 있습니다. iOS 애플리케이션도 GCD 또는 Thread를 통해 추가 스레드를 생성할 수 있는 단일 프로세스입니다.

스레드의 생명주기: 상태와 전이

각 스레드는 Java/Kotlin(Android) 및 NSThread(iOS)에서 다섯 가지 상태를 거칩니다: New(생성됨), Runnable(실행 준비), Running(CPU에서 실행 중), Blocked/Waiting(리소스 또는 알림 대기), Terminated(종료됨). 상태 간 전이는 OS 스케줄러와 동기화 프리미티브에 의해 관리됩니다. 개발자는 스레드 우선순위(Thread.setPriority())와 상태(sleep, join, interrupt)에 영향을 줄 수 있습니다.

Android에서 스레드는 사용 중인 모니터(synchronized)를 획득하려 하거나 Object.wait() 또는 Thread.sleep()을 호출할 때 Blocked 상태가 됩니다. iOS에서는 NSCondition.wait(), pthread_cond_wait() 또는 dispatch_semaphore_wait() 호출 시 그렇습니다. Blocked 상태에서 스레드는 CPU를 소비하지 않지만 메모리(스택)를 점유합니다. 스레드는 다른 스레드에서 인터럽트(interrupted)되어 InterruptedException(Java) 또는 isCancelled(Kotlin Coroutines)를 받을 수 있습니다.

Context Switch와 그 비용

Context Switch(컨텍스트 스위치) — OS가 현재 스레드의 상태(레지스터, PC, TLB)를 저장하고 다른 스레드의 저장된 상태를 로드하는 작업입니다. 모바일 시스템(Linux + ART, iOS의 XNU)에서 컨텍스트 스위치는 1-10마이크로초가 걸립니다. 스레드가 100마이크로초에 작업을 수행하고 컨텍스트 스위치에 5마이크로초가 걸리면 5%의 시간이 낭비됩니다. 컨텍스트 스위치를 최소화하기 위해 iOS는 work stealing이 있는 GCD를 사용하고, Android는 fixedThreadCount가 있는 풀을 사용합니다.

Android의 Thread: Thread에서 Coroutines까지

Android는 저수준 java.lang.Thread에서 현대적인 코루틴으로 진화했습니다. 각 추상화 수준은 더 적은 오버헤드로 더 많은 기능을 제공합니다. Thread는 기본 클래스이지만 직접 생성은 권장되지 않습니다: 새 스레드가 풀에서 관리되지 않고 모니터링 및 취소가 어렵습니다. AsyncTask(API 30부터 deprecated)는 한 걸음 앞섰지만 메모리 누수와 불편한 구성 처리 문제가 있었습니다.

HandlerThread — Looper가 있는 Thread의 특별한 하위 클래스로, 메시지 큐를 처리할 수 있습니다. 백그라운드 스레드에서 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의 4가지 스레드 추상화 수준을 모두 보여줍니다. Thread 직접 생성은 가장 저수준이고 비효율적인 접근 방식입니다. HandlerThread는 백그라운드에서 순차적 작업에 유용합니다. Executors.newFixedThreadPool(4)는 최대 10개 작업의 병렬 실행을 위해 4개 스레드 풀을 생성합니다. Dispatchers.Default를 사용하는 Kotlin Coroutines는 현대적이고 효율적이며 안전한 방법입니다.

HandlerThread: 순차적 백그라운드 작업

HandlerThread — 내장 Looper와 메시지 큐를 가진 Thread의 특수화된 하위 클래스입니다. 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)
    }
}

// GCD 배리어를 통한 스레드 안전 컬렉션
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 {
            // 보호된 코드 — 스레드 안전
            doWork()
        }
    }

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

// 데드락 예제: 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") }
    }
}