Java – 複数のスレッドでデータを同期させて整合性を保つ方法

public class App {
    private int count = 0; // カウンター
    // synchronizedメソッド
    public synchronized void increment() {
        count++; // カウンターをインクリメント
    }
    public int getCount() {
        return count; // カウンターの値を取得
    }
    public static void main(String[] args) throws InterruptedException {
        App app = new App(); // Appクラスのインスタンスを作成
        // スレッドを作成
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                app.increment(); // カウンターをインクリメント
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                app.increment(); // カウンターをインクリメント
            }
        });
        // スレッドを開始
        thread1.start();
        thread2.start();
        // スレッドの終了を待機
        thread1.join();
        thread2.join();
        // カウンターの値を表示
        System.out.println("最終カウント: " + app.getCount()); // 最終カウントを表示
    }
}

最終カウント: 2000

import java.util.concurrent.locks.ReentrantLock;
public class App {
    private int count = 0; // カウンター
    private ReentrantLock lock = new ReentrantLock(); // ロックのインスタンス
    public void increment() {
        lock.lock(); // ロックを取得
        try {
            count++; // カウンターをインクリメント
        } finally {
            lock.unlock(); // ロックを解放
        }
    }
    public int getCount() {
        return count; // カウンターの値を取得
    }
    public static void main(String[] args) throws InterruptedException {
        App app = new App(); // Appクラスのインスタンスを作成
        // スレッドを作成
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                app.increment(); // カウンターをインクリメント
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                app.increment(); // カウンターをインクリメント
            }
        });
        // スレッドを開始
        thread1.start();
        thread2.start();
        // スレッドの終了を待機
        thread1.join();
        thread2.join();
        // カウンターの値を表示
        System.out.println("最終カウント: " + app.getCount()); // 最終カウントを表示
    }
}

最終カウント: 2000

import java.util.concurrent.CountDownLatch;
public class App {
    private static final int THREAD_COUNT = 3; // スレッドの数
    private static CountDownLatch latch = new CountDownLatch(THREAD_COUNT); // CountDownLatchのインスタンス
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < THREAD_COUNT; i++) {
            final int threadId = i;
            new Thread(() -> {
                try {
                    // 各スレッドの処理
                    System.out.println("スレッド " + threadId + " が処理を開始しました。");
                    Thread.sleep(1000); // 処理のシミュレーション
                    System.out.println("スレッド " + threadId + " が処理を完了しました。");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    latch.countDown(); // 処理が完了したらカウントダウン
                }
            }).start();
        }
        // 全てのスレッドが完了するまで待機
        latch.await(); 
        System.out.println("全てのスレッドが完了しました。");
    }
}

スレッド 0 が処理を開始しました。
スレッド 1 が処理を開始しました。
スレッド 2 が処理を開始しました。
スレッド 0 が処理を完了しました。
スレッド 1 が処理を完了しました。
スレッド 2 が処理を完了しました。
全てのスレッドが完了しました。

import java.util.concurrent.CyclicBarrier;
public class App {
    private static final int THREAD_COUNT = 3; // スレッドの数
    private static CyclicBarrier barrier = new CyclicBarrier(THREAD_COUNT, () -> {
        // 全てのスレッドが到達した後に実行される処理
        System.out.println("全てのスレッドが到達しました。次の処理を開始します。");
    });
    public static void main(String[] args) {
        for (int i = 0; i < THREAD_COUNT; i++) {
            final int threadId = i;
            new Thread(() -> {
                try {
                    // 各スレッドの処理
                    System.out.println("スレッド " + threadId + " が処理を開始しました。");
                    Thread.sleep(1000); // 処理のシミュレーション
                    System.out.println("スレッド " + threadId + " がバリアに到達しました。");
                    barrier.await(); // バリアに到達
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

スレッド 0 が処理を開始しました。
スレッド 1 が処理を開始しました。
スレッド 2 が処理を開始しました。
スレッド 0 がバリアに到達しました。
スレッド 1 がバリアに到達しました。
スレッド 2 がバリアに到達しました。
全てのスレッドが到達しました。次の処理を開始します。

import java.util.concurrent.Semaphore;
public class App {
    private static final int MAX_PERMITS = 2; // 最大許可数
    private static Semaphore semaphore = new Semaphore(MAX_PERMITS); // Semaphoreのインスタンス
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            final int threadId = i;
            new Thread(() -> {
                try {
                    semaphore.acquire(); // セマフォを取得
                    System.out.println("スレッド " + threadId + " がリソースを使用中。");
                    Thread.sleep(1000); // リソース使用のシミュレーション
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println("スレッド " + threadId + " がリソースを解放。");
                    semaphore.release(); // セマフォを解放
                }
            }).start();
        }
    }
}

スレッド 0 がリソースを使用中。
スレッド 1 がリソースを使用中。
スレッド 0 がリソースを解放。
スレッド 2 がリソースを使用中。
スレッド 1 がリソースを解放。
スレッド 3 がリソースを使用中。
スレッド 2 がリソースを解放。
スレッド 4 がリソースを使用中。
スレッド 3 がリソースを解放。
スレッド 4 がリソースを解放。

public class App {
    private int count = 0; // カウンター
    // synchronizedメソッド
    public synchronized void increment() {
        count++; // カウンターをインクリメント
    }
    public int getCount() {
        return count; // カウンターの値を取得
    }
    public static void main(String[] args) throws InterruptedException {
        App app = new App(); // Appクラスのインスタンスを作成
        // スレッドを作成
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                app.increment(); // カウンターをインクリメント
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                app.increment(); // カウンターをインクリメント
            }
        });
        // スレッドを開始
        thread1.start();
        thread2.start();
        // スレッドの終了を待機
        thread1.join();
        thread2.join();
        // カウンターの値を表示
        System.out.println("最終カウント: " + app.getCount()); // 最終カウントを表示
    }
}

最終カウント: 2000

import java.util.concurrent.locks.ReentrantLock;
public class App {
    private int count = 0; // カウンター
    private ReentrantLock lock = new ReentrantLock(); // ロックのインスタンス
    public void increment() {
        lock.lock(); // ロックを取得
        try {
            count++; // カウンターをインクリメント
        } finally {
            lock.unlock(); // ロックを解放
        }
    }
    public int getCount() {
        return count; // カウンターの値を取得
    }
    public static void main(String[] args) throws InterruptedException {
        App app = new App(); // Appクラスのインスタンスを作成
        // スレッドを作成
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                app.increment(); // カウンターをインクリメント
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                app.increment(); // カウンターをインクリメント
            }
        });
        // スレッドを開始
        thread1.start();
        thread2.start();
        // スレッドの終了を待機
        thread1.join();
        thread2.join();
        // カウンターの値を表示
        System.out.println("最終カウント: " + app.getCount()); // 最終カウントを表示
    }
}

最終カウント: 2000