Javaのスレッドと同期の基礎

Javaにおけるスレッドの作成と同期の理解は、並列処理を効果的に活用するために不可欠な技術です。スレッドは、Javaプログラムで並行して処理を実行するための基本的な単位であり、効率的なリソース管理と処理速度向上に寄与します。本記事では、Javaでスレッドを作成する方法、スレッドの同期、スレッドセーフなプログラムの設計方法について完全かつ包括的に説明します。

1. スレッドの作成方法

Javaでスレッドを作成する方法は大きく分けて2つあります。それは「Thread クラスを継承する方法」と「Runnable インターフェースを実装する方法」です。

1.1 Thread クラスを継承する方法

Thread クラスを継承し、その run() メソッドをオーバーライドしてスレッドの処理を記述する方法です。

java
CopyEdit
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("スレッドが実行中...");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // スレッドを開始する
    }
}

この方法では、Thread クラスを拡張することによってスレッドを作成し、start() メソッドを呼び出してスレッドを開始します。run() メソッドはスレッドが実行する処理を記述する部分です。

1.2 Runnable インターフェースを実装する方法

Runnable インターフェースを実装し、その run() メソッドをオーバーライドする方法です。この方法は、Thread クラスを継承するのではなく、他のクラスを継承する場合に有用です。

java
CopyEdit
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnableスレッドが実行中...");
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start(); // スレッドを開始する
    }
}

Runnable インターフェースを使用することで、スレッドの処理を他のクラスと共存させることができるため、クラスの継承に制限を受けずにスレッド処理を実装できます。

2. スレッドの同期

スレッドが同時に実行される環境では、複数のスレッドが同じリソースにアクセスしようとすると、データ競合（データの不整合）が発生する可能性があります。これを防ぐために、Javaでは「同期」を使用してスレッド間のデータアクセスを制御することができます。

2.1 synchronized キーワード

synchronized キーワードは、特定のメソッドやコードブロックが同時に複数のスレッドから実行されないようにロックをかけるために使用されます。

java
CopyEdit
class Counter {
    private int count = 0;

    // synchronizedを使ってスレッド間での競合を防ぐ
    public synchronized void increment() {
        count++;
    }

    public synchronized void decrement() {
        count--;
    }

    public int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        // スレッド1
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        // スレッド2
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

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

        System.out.println("最終カウント: " + counter.getCount());
    }
}

この例では、increment() と decrement() メソッドに synchronized を付けて、複数のスレッドが同時にカウントを変更しないようにしています。これにより、カウントの不整合を防ぎます。

2.2 ReentrantLock クラス

ReentrantLock クラスは、synchronized よりも細かい制御が可能なロック機構を提供します。例えば、ロックの取得をタイムアウト付きで試みることや、ロックを手動で解除することができます。

java
CopyEdit
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Counter {
    private int count = 0;
    private final Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock(); // ロックを取得
        try {
            count++;
        } finally {
            lock.unlock(); // ロックを解放
        }
    }

    public void decrement() {
        lock.lock();
        try {
            count--;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        // スレッド1
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        // スレッド2
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

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

        System.out.println("最終カウント: " + counter.getCount());
    }
}

ReentrantLock を使用することで、ロックの取得・解放がより柔軟に制御でき、複雑なシナリオでも確実にリソースを管理できます。

3. スレッドの状態とライフサイクル

スレッドには、以下のような状態があります：

• 新規状態（New）: スレッドが作成され、まだ実行されていない状態です。
• 実行可能状態（Runnable）: start() メソッドが呼ばれ、スケジューラによって実行を待っている状態です。
• 実行中状態（Running）: スレッドがCPUを獲得し、実際に実行されている状態です。
• 停止状態（Terminated）: スレッドの run() メソッドが終了した場合、または interrupt() によってスレッドが停止した場合にこの状態になります。

スレッドの状態は、プログラムがどのようにリソースを管理しているか、スレッド間でどのように協調して動作しているかに影響を与えます。

4. スレッドプールの活用

スレッドを効率的に管理するためには、ExecutorService を使用してスレッドプールを作成することが一般的です。これにより、スレッドの作成と管理を簡素化し、リソースの無駄を減らすことができます。

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

public class Main {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);

        executorService.submit(() -> System.out.println("タスク1"));
        executorService.submit(() -> System.out.println("タスク2"));
        executorService.submit(() -> System.out.println("タスク3"));

        executorService.shutdown(); // スレッドプールのシャットダウン
    }
}

ExecutorService を使うと、スレッドの再利用が可能になり、性能向上が期待できます。

結論

Javaでのスレッドの作成と同期は、並列処理を効率的に実行するための基本的な技術です。Thread クラスや Runnable インターフェースを使ってスレッドを作成し、synchronized や ReentrantLock を使ってスレッド間での競合を避けることができます。また、スレッドプールを使用することでスレッド管理を簡素化し、パフォーマンスを最適化することができます。これらを理解し、適切に使うことで、Javaで効率的で安全な並列プログラミングが可能になります。