Java中保证线程顺序执行的四种实现方式

class MyThread extends Thread {
    private String name;

    MyThread(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println(name + " is running.");
    }
}

public class ThreadJoinExample {
    public static void main(String[] args) throws InterruptedException {
        MyThread thread1 = new MyThread("Thread 1");
        MyThread thread2 = new MyThread("Thread 2");
        MyThread thread3 = new MyThread("Thread 3");

        thread1.start();
        thread1.join();  // 让主线程等待thread1执行完成

        thread2.start();
        thread2.join();  // 让主线程等待thread2执行完成

        thread3.start();
        thread3.join();  // 让主线程等待thread3执行完成
    }
}

import java.util.concurrent.*;

public class ThreadOrderWithCountDownLatch {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        CountDownLatch latch1 = new CountDownLatch(1);
        CountDownLatch latch2 = new CountDownLatch(1);

        executor.submit(() -> {
            try {
                System.out.println("Thread 1 is running.");
                latch1.countDown();  // 释放线程2
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        executor.submit(() -> {
            try {
                latch1.await();  // 等待线程1完成
                System.out.println("Thread 2 is running.");
                latch2.countDown();  // 释放线程3
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        executor.submit(() -> {
            try {
                latch2.await();  // 等待线程2完成
                System.out.println("Thread 3 is running.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        executor.shutdown();
    }
}

import java.util.concurrent.*;

public class ThreadOrderWithSemaphore {
    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphore1 = new Semaphore(0);  // 初始化为0，表示线程2需要等待线程1
        Semaphore semaphore2 = new Semaphore(0);  // 初始化为0，表示线程3需要等待线程2

        new Thread(() -> {
            System.out.println("Thread 1 is running.");
            semaphore1.release();  // 释放线程2
        }).start();

        new Thread(() -> {
            try {
                semaphore1.acquire();  // 等待线程1完成
                System.out.println("Thread 2 is running.");
                semaphore2.release();  // 释放线程3
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(() -> {
            try {
                semaphore2.acquire();  // 等待线程2完成
                System.out.println("Thread 3 is running.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

public class ThreadOrderWithWaitNotify {
    private static final Object lock = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 1 is running.");
                lock.notify();  // 唤醒线程2
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                try {
                    lock.wait();  // 等待线程1执行
                    System.out.println("Thread 2 is running.");
                    lock.notify();  // 唤醒线程3
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread thread3 = new Thread(() -> {
            synchronized (lock) {
                try {
                    lock.wait();  // 等待线程2执行
                    System.out.println("Thread 3 is running.");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        thread1.start();
        thread2.start();
        thread3.start();
    }
}