はじめに
Javaは進化を続けており、特にJava 21で導入された「仮想スレッド」と「パターンマッチング」は、開発体験を大きく向上させる機能です。
これらは、並行処理の設計やコードの記述方法に大きな変化をもたらし、より簡潔で安全な開発を可能にします。
しかし、これらの新機能について、「仮想スレッドとは何か？」「パターンマッチングをどう活用すればよいのか？」といった疑問を持つ方も少なくないでしょう。
この記事では、Java 21の重要な新機能である仮想スレッドとパターンマッチングについて、その基本から実践的な使い方まで分かりやすく解説します。
本記事を読み終えることで、Java 21の主要な新機能を理解し、ご自身のプロジェクトで活用するための第一歩を踏み出せることを目指します。
目次
- Java 21がもたらす開発体験の変革
- 仮想スレッド（Virtual Threads）：軽量スレッドによる並行処理の進化
- 仮想スレッドとは何か？：OSスレッドとの違い
- 仮想スレッドのメリットとユースケース
- 実践！仮想スレッドの導入とコード例
- 仮想スレッド利用時の注意点とベストプラクティス
- 構造化された並行処理（Structured Concurrency）
- パターンマッチングの進化：コードの簡潔性と安全性の向上
- レコードパターン（Record Patterns）の活用
- switchのパターンマッチング（Pattern Matching for switch）詳解
- Java 21以降の進化：未来への展望
- まとめ
対象読者
この記事は、以下のような方を対象としています。
- Javaの基本的な文法や開発経験をお持ちの方
- Java 21で導入された新機能、特に仮想スレッドやパターンマッチングに関心のある方
- アプリケーションのパフォーマンスやコードの可読性を向上させたいと考えている開発者
動作検証環境
この記事は、以下の環境で検証しています。
- OS : macOS Tahoe Version 26.1
- ハードウェア : MacBook Air 2024 M3 24GB
- VS Code: 最新版 (記事執筆時点)
- Java Extension Pack: 最新版 (記事執筆時点)
- Java: OpenJDK 21.0.9 LTS (Temurin)
本記事におけるプレビュー機能の取り扱い
本記事で紹介する機能の一部は、Javaの「プレビュー機能」として提供されています。これらは、開発者コミュニティからのフィードバックを目的とした試験的な機能です。
【プレビュー機能利用上の注意】
- APIの変更可能性: プレビュー機能は、将来のJavaバージョンでAPIが変更または削除される可能性があります。
- 本番環境での利用非推奨: 上記のリスクのため、現時点での本番環境での利用は推奨されません。
- 有効化フラグ: これらの機能を利用するには、コンパイルおよび実行時に
--enable-previewフラグを指定する必要があります。
コマンド例:
# ソースファイルをコンパイルする
javac --release 21 --enable-preview YourClass.java
# クラスファイルを実行する
java --enable-preview YourClass
# 単一ソースファイルプログラムとして直接実行する
java --source 21 --enable-preview YourFile.java1. Java 21がもたらす開発体験の変革
Java 21は、長期サポート（LTS）リリースとして、開発者に多くのメリットをもたらします。
その中でも特に注目すべきは、Project Loomによって実現された「仮想スレッド」と、Project Amberによって進化を遂げた「パターンマッチング」です。
これらは、Javaアプリケーションのパフォーマンス、可読性、保守性を大きく向上させるための鍵となります。
2. 仮想スレッド（Virtual Threads）：軽量スレッドによる並行処理の進化
2-1. 仮想スレッドとは何か？：OSスレッドとの違い
従来のJavaにおけるスレッドは、OSスレッドに1対1でマッピングされていました。
これは、スレッドの生成やコンテキストスイッチに高いコストがかかることを意味し、多数の並行処理を必要とするアプリケーションでは、スケーラビリティのボトルネックとなっていました。
図1: 従来のOSスレッドモデル。JavaスレッドがOSスレッドに1対1で対応します。
仮想スレッドは、この問題を解決するために導入されました。
仮想スレッドは、Java仮想マシン（JVM）によって管理される「軽量スレッド」であり、OSスレッドとは異なり、非常に少ないリソースで大量に生成することができます。
これにより、開発者はスレッドプールの管理や非同期プログラミングの複雑さから解放され、同期的なコードを書くかのように、効率的な並行処理を実現できます。
図2: 仮想スレッドモデル。多数の仮想スレッドが、少数のプラットフォームスレッド上で実行されます。
2-2. 仮想スレッドのメリットとユースケース
仮想スレッドの最大のメリットは、I/Oバウンドな処理（データベースアクセス、ネットワーク通信など）において、アプリケーションのスループットを大幅に向上させることができる点です。
従来のOSスレッドでは、I/O待ちの間もOSスレッドを占有していましたが、仮想スレッドはI/O待ちの間はプラットフォームスレッドを解放し、他の仮想スレッドが実行されることを可能にします。
ユースケース例:
- マイクロサービスアーキテクチャにおける多数のAPI呼び出し
- Webサーバーやアプリケーションサーバーでの多数のクライアント接続処理
- データ処理パイプラインにおけるI/O集中型タスク
2-3. 実践！仮想スレッドの導入とコード例
仮想スレッドの導入は非常に簡単です。Thread.ofVirtual().start(...) を使用するか、Executors.newVirtualThreadPerTaskExecutor() を利用することで、既存のコードをほとんど変更することなく仮想スレッドを活用できます。
コード例: 仮想スレッドの基本的な使用法
import java.util.concurrent.Executors;
import java.util.stream.IntStream;
public class VirtualThreadExample {
public static void main(String[] args) {
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
IntStream.range(0, 10_000).forEach(i -> {
executor.submit(() -> {
Thread.sleep(1000); // 模擬的なI/O処理
System.out.println("Task " + i + " running in virtual thread: " + Thread.currentThread());
return i;
});
});
} // executor.close() が呼ばれると、すべてのタスクが完了するまで待機する
System.out.println("All tasks submitted and completed.");
}
}このコードでは、1万個のタスクを仮想スレッドで実行しています。従来のExecutorServiceでは、これほどの数のスレッドを生成するとリソースを枯渇させてしまいますが、仮想スレッドなら問題なく処理できます。
実行結果例：
Task 6 running in virtual thread: VirtualThread[#27]/runnable@ForkJoinPool-1-worker-10
Task 2 running in virtual thread: VirtualThread[#23]/runnable@ForkJoinPool-1-worker-2
Task 5 running in virtual thread: VirtualThread[#26]/runnable@ForkJoinPool-1-worker-1
Task 1 running in virtual thread: VirtualThread[#22]/runnable@ForkJoinPool-1-worker-3
... 中略
Task 9979 running in virtual thread: VirtualThread[#10014]/runnable@ForkJoinPool-1-worker-5
Task 9984 running in virtual thread: VirtualThread[#10019]/runnable@ForkJoinPool-1-worker-2
Task 9999 running in virtual thread: VirtualThread[#10034]/runnable@ForkJoinPool-1-worker-14
Task 9993 running in virtual thread: VirtualThread[#10028]/runnable@ForkJoinPool-1-worker-10
Task 9997 running in virtual thread: VirtualThread[#10032]/runnable@ForkJoinPool-1-worker-9
All tasks submitted and completed.2-4. 仮想スレッド利用時の注意点とベストプラクティス
仮想スレッドは万能ではなく、利用する際にはいくつかの注意点があります。
- CPUバウンドな処理には不向き:
- CPUを集中して使用する計算処理には、依然としてプラットフォームスレッド（従来のOSスレッド）が適しています。
synchronizedの利用は慎重に:synchronizedブロック内でI/O処理などを行うと、仮想スレッドがマウントされているプラットフォームスレッドがブロック（ピン留め）され、仮想スレッドの利点が損なわれる可能性があります。java.util.concurrent.locks.ReentrantLockなどの利用を検討してください。
- スレッドローカルからの脱却:
- 従来の
ThreadLocalは、大量の仮想スレッドで利用するとメモリを圧迫する可能性があります。Java 21でプレビュー導入されたスコープ値（Scoped Values）への移行を検討しましょう。スコープ値は、スレッド間で不変のデータを効率的に共有するための仕組みです。
- 従来の
コード例: スコープ値（Java 21 プレビュー機能）
public class ScopedValueExample {
// USERという名前のスコープ値を定義
private static final ScopedValue<String> USER = ScopedValue.newInstance();
public static void main(String[] args) throws Exception {
// スコープ値に"user-A"を束縛して処理を実行
ScopedValue.where(USER, "user-A").run(() -> new Service().process());
}
static class Service {
void process() {
// スコープ値が束縛されていれば、その値を取得できる
System.out.println("Processing for: " + USER.orElse("guest"));
// ネストされたスコープでは、さらに値を上書きすることも可能
try {
ScopedValue.where(USER, "user-B").run(() -> new Controller().handle());
} catch (Exception e) {
e.printStackTrace();
}
}
}
static class Controller {
void handle() {
System.out.println("Handled by: " + USER.orElse("guest"));
}
}
}実行結果例：
Processing for: user-A
Handled by: user-B2-5. 構造化された並行処理（Structured Concurrency）
Java 21では、仮想スレッドをより安全に扱うための構造化された並行処理（プレビュー機能）も導入されました。これは、複数の並行タスクを単一の作業単位としてグループ化するAPIです。これにより、タスクのフォークとジョイン、エラーハンドリング、キャンセル処理が大幅に簡素化されます。
コード例: StructuredTaskScope（Java 21 プレビュー機能）
// --enable-preview フラグを付けて実行する必要があります
import java.util.concurrent.StructuredTaskScope;
import java.util.function.Supplier;
public class StructuredConcurrencyExample {
public static void main(String[] args) throws Exception {
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
// 2つのタスクをフォーク（並行実行）
Supplier<String> user = scope.fork(() -> findUser());
Supplier<Integer> order = scope.fork(() -> fetchOrder());
// すべてのタスクが完了するまで待機し、失敗があれば例外をスロー
scope.join().throwIfFailed();
// 結果を結合
System.out.println("User: " + user.get() + ", Order: " + order.get());
}
}
static String findUser() throws InterruptedException {
Thread.sleep(100);
return "user-123";
}
static Integer fetchOrder() throws InterruptedException {
Thread.sleep(200);
return 456;
}
}実行結果例：
User: user-123, Order: 4563. パターンマッチングの進化：コードの簡潔性と安全性の向上
Java 21では、パターンマッチングがさらに進化し、コードの可読性と安全性が向上しました。
特に「レコードパターン」と「switchのパターンマッチング」は、データ処理の記述を大幅に簡潔にします。
3-1. レコードパターン（Record Patterns）の活用
レコードはJava 16で導入された不変なデータクラスですが、Java 21のレコードパターンと組み合わせることで、レコードのコンポーネントを直接パターンマッチングで分解・抽出できるようになりました。
コード例: レコードパターン
record Point(int x, int y) {}
record ColoredPoint(Point p, String color) {}
public class RecordPatternExample {
// ネストしたレコードパターンで、深い階層のデータも一度に抽出
public static void printColorAndCoordinates(Object obj) {
if (obj instanceof ColoredPoint(Point(int x, int y), String color)) {
System.out.println("Color: " + color + ", Coordinates: x=" + x + ", y=" + y);
} else {
System.out.println("Not a colored point.");
}
}
public static void main(String[] args) {
printColorAndCoordinates(new ColoredPoint(new Point(1, 2), "Red"));
printColorAndCoordinates(new Point(3, 4));
}
}この例では、instanceof演算子とネストしたレコードパターンを組み合わせることで、ColoredPointオブジェクトからPointのx, y座標とcolorを一度に抽出しています。これにより、冗長なキャストやゲッター呼び出しが不要になり、コードが簡潔になります。
実行結果例：
Color: Red, Coordinates: x=1, y=2
Not a colored point.3-2. switchのパターンマッチング（Pattern Matching for switch）詳解
switch式（Java 14で標準化）は、Java 21でパターンマッチングを完全にサポートするようになり、より強力なデータ処理ツールへと進化しています。
これにより、複数の型や条件に基づいた分岐処理を、より安全かつ簡潔に記述できます。
コード例: ガード付きパターンを含むswitchのパターンマッチング
public class SwitchPatternMatchingExample {
// PointとColoredPointは上記で定義済みとする
public static String describeObject(Object obj) {
return switch (obj) {
case Integer i -> "Integer: " + i;
case String s -> "String: " + s;
// レコードパターン
case Point(int x, int y) -> "Point: x=" + x + ", y=" + y;
// ガード付きパターン: colorが"Red"の場合のみマッチ
case ColoredPoint(Point p, String color) when color.equals("Red") -> "A red colored point at " + p;
case ColoredPoint(Point p, String color) -> "A colored point of color " + color + " at " + p;
// nullパターン
case null -> "Null object";
default -> "Unknown object";
};
}
public static void main(String[] args) {
System.out.println(describeObject(100));
System.out.println(describeObject("Hello Java 21"));
System.out.println(describeObject(new Point(5, 6)));
System.out.println(describeObject(new ColoredPoint(new Point(7, 8), "Blue")));
System.out.println(describeObject(new ColoredPoint(new Point(1, 1), "Red"))); // ガード付きパターンにマッチ
System.out.println(describeObject(null));
}
}switch式のcaseラベルで型パターンやレコードパターンを使用できます。さらにwhen句（ガード付きパターン）を使うことで、型が一致しかつ特定の条件を満たす場合にのみマッチさせることが可能です。また、nullパターンもサポートされており、NullPointerExceptionを恐れることなく安全にswitchを使えるようになりました。
実行結果例：
Integer: 100
String: Hello Java 21
Point: x=5, y=6
A colored point of color Blue at Point[x=7, y=8]
A red colored point at Point[x=1, y=1]
Null object4. Java 21以降の進化：未来への展望
Javaの進化は続いています。Java 21の次のLTSであるJava 25に向けて、多くの新機能がプレビューとして導入され、磨きがかけられています。
- Stream Gatherers (JEP 461, Java 22 プレビュー): Stream APIに、より柔軟でカスタム可能な中間操作を追加する機能。
- String Templates (JEP 459, Java 22 セカンドプレビュー): 文字列補間をより安全かつ表現力豊かに行うための機能。
- Implicitly Declared Classes and Instance Main Methods (JEP 463, Java 22 セカンドプレビュー): Javaを学び始める際の記述を簡素化し、よりスムーズな学習体験を提供する機能。
これらの機能は、Javaをよりモダンで、開発者にとって使いやすい言語へと進化させていくでしょう。
まとめ：Java 21でより効率的で安全なコードを書く
Java 21は、仮想スレッドとパターンマッチングという強力な新機能によって、Java開発に大きな変化をもたらしました。
仮想スレッドと構造化された並行処理は、並行処理の記述をシンプルにし、アプリケーションのスケーラビリティを向上させます。
一方、パターンマッチングは、データ処理のコードをより簡潔で安全なものにします。
これらの機能を深く理解し、スコープ値のような関連するプレビュー機能も視野に入れながら適切に活用することで、より効率的で、堅牢で、保守性の高いJavaアプリケーションを開発する一助となるはずです。
Javaは活発な進化を続けています。ぜひ、あなたのプロジェクトにJava 21の新機能を取り入れ、その効果を実感してみてください。
免責事項
本記事で提供する情報およびコード例については、正確性を期しておりますが、その内容を保証するものではありません。本記事の情報を利用したことによって生じたいかなる損害についても、筆者および所属組織は一切の責任を負いかねます。
特に、記事中で紹介しているプレビュー機能は、将来のJavaバージョンで仕様が変更または削除される可能性があります。これらの機能の利用に際しては、公式ドキュメントを必ず参照し、ご自身の判断と責任において行ってください。
