【Javaの基礎知識】スレッドと並行処理の基本を徹底解説！

Javaのスレッドと並行処理は、効率的なプログラム開発に欠かせません。これまでは初心者向けの話でしたが、スレッドを深く理解するには、もう一歩踏み込む必要があります。

この記事ではスレッドの本質と「並行処理」の実態を学び、本当に効率的なスレッド設計 について解説します。

スレッドと並行処理の基礎知識

マルチスレッドを活用することで、アプリケーションのパフォーマンスを向上させることができます。本セクションでは、スレッドの基本概念と並行処理の必要性について解説します。

スレッドとは？

スレッドとは、プログラム内で並行して実行できる最小単位の処理です。一般的なプログラムは1つのスレッド（シングルスレッド）で動作しますが、複数のスレッド（マルチスレッド）を利用することで並行処理が可能になります。

プロセスとスレッドの違い

プロセスとスレッドは似ていますが、明確な違いがあります。

例えば、Webブラウザはタブごとにプロセスを分けることで、1つのタブがクラッシュしても他のタブに影響を与えないように設計されています。一方、動画再生ソフトは、動画のデコードとオーディオの処理を別々のスレッドで並行処理することでスムーズな再生を実現します。

シングルスレッドとマルチスレッドの比較

スレッドの使用方法には、シングルスレッドとマルチスレッドの2種類があります。

例えば、画像のダウンロードと表示を同時に行う場合、シングルスレッドだと「ダウンロードが終わるまで画面が固まる」現象が発生しますが、マルチスレッドを利用するとダウンロード中でも画面の操作が可能になります。

並行処理とは？

並行処理（Concurreny）は、プログラム内で複数の処理を同時に実行することを指します。例えば、Webサーバーが複数のユーザーからのリクエストを処理する際、それぞれのリクエストを独立したスレッドで処理することで、スムーズな応答が可能になります。

並行処理と並列処理の違い

並行処理と並列処理は混同されがちですが、異なる概念です。

例えば、スマホで音楽を聴きながらWebページを閲覧するのは並行処理、画像を高速に処理するために複数のコアを活用するのは並列処理の例です。

並行処理が必要とされるシナリオ

並行処理は以下のような場面で特に有効です。

• Webサーバー: 複数のクライアントからのリクエストを同時に処理
• ゲーム開発: ゲームの描画とユーザー入力を並行して処理
• データ処理: ビッグデータの分析やAI処理の高速化
• 動画再生: 映像と音声の同期処理

例えば、オンラインショッピングサイトでは、ユーザーが商品を検索している間に、裏側で在庫情報を取得するなどの並行処理が行われています。

シングルスレッドの例

シングルスレッドでは、1つの処理が終わるまで次の処理が実行されません。

public class SingleThreadExample {
    public static void main(String[] args) {
        System.out.println("画像を読み込みます...");
        loadImage(); // 画像を読み込む（ここで処理が止まる）
        System.out.println("他の処理をしたいけど、止まってしまう...");
    }
    static void loadImage() {
        try { Thread.sleep(3000); } catch (InterruptedException e) {}
        System.out.println("画像の読み込み完了！");
    }
}

この場合、画像の読み込みが終わるまでプログラム全体が止まってしまい、他の処理ができません。

マルチスレッドの例

マルチスレッドを使うと、画像の読み込み中でも他の処理を並行して実行できます。

public class MultiThreadExample {
    public static void main(String[] args) {
        System.out.println("画像を読み込みます...");
        new Thread(() -> loadImage()).start(); // 画像読み込みを別のスレッドで実行
        System.out.println("画像を読み込みながら他の処理もできる！");
    }
    static void loadImage() {
        try { Thread.sleep(3000); } catch (InterruptedException e) {}
        System.out.println("画像の読み込み完了！");
    }
}

この場合、画像の読み込みと他の処理を同時に進めることができるため、スムーズな動作を実現できます。

スレッドが必要な場面（スレッドを使うメリット）

スレッドを活用することで、アプリケーションの動作をスムーズにし、処理の高速化や同時リクエスト対応が可能になります。ここでは、スレッドを使うことで得られる主なメリットを紹介します。

アプリの動作をスムーズにする（UIフリーズを防ぐ）

シングルスレッドのプログラムでは、1つの処理が終わるまで他の処理が止まるため、アプリの動作が固まることがあります。スレッドを使うことで、時間のかかる処理をバックグラウンドで実行し、UIの応答性を向上させることができます。

import javax.swing.*;

class UIExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("スレッド例");
        JButton button = new JButton("処理開始");
        button.addActionListener(e -> new Thread(() -> {
            try { Thread.sleep(5000); } catch (InterruptedException ex) {}
            System.out.println("処理完了！");
        }).start());
        frame.add(button);
        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
   }
}

このように、ボタンを押した後もUIがフリーズせず、スムーズな動作が可能になります。

Webサーバーの同時リクエスト処理

Webサーバーは複数のクライアントからのリクエストを同時に処理する必要があります。シングルスレッドだと、1つのリクエストを処理し終わるまで次のリクエストを待たなければならず、応答速度が低下します。マルチスレッドを活用することで、複数のリクエストを同時に処理でき、スムーズな通信が可能になります。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class WebServerExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);
        for (int i = 1; i <= 10; i++) {
            final int requestId = i;
            executor.submit(() -> {
                System.out.println("リクエスト " + requestId + " を処理中...");
            });
        }
        executor.shutdown();
    }
}

スレッドプールを活用することで、同時に複数のリクエストを処理し、サーバーの応答速度を向上させることができます。

データ処理の高速化

大規模なデータ処理を行う場合、1つのスレッドで処理すると時間がかかります。スレッドを分割して処理することで、計算時間を大幅に短縮できます。

import java.util.concurrent.*;

class DataProcessingExample {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executor = Executors.newFixedThreadPool(4);
        Callable task = () -> {
            return 100 * 2;
        };

        Future result = executor.submit(task);
        System.out.println("計算結果: " + result.get());
        executor.shutdown();
    }
}

このように、複数のスレッドでデータを並列処理することで、処理時間を短縮できます。

Javaにおけるスレッドの実装

Javaでは、スレッドを作成する方法が複数存在します。ここでは、基本的なスレッドの実装方法について詳しく解説します。

Thread クラスの利用

Thread クラスを使ったスレッドの作成方法を紹介します。

Thread クラスを継承する方法

Javaでは、 Thread クラスを継承することでスレッドを作成できます。以下のように、 run() メソッドをオーバーライドすることで、スレッドに実行したい処理を記述できます。

class MyThread extends Thread {
    public void run() {
        System.out.println("スレッドが実行されています");
    }
}
MyThread thread = new MyThread();
thread.start();

Thread クラスを利用した基本的なサンプルコード

以下のコードでは、複数のスレッドを作成し、それぞれ独立した処理を実行させる例を示します。

class MyThread extends Thread {
    private String name;
    public MyThread(String name) {
        this.name = name;
    }
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(name + " の実行: " + i);
        }
    }
}
MyThread t1 = new MyThread("スレッド1");
MyThread t2 = new MyThread("スレッド2");
t1.start();
t2.start();

Runnable インターフェースの利用

Runnable インターフェースを使ってスレッドを作成する方法を紹介します。

Runnable 実装のメリット

Javaでは、 Thread クラスを継承する代わりに Runnable インターフェースを実装することで、スレッドを作成できます。この方法のメリットは、Javaの「単一継承の制限」に引っかからないことです。

Runnable を活用した実装例

以下のコードでは、 Runnable を実装したクラスを使い、スレッドを作成する例を示します。

class MyRunnable implements Runnable {
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("スレッドの実行: " + i);
        }
    }
}
Thread thread = new Thread(new MyRunnable());
thread.start();

Callable と Future の活用

Callable インターフェースと Future を使った非同期処理の実装方法を解説します。

Callable と Runnable の違い

Runnable は戻り値を返せませんが、 Callable は戻り値を返すことができます。この違いを活かし、結果を取得できるスレッドを作成できます。

Future を用いた並行処理の実装例

以下のコードでは、 Callable を使って計算結果を取得するスレッドを作成する例を示します。

import java.util.concurrent.*;
class MyCallable implements Callable<Integer> {
    public Integer call() throws Exception {
        return 42;
    }
}
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<Integer> future = executor.submit(new MyCallable());
System.out.println("結果: " + future.get());
executor.shutdown();

Javaの実装はデフォルトでマルチスレッド

Javaのプログラムは、JVMが裏でスレッドを管理しているため、明示的に Thread を作成しなくてもマルチスレッドで動作します。

Javaが自動でマルチスレッド処理を行うケース

• Servlet / Springアプリ：クライアントのリクエストごとに自動でスレッドが作成される
• JDBC（データベースアクセス）：複数クエリの並列処理をDBドライバがスレッドで管理
• 非同期処理（Future, CompletableFuture）：バックグラウンドスレッドで非同期処理を実行
• ExecutorService（スレッドプール）：複数タスクを効率的に並行処理

Singletonはスレッドセーフに注意

Singletonパターンでは、インスタンスが1つしか作られないため、複数スレッドが同時にアクセスすると競合が発生する可能性があります。

スレッドセーフでない Singleton の例

public class UnsafeSingleton {
    private static UnsafeSingleton instance;
    private UnsafeSingleton() {}
    public static UnsafeSingleton getInstance() {
        if (instance == null) {
            instance = new UnsafeSingleton(); // スレッド競合の可能性あり
        }
        return instance;
    }
}

スレッドセーフな Singleton（synchronized を使用）

public class SafeSingleton {
    private static SafeSingleton instance;
    private SafeSingleton() {}
    public static synchronized SafeSingleton getInstance() {
        if (instance == null) {
            instance = new SafeSingleton();
        }
        return instance;
    }
}

ダブルチェックロッキング（推奨）

public class DoubleCheckedLockingSingleton {
    private static volatile DoubleCheckedLockingSingleton instance;
    private DoubleCheckedLockingSingleton() {}
    public static DoubleCheckedLockingSingleton getInstance() {
        if (instance == null) {
            synchronized (DoubleCheckedLockingSingleton.class) {
                if (instance == null) {
                    instance = new DoubleCheckedLockingSingleton();
                }
            }
        }
        return instance;
    }
}

Singletonとは？

Singleton（シングルトン） とは、「アプリ内で1つのインスタンスだけを作る」 デザインパターンです。

DB接続や設定情報など、複数作ると無駄になるものを1つに制限 し、メモリ消費を抑え、データの整合性を保ちます。

🔹 Singletonのメリット

• メモリの節約：何度もインスタンスを作らず、リソースを効率的に利用します。
• データの一貫性：全スレッドが同じインスタンスを共有できます
• 管理が簡単：グローバルにアクセスできるため、統一した管理が可能です。

マルチスレッド環境では複数のインスタンスが生成される可能性があるため、スレッドセーフな実装（synchronizedやダブルチェックロッキング）を行う必要があります。

慣れてきたら、他のデザインパターンも学ぶとより効率的な設計ができ流ようになります！

「マルチスレッド」の誤解を防ぐために

「マルチスレッド」という言葉から、「スレッドが同時に動いている」と誤解されがちですが、実際には **シングルコア環境では順番に切り替えながら処理しているだけ** です。

マルチスレッド＝本当に同時に動いているわけではない

「マルチスレッド」は「並列処理（Parallel）」ではなく、実際には「並行処理（Concurrent）」を行っているだけです。

シングルコア環境では「並行処理」

シングルコアのCPUでは、スレッドは順番に処理されますが、高速に切り替えることで「同時に動いているように見せている」だけです。

つまり、実際にはスレッドが交代しながら動作しているだけで、ユーザーには「同時に動いている」ように見えるのです。

マルチコア環境では「並列処理」

マルチコアCPUでは、物理的に「スレッドを並列実行」できます。

• 🟢 シングルコア：スレッドは順番に実行（並行処理）
• 🟢 デュアルコア：2つのスレッドを物理的に同時実行
• 🟢 クアッドコア以上：複数のスレッドを並列処理可能

📌 つまり、マルチスレッドのメリットを最大限活かすには「マルチコア環境」が前提となる！

「マルチスレッド」より「並行処理」と言うべき

「マルチスレッド」という表現は、誤解を生みやすいため、実際の動作を考えると「並行処理（Concurrent Processing）」という表現の方が適切です。

スレッドの活用シーン

スレッドを利用することで、プログラムの処理を並行して実行でき、パフォーマンスの向上やスムーズなユーザー体験を実現できます。ここでは、スレッドが特に有効な場面を紹介します。

① マルチタスク処理

複数の作業を同時に実行する場合、スレッドを使うことで処理の効率が向上します。

• 例: Webサーバーが複数のクライアントのリクエストを同時に処理する
• 例: 動画再生アプリで映像のデコードと音声の再生を並行処理

② UIの応答性向上

GUIアプリでは、時間のかかる処理をメインスレッドで実行すると画面がフリーズするため、別スレッドで処理を実行することでスムーズな操作が可能になります。

• 例: ボタンをクリックした際にデータを非同期で取得し、UIの更新をブロックしない
• 例: 画像処理アプリで大きな画像を読み込みながらUIを操作可能にする

③ 大量のデータ処理

ビッグデータ処理や機械学習では、複数のスレッドを利用して計算を並列化することで処理時間を短縮できます。

• 例: AIのニューラルネットワーク学習時に複数スレッドで並列計算
• 例: データベース検索のクエリを複数スレッドで同時実行

④ ネットワーク通信の最適化

ネットワークを利用する処理では、データの送受信をスレッド化することで効率的に処理できます。

• 例: メールクライアントがバックグラウンドでメールの送受信を行う
• 例: ダウンロードマネージャーが複数のファイルを同時にダウンロード

⑤ ゲーム開発

ゲームでは、描画処理・物理演算・サウンド処理などをスレッド化することで、リアルタイムな動作を実現します。

• 例: 3Dゲームでプレイヤーの入力処理と敵AIの計算を別々のスレッドで処理
• 例: ネットワーク対戦ゲームで通信と描画処理を並列実行

スレッド管理と同期処理

スレッドを安全に管理し、データの整合性を確保するための手法を学びます。

スレッドの状態管理

スレッドのライフサイクルと、各状態の役割について解説します。

NEW, RUNNABLE, BLOCKED などの状態の解説

Javaのスレッドは、以下の6つの状態を持ちます。

Thread.sleep() や join() の使用例

スレッドの制御には、 Thread.sleep() や join() を使用できます。

class MyThread extends Thread {
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("スレッド実行中: " + i);
            try {
                Thread.sleep(1000); // 1秒待機
            } catch (InterruptedException e) { e.printStackTrace(); }
        }
    }
}
MyThread t = new MyThread();
t.start();
t.join(); // メインスレッドは t が終了するまで待機

同期処理と排他制御

共有リソースを安全に利用するための同期処理を解説します。

synchronized キーワードの使い方

synchronized を使うことで、同時に1つのスレッドのみがメソッドやブロックを実行できるように制御できます。

class SharedResource {
    public synchronized void print(String msg) {
        System.out.println(msg);
    }
}
SharedResource res = new SharedResource();
Thread t1 = new Thread(() -> res.print("スレッド1実行"));
Thread t2 = new Thread(() -> res.print("スレッド2実行"));
t1.start(); t2.start();

ReentrantLock を用いた排他制御

ReentrantLock を使うことで、より柔軟なロック管理が可能です。

import java.util.concurrent.locks.ReentrantLock;
class SharedResource {
    private final ReentrantLock lock = new ReentrantLock();
    public void print(String msg) {
        lock.lock();
        try {
            System.out.println(msg);
        } finally {
            lock.unlock();
        }
    }
}

volatile 修飾子の役割と注意点

volatile を使うことで、変数の値がキャッシュされずに即時反映されるため、スレッド間で一貫した値を共有できます。

class SharedData {
    private volatile boolean running = true;
    public void stop() { running = false; }
}

スレッドプールの活用

ExecutorService を使ってスレッドプールを管理する方法を紹介します。

スレッドプールを使用するメリット

• スレッドの作成と破棄のオーバーヘッドを削減
• 複数のタスクを効率的に管理
• スレッド数を制御し、システムの負荷を抑える

Executors クラスを使ったスレッド管理

スレッドプールを利用することで、複数のタスクを効率よく処理できます。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
ExecutorService executor = Executors.newFixedThreadPool(2);
executor.submit(() -> System.out.println("タスク1 実行中"));
executor.submit(() -> System.out.println("タスク2 実行中"));
executor.shutdown();

よくあるトラブルとデバッグ方法

スレッドプログラミングで発生しやすい問題と、それをデバッグするためのアプローチを紹介します。

デッドロックとは？

デッドロックとは、複数のスレッドがお互いのリソースをロックし合い、永久に待機状態になる問題です。適切な設計をしないと、アプリケーションが応答しなくなる可能性があります。

デッドロックの発生パターン

デッドロックは、主に以下の条件が揃うと発生します。

• ① 相互排他: 資源が1つのスレッドだけにロックされる
• ② 保持と待機: スレッドがすでにロックを持ちながら、別のロックを待機する
• ③ 循環待機: 複数のスレッドが循環的にリソースを要求する

以下のコードは、デッドロックが発生する例です。

class Resource {
    void methodA(Resource other) {
        synchronized (this) {
            System.out.println("MethodA locked this");
            synchronized (other) {
                System.out.println("MethodA locked other");
            }
        }
    }
}

デッドロックを回避する設計方法

デッドロックを防ぐには、以下の対策が有効です。

• リソースのロック順序を統一し、循環待機を防ぐ
• タイムアウト付きのロックを使用し、長時間のブロックを回避する
• 可能な限り、同期を減らし、共有リソースを最小限にする

以下のコードでは、ロックの順序を統一し、デッドロックを回避しています。

class SafeResource {
    void safeMethod(SafeResource other) {
        SafeResource first = this;
        SafeResource second = other;
        if (System.identityHashCode(this) > System.identityHashCode(other)) {
            first = other;
            second = this;
        }
        synchronized (first) {
            synchronized (second) {
                System.out.println("Safe execution");
            }
        }
    }
}

スレッドの競合条件

競合状態（レースコンディション）とは、複数のスレッドが同じリソースにアクセスし、データが破損したり、予期しない動作を引き起こす問題です。

競合状態の発生要因

以下のようなケースで競合状態が発生します。

• 同じ変数に複数のスレッドが同時に書き込む
• スレッドが順序を考慮せずにリソースへアクセスする

例えば、以下のコードでは、カウンターを増やす処理が競合して正しく動作しません。

class Counter {
    private int count = 0;
    void increment() { count++; }
}
Counter counter = new Counter();
Thread t1 = new Thread(() -> { for (int i = 0; i < 1000; i++) counter.increment(); });
Thread t2 = new Thread(() -> { for (int i = 0; i < 1000; i++) counter.increment(); });
t1.start();
t2.start();

synchronized での競合回避

synchronized を使うことで、1つのスレッドのみがリソースを変更できるようにし、競合を防ぐことができます。

class SafeCounter {
    private int count = 0;
    public synchronized void increment() { count++; }
}
SafeCounter counter = new SafeCounter();
Thread t1 = new Thread(() -> { for (int i = 0; i < 1000; i++) counter.increment(); });
Thread t2 = new Thread(() -> { for (int i = 0; i < 1000; i++) counter.increment(); });
t1.start();
t2.start();

Atomic クラスを用いた解決策

AtomicInteger を使うことで、スレッドセーフな処理を実現できます。

import java.util.concurrent.atomic.AtomicInteger;

class AtomicCounter {
    private AtomicInteger count = new AtomicInteger(0);
    void increment() { count.incrementAndGet(); }
}
AtomicCounter counter = new AtomicCounter();

Thread t1 = new Thread(() -> { for (int i = 0; i < 1000; i++) counter.increment(); });
Thread t2 = new Thread(() -> { for (int i = 0; i < 1000; i++) counter.increment(); });

t1.start();
t2.start();

まとめ

Javaのプログラムは、意識しなくてもマルチスレッドで動いています。しかし、大量のデータ処理やWebサーバーなどでは、スレッドを理解して適切に管理することで、より効率的なプログラムを作ることができます。

💡 そもそもスレッドって必要？

プログラムが1つの処理しかできなかったら、こんな問題が起こります。

• 🔹 ボタンを押すと画面がフリーズする（画像を読み込み中に操作できない）
• 🔹 Webサイトの読み込みが遅くなる（1人ずつしかアクセスできない）
• 🔹 ゲームのBGMが途切れる（キャラクターの動きとBGMが同時に再生されない）

こうした問題を解決するのが「スレッド」です。

✅ スレッドを意識しなくても動く場面

Javaのプログラムは、普通に書くだけで **JVMが自動的にスレッドを管理** してくれます。

• 🟢 Webアプリ（Spring, Servlet） → リクエストごとにスレッドが作られる
• 🟢 データベース処理（JDBC） → 並列でクエリを実行できる
• 🟢 非同期処理（Future, CompletableFuture） → 裏で自動的にスレッドが動く

つまり、「スレッドを意識しなくても普通に動くことが多い」 のです。

⚠ でもスレッドを意識しなければいけない場面

ただし、次のような場合は **スレッドの管理を考えないと問題が発生する** ことがあります。

• ⚠ データの競合が起こる（例: 2つのスレッドが同じファイルを書き換える）
• ⚠ デッドロックになる（例: AのスレッドがBを待ち、BがAを待つ）
• ⚠ スレッドの作りすぎで重くなる（無限にスレッドを作るとCPUがパンク）

このような問題を避けるために、適切なスレッド管理が必要です。

📌 初心者がまず覚えるべきこと

• ✅ Thread クラスを使うとスレッドを作れるが、基本的には ExecutorService を使う方が良い
• ✅ synchronized を使うと、データの競合を防げる
• ✅ スレッドを使いすぎると逆に処理が遅くなるので、適切な管理が必要

🎯 これから学ぶべきこと

• 🔹 スレッドプール（ ExecutorService）の使い方
• 🔹 非同期処理（ CompletableFuture）の活用
• 🔹 「デッドロックを避ける設計」の考え方

スレッドは「プログラムを速くする魔法」ではなく、「適切に使わないと逆に遅くなる」こともあります。まずは **「スレッドが必要な場面」と「注意点」** を押さえておきましょう！