スレッド処理の限界とコルーチン登場の理由

こんにちは！　アスクルの程です！

今回は、スレッド処理の限界とコルーチンが登場した理由についてお話しします。

はじめに

実務でコルーチンを活用しているうちに、なぜコルーチンが生まれたのかという疑問が湧いてきました。そこで、スレッド処理の限界とコルーチンが登場した背景を整理して共有したいと思い、この内容をまとめました。

スレッドとは？

スレッドとは、1つのプロセス内で独立して動作できる実行単位です。プロセスがメモリ空間を提供し、その中で実際の作業をするのがスレッドです。単一スレッドでは、一度に1つの作業しか行えず、I/O処理や重い処理がある場合、アプリケーション全体がブロックされます。これを克服するためにマルチスレッドプログラミングが登場しました。

Thread（Java 1.0）の登場と限界

Java 1.0では、Threadを利用して簡単な並列処理が可能になりました。

fun main() {
    val thread = Thread {
        println("新しいスレッド:こんにちは！")
    }
    thread.start()
}

しかし、ここには次のような限界が存在します。

限界（1）: スレッドの再利用が困難

start()を呼ぶたびに新しいスレッドが生成されます。再利用できず、スレッド生成のコストが高まります。

限界（2）: スレッド管理責任は開発者にある

開発者がスレッドの作成・終了・例外処理をすべて管理するため、次の問題が起きやすくなります。

メモリリークの危険性

開発者がスレッドの停止処理（interruptやjoin）を忘れると、スレッドが生き続けてメモリリークを引き起こします。

複雑さの増加による管理困難性

プログラムが複雑になるほど、どのスレッドがどの処理をしているのか把握が難しくなります。たとえば、大規模なウェブサーバで数百のスレッドを管理する必要が生じると、手動で個別に管理することは現実的でもないし、エラーが発生しやすくなります。

fun main() {
    repeat(1000) { i ->
        val thread = Thread {
            try {
                // 長時間実行のタスク
                println("処理$i 実行中")
                Thread.sleep(5000)
            } catch (e: InterruptedException) {
                println("処理$i が中断されました")
            }
        }
        thread.start()
        // 終了処理が抜けていると、メモリやCPU資源が消耗し続けます
    }
}

上記のように、スレッド管理を誤ると、システムリソースが枯渇してしまう可能性があります。

Executor（Java 1.5）フレームワークの登場と限界

Java 1.5から登場したExecutorフレームワークは、次の点でスレッド管理を容易にしました。

利点（1）: スレッドの再利用

スレッドプールを利用し、スレッドを効率的に再利用できるようになりました。

利点（2）: 開発者が直接スレッドを管理する必要がない

開発者はタスクをExecutorに渡すだけでよく、スレッドの作成や終了処理を自動的に行ってくれます。

fun main() {
    // 固定サイズのスレッドプール（ここでは3個）を用意
    val executor = Executors.newFixedThreadPool(3)
    repeat(5) { task ->
        executor.submit {
            println("タスク$task 実行中 - スレッド名: ${Thread.currentThread().name}")
            Thread.sleep(1000)
            println("タスク$task 完了")
        }
    }
    executor.shutdown() // 全タスク完了後、自動でスレッド終了
}

このコードでは、次のようなメリットがあります。

開発者は個別のスレッドを作成・管理する必要がない
自動的にスレッドが再利用されるため、リソースが効率よく活用される

Executorの限界：スレッドブロッキングの問題

ただし、Executorにも問題があります。タスク内で長時間のブロッキング処理が発生すると、スレッドが不足し、後続のタスクが待機状態になります。

val executor = Executors.newFixedThreadPool(2)
repeat(10) { task ->
    executor.submit {
        Thread.sleep(5000) // スレッドをブロック
        println("タスク$task 終了")
    }
}
executor.shutdown()

このコードでは2つのスレッドで10個のタスクを処理するため、各タスクがスレッドを5秒間占有します。結果として、後続のタスクが長時間の待機状態となり、処理効率が著しく低下します。

コルーチンによるスレッドブロッキング問題の解決

コルーチンは上記のスレッドブロッキング問題を解決するために登場しました。コルーチンは軽量スレッドのようなものであり、スレッドの使用権を他のコルーチンに譲渡(yield)できます。これにより、スレッドを効率よく使いながら非同期処理を実現します。

fun main() = runBlocking {
    repeat(10) { task ->
        launch {
            delay(3000) // 非ブロッキングな待機
            println("タスク $task 完了")
        }
    }
}

上記のコードは、従来のThread.sleep()とは異なり、delay()を用いてスレッドをブロックしません。コルーチンは次のような利点があります。

利点（1）：スレッドをブロックせず、他の処理に譲渡可能

コルーチンは1つのスレッド内で複数のタスクを効率よく処理できます。これは、あるタスクが待機時間(delay)に入ると、その間にスレッドを他のタスクへ譲る（yield）ことができるためです。

fun main() = runBlocking {
    launch {
        println("タスク１開始: ${Thread.currentThread().name}")
        delay(1000) // 1秒間非ブロッキング待機
        println("タスク１終了: ${Thread.currentThread().name}")
    }
    launch {
        println("タスク２開始: ${Thread.currentThread().name}")
        delay(500) // 0.5秒間非ブロッキング待機
        println("タスク２終了: ${Thread.currentThread().name}")
    }
}

実行結果の例

タスク１開始: main
タスク２開始: main
タスク２終了: main
タスク１終了: main

このように、1つのスレッド（mainスレッド）だけで、複数のタスクを効率よく切り替えて処理しています。 delayを使用している間も、スレッドを占有（ブロック）せずに別のタスクを実行できます。

利点（2）：スレッド生成コストが低く、多数の処理が可能

コルーチンの最大の特徴は「軽量スレッド」とも呼ばれるほど生成コストが低く、非常に多くの処理を効率よく並行実行できる点です。従来のスレッドは、生成と管理に多くのメモリやCPUリソースが必要であり、一度に大量のスレッドを作成するとシステムが不安定になる可能性があります。しかし、コルーチンはスレッドを新たに生成するのではなく、既存のスレッド上で動く軽量なタスクとして実行されるため、大量に作成しても問題なく動作します。

fun main() = runBlocking {
    val coroutineCount = 100_000 // 10万個のコルーチンを作成します
    val time = measureTimeMillis {
        val jobs = List(coroutineCount) {
            launch {
                delay(1000L) // 非ブロッキングで1秒間待機します
            }
        }
        jobs.forEach { it.join() } // すべてのコルーチンの完了を待機します
    }
    println("10万個のコルーチン処理完了までの時間: $time ms")
}

上記の例では、10万個という非常に多くのコルーチンを作成しています。これを従来のスレッドで実行しようとすると、リソース不足やシステムクラッシュを引き起こす可能性がありますが、コルーチンでは正常に完了します。

なぜコルーチンはこれが可能なのか？

コルーチンはOSスレッドとは異なり、言語側でタスクの切り替えが行われるため、大量に動かしてもシステムへの負荷を抑えることができます。また、各コルーチンは中断しても、現在の状態をメモリに効率よく保持しておき、必要な時に再開できます。このように、コルーチンの特徴をまとめると次のとおりです。

生成コストが非常に低い
メモリ消費量もスレッドより遥かに少ない
1つのスレッド内で多くの処理を効率的に並行して動かせる
タスクの切り替え（コンテキストスイッチ）の負荷も極めて小さい

これらの理由から、バックエンドアプリケーションで大量のリクエスト処理や非同期タスクを実装する際には、コルーチンが非常に適しています。

まとめ

コルーチンは従来のスレッド処理における問題を効果的に解決した技術です。特にバックエンド開発においては並行処理を効率化し、スレッドリソースの有効活用によりパフォーマンス向上を実現できます。本内容がコルーチンの利便性を理解し、実務で積極的に活用するきっかけとなれば幸いです。もっとコルーチンに対して詳しく知りたい方は、こちらの公式ドキュメントを参照してください。 https://kotlinlang.org/docs/coroutines-guide.html