モバイル開発におけるThread — その概要、種類、スレッド管理

Threadとは

Thread（実行スレッド） — オペレーティングシステムがCPUコアにスケジュールできる命令の独立したシーケンスです。各プロセス（アプリケーション）には少なくとも1つのスレッド（メインスレッド）が含まれます。追加のスレッドはタスクの並列実行のために作成されます。各スレッドは独自のプログラムスタック（ローカル変数を含む）、プログラムカウンタ（PC）、レジスタを持ちます。ヒープメモリはプロセスのすべてのスレッドで共有されます。

モバイルOSでは、スレッドはプリエンプティブマルチタスクによってスケジュールされます：OSはいつでもスレッドの実行を中断し、別のスレッドに制御を渡すことができます（コンテキストスイッチ）。コンテキストスイッチはコストの高い操作です（1〜10マイクロ秒）。CPUレジスタの保存/復元、TLBの更新、キャッシュのフラッシュが必要だからです。これが、過剰な数のスレッド（数百から数千）がパフォーマンスを低下させる理由です — OSは実行よりも切り替えに多くの時間を費やします。

スレッドとプロセス — 異なる概念です。プロセスは専用の仮想メモリを持つアプリケーションのインスタンスです。プロセス内のスレッドはこのメモリを他のスレッドと共有します。Androidでは、アプリケーションの各コンポーネント（Activity、Service、BroadcastReceiver）は1つのプロセスで動作しますが、異なるスレッドで実行できます。iOSアプリケーションも、GCDやThreadを介して追加スレッドを作成できる単一のプロセスです。

スレッドのライフサイクル：状態と遷移

各スレッドはJava/Kotlin（Android）とNSThread（iOS）で5つの状態を経ます：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（コンテキストスイッチ） — 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で非推奨）は一歩前進でしたが、メモリリークや設定処理の不便さに悩まされていました。

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

        // 書き込み同期のためのバリア
        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() {
        // 一度に1スレッドのみ
        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") }
    }
}