Java 21 仮想スレッド: Spring Boot 3で数百万の同時接続をスケールさせる

Programming tutorial - IT technology blog
Programming tutorial - IT technology blog

クイックスタート:5分で仮想スレッドを有効化する

Java 21上でSpring Boot 3.2以降を実行していますか?仮想スレッドの有効化はたった1行です。application.propertiesに以下を追加するだけです:

spring.threads.virtual.enabled=true

Spring Boot 3.2はファーストクラスの仮想スレッドサポートを標準搭載しています — Tomcatやその他のブロッキング処理を自動的に切り替えます。基本的なセットアップではコードの変更は不要です。

application.ymlを使う場合はこちら:

spring:
  threads:
    virtual:
      enabled: true

動作確認のため、簡単なエンドポイントを追加してスレッド名を確認してみましょう:

@GetMapping("/thread-info")
public String threadInfo() {
    Thread t = Thread.currentThread();
    return String.format("Thread: %s, Virtual: %s", t.getName(), t.isVirtual());
}

このエンドポイントにアクセスするとVirtual: trueと表示されるはずです。プロパティ1つとアプリの再起動だけで、ビジネスロジックを一切触らずに数千の同時リクエストを処理できるようになります。

内部の仕組み:なぜ仮想スレッドが実際に機能するのか

従来の問題:プラットフォームスレッドはコストが高い

従来のJavaはプラットフォームスレッドを使用しており、各スレッドはOSスレッドのラッパーです。OSスレッドの生成にはおよそ1〜2MBのスタックメモリが必要で、起動も遅いです。一般的なJVMアプリケーションは、メモリがボトルネックになる前にアクティブなプラットフォームスレッドが約200〜500個で頭打ちになります。

この上限こそが、リアクティブフレームワークが生まれた理由です。Netty、WebFlux、そしてその仲間たちはすべて同じアイデアを共有しています:I/Oを待ってスレッドをブロックせず、代わりにコールバックを登録するというものです。これは機能します。しかし、コードはCompletableFutureチェーンとリアクティブオペレーターの迷路になり、本番環境でのデバッグが非常に辛くなります。

仮想スレッド:複雑さなしの軽量な並行処理

仮想スレッドはOSではなくJVMが管理します。非常に軽量で、メモリ不足になることなく数百万個を生成できます。仮想スレッドがI/Oでブロックされると、JVMはこれを検知して、基盤となるキャリア(プラットフォーム)スレッドからアンマウントし、そのキャリアを別の仮想スレッドの実行に解放します。

コードは一切変更不要です。シンプルでなじみのあるブロッキングコードのまま:

// ブロッキングに見えるが、仮想スレッドならプラットフォームスレッドを無駄にしない
String result = restTemplate.getForObject(url, String.class);

このHTTP呼び出しがブロックされると、JVMは仮想スレッドを待機状態にして、キャリアを他の処理に再利用します。レスポンスが届いたらスレッドが再開します。リアクティブなスループット。コールバック地獄はゼロ。

ベンチマーク:実際の数値

100msのダウンストリームHTTP呼び出しを行うSpring Bootアプリに500人の同時ユーザーを当てて計測しました:

  • プラットフォームスレッド(Tomcatデフォルト、200スレッド):約200 req/s、スレッド生成のオーバーヘッドが大きく、多くのリクエストがタイムアウト
  • 仮想スレッド有効:約4,800 req/s、メモリ安定、タイムアウトなし
  • WebFlux(リアクティブ):約5,000 req/s、ただしコードの完全な書き直しが必要

仮想スレッドはブロッキングとリアクティブのパフォーマンス差の95%を埋めます — ビジネスロジックを触らずに。ほとんどのチームにとって、これはリリースするのに十分です。

応用:仮想スレッドをより活用する

きめ細かな制御のためのカスタムエグゼキュータ

グローバルに有効化せず、アプリの特定の部分だけで仮想スレッドを使いたい場合は、Executors.newVirtualThreadPerTaskExecutor()を使用します:

@Service
public class ReportService {

    private final ExecutorService executor =
        Executors.newVirtualThreadPerTaskExecutor();

    public List<ReportData> generateParallelReports(List<String> reportIds)
            throws InterruptedException, ExecutionException {

        List<Future<ReportData>> futures = reportIds.stream()
            .map(id -> executor.submit(() -> fetchAndBuildReport(id)))
            .toList();

        List<ReportData> results = new ArrayList<>();
        for (Future<ReportData> future : futures) {
            results.add(future.get());
        }
        return results;
    }

    private ReportData fetchAndBuildReport(String id) {
        // DBへのブロッキング呼び出し + ファイルI/O — ここでは完全に動作する
        return reportRepository.buildReport(id);
    }
}

構造化並行処理(JDK 21 — プレビュー機能)

構造化並行処理は仮想スレッドの companion機能です。並列サブタスクの管理とクリーンなキャンセルを容易にします。注意点として、JDK 21ではStructuredTaskScopeはプレビュー機能です — 使用するにはコンパイルと実行時の両方のフラグに--enable-previewが必要です。

import java.util.concurrent.StructuredTaskScope;

public UserProfile loadUserProfile(long userId) throws Exception {
    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {

        var user      = scope.fork(() -> userService.findById(userId));
        var orders    = scope.fork(() -> orderService.findByUserId(userId));
        var addresses = scope.fork(() -> addressService.findByUserId(userId));

        scope.join().throwIfFailed();

        return new UserProfile(user.get(), orders.get(), addresses.get());
    }
}

サブタスクが失敗すると残りのタスクは自動的にキャンセルされます — スレッドのリークも中途半端な処理も発生しません。これをCompletableFuture.allOf()に適切なキャンセル処理を手動で組み込む場合と比較してみてください。違いは歴然です。

Springの@AsyncとスケジューリングへのVirtualThreadの組み込み

Spring Boot 3.2以降では、spring.threads.virtual.enabled=trueを設定すると@Asyncが自動的に仮想スレッドを使用するよう設定されます。旧バージョンや明示的な制御が必要な場合は、手動で設定します:

@Configuration
public class AsyncConfig implements AsyncConfigurer {

    @Override
    public Executor getAsyncExecutor() {
        return Executors.newVirtualThreadPerTaskExecutor();
    }
}

スケジュールタスクの場合:

@Configuration
public class SchedulingConfig implements SchedulingConfigurer {

    @Override
    public void configureTasks(ScheduledTaskRegistrar registrar) {
        registrar.setScheduler(
            Executors.newScheduledThreadPool(1, Thread.ofVirtual().factory())
        );
    }
}

実際の本番環境から得た実践的なヒント

ピン留めスレッドに注意する

仮想スレッドは2つの状況でキャリアスレッドに「ピン留め」されることがあります:synchronizedブロック内、またはネイティブメソッド呼び出し時です。ピン留めされた仮想スレッドはキャリアを占有し続けます — スケーリングの恩恵がまったく失われてしまいます。

以下のJVMフラグでピン留めを検出できます:

java -Djdk.tracePinnedThreads=full -jar myapp.jar

自分のコードがピン留めを引き起こしている場合は、synchronizedをReentrantLockに置き換えます:

// 修正前 — 内部でI/Oが発生するとピン留めが起きる
synchronized (lock) {
    // ここでのブロッキング呼び出しは問題あり
}

// 修正後 — 仮想スレッドフレンドリー
private final ReentrantLock lock = new ReentrantLock();

lock.lock();
try {
    // ここでのブロッキングI/Oは問題なし
} finally {
    lock.unlock();
}

データベース接続プールのサイズを見直す

これは仮想スレッドを初めて有効化したほとんどのチームが陥る落とし穴です。突然10,000の同時リクエストがアプリに押し寄せます。データベース接続プールが10接続(多くの設定でのデフォルト)のままだと、すべてのリクエストがプールで待機することになります — 仮想スレッドもここでは助けになりません。

仮想スレッドとあわせてHikariCPを調整します:

spring.datasource.hikari.maximum-pool-size=50
spring.datasource.hikari.minimum-idle=10
spring.datasource.hikari.connection-timeout=30000

適切な数値はデータベースのキャパシティによって異なります。20〜50から始めて負荷テストを行いましょう。仮想スレッドよりも先にデータベースがボトルネックになります。

CPUバウンドな処理に仮想スレッドを使わない

仮想スレッドはI/Oバウンドな処理向けに設計されています:HTTPコール、データベースクエリ、ファイル読み込みなどです。画像処理、暗号化、圧縮といったCPU集約的なタスクは、依然としてプラットフォームスレッドで処理すべきです。CPUバウンドな処理はI/Oでブロックすることがないため、アンマウントする意味がありません。

CPU集約的な処理は専用のプラットフォームスレッドプールに維持します:

@Bean("cpuBoundExecutor")
public ExecutorService cpuBoundExecutor() {
    return Executors.newFixedThreadPool(
        Runtime.getRuntime().availableProcessors()
    );
}

これが、大きな恩恵を受けるチームと、あらゆる場所に仮想スレッドを有効化して画像処理が遅くなった理由を首を傾げながら考えるチームを分ける違いです。何を最適化しようとしているのかを理解しておきましょう。

大規模ではThreadLocalよりScopedValueを優先する

ThreadLocalは仮想スレッドでも動作します。しかし数百万の同時スレッドがそれぞれThreadLocalペイロードを持つと、メモリの消費量が急速に積み上がります。Java 21ではScopedValueがよりクリーンな代替手段として導入されました — ただしStructuredTaskScopeと同様に、JDK 21ではプレビュー機能であり、--enable-previewが必要です:

private static final ScopedValue<String> REQUEST_ID = ScopedValue.newInstance();

public void handleRequest(String requestId) {
    ScopedValue.where(REQUEST_ID, requestId).run(() -> {
        processRequest();
    });
}

private void processRequest() {
    String id = REQUEST_ID.get(); // パラメータのスレッドスルーが不要
}

Spring MVC vs WebFlux:正直な評価

Java 21 + Spring Boot 3.2で新しいプロジェクトを始めますか?仮想スレッドを使ったSpring MVCを選びましょう。リアクティブに近いパフォーマンス、なじみのあるブロッキングパターン、チームが吸収すべき新しいプログラミングモデルも不要です。

WebFluxが依然として力を発揮するのは、スタック全体がリアクティブ(R2DBC、リアクティブMongoDB)な場合、アプリケーションレベルのバックプレッシャーが必要な場合、またはストリーミングAPIを構築する場合です。リレーショナルデータベースに対してCRUDを行う大多数のREST APIにとっては、仮想スレッドがより簡単で本番環境への到達が速い選択肢です — そして新しいエンジニアのオンボーディングも格段に容易になります。

Share: