Java中保證線程順序執(zhí)行的四種實現(xiàn)方式

更新時間：2025年08月11日 10:26:50 作者：喵手

在多線程編程中,線程的并發(fā)執(zhí)行通常是不可預知的,然而在某些應用場景中,我們需要確保多個線程按特定的順序執(zhí)行,本文將介紹幾種常見的方式,幫助我們在多線程中保證執(zhí)行順序,需要的朋友可以參考下

前言

在多線程編程中，線程的并發(fā)執(zhí)行通常是不可預知的，然而在某些應用場景中，我們需要確保多個線程按特定的順序執(zhí)行。保證線程按順序執(zhí)行可以避免資源競爭、避免邏輯錯誤并提高程序的可控性。本文將介紹幾種常見的方式，幫助我們在多線程中保證執(zhí)行順序。

1. 使用Thread.join()方法

join()方法是Java中一種常用的線程控制方法，用來讓一個線程等待另一個線程執(zhí)行完成后再繼續(xù)執(zhí)行。通過join()方法，我們可以確保多個線程按順序執(zhí)行。

示例：

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執(zhí)行完成

        thread2.start();
        thread2.join();  // 讓主線程等待thread2執(zhí)行完成

        thread3.start();
        thread3.join();  // 讓主線程等待thread3執(zhí)行完成
    }
}

解釋：

thread1.start()啟動線程1。
thread1.join()主線程會等待線程1執(zhí)行完成后才會繼續(xù)執(zhí)行。
thread2.start()啟動線程2，依此類推。

這樣，線程將會按順序（Thread 1 -> Thread 2 -> Thread 3）執(zhí)行。

2. 使用ExecutorService和CountDownLatch

ExecutorService提供了線程池的實現(xiàn)，而CountDownLatch則允許多個線程互相等待直到某個條件被滿足。通過這種機制，我們可以精確控制線程的執(zhí)行順序。

示例：

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();
    }
}

解釋：

通過CountDownLatch的await()和countDown()方法，線程2必須等待線程1執(zhí)行完畢，線程3必須等待線程2執(zhí)行完畢。
這種方法非常適合復雜的線程執(zhí)行順序控制，尤其是在多個線程之間存在依賴關系時。

3. 使用Semaphore

Semaphore是一個計數(shù)信號量，用于控制多個線程對共享資源的訪問。在保證順序執(zhí)行時，我們可以利用Semaphore來協(xié)調線程之間的執(zhí)行順序。

示例：

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();
    }
}

解釋：

Semaphore通過acquire()和release()方法協(xié)調線程執(zhí)行順序，確保線程按指定順序執(zhí)行。

4. 使用Synchronized和wait/notify

通過Synchronized和wait/notify機制，線程可以通過同步和通知機制來等待和喚醒。wait()會使線程進入等待狀態(tài)，而notify()或notifyAll()可以喚醒等待的線程。

示例：

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執(zhí)行
                    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執(zhí)行
                    System.out.println("Thread 3 is running.");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

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