Java中如何实现让线程按照自己指定的顺序执行

发布时间：2023-05-05 10:16:28 作者：iii
来源：亿速云阅读：387

Java中如何实现让线程按照自己指定的顺序执行

在Java多线程编程中，线程的执行顺序通常是由操作系统的调度器决定的，开发者无法直接控制线程的执行顺序。然而，在某些场景下，我们可能需要让多个线程按照特定的顺序执行。本文将详细介绍如何在Java中实现让线程按照指定的顺序执行，并提供多种实现方式的代码示例。

1. 使用`join()`方法

join()方法是Java中用于控制线程执行顺序的一种简单方式。当一个线程调用另一个线程的join()方法时，当前线程会等待被调用的线程执行完毕后再继续执行。

示例代码

public class JoinExample {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            System.out.println("Thread 1 is running");
        });

        Thread t2 = new Thread(() -> {
            try {
                t1.join(); // 等待t1执行完毕
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 2 is running");
        });

        Thread t3 = new Thread(() -> {
            try {
                t2.join(); // 等待t2执行完毕
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 3 is running");
        });

        t1.start();
        t2.start();
        t3.start();
    }
}

输出结果

Thread 1 is running
Thread 2 is running
Thread 3 is running

分析

t1线程首先启动并执行。
t2线程在启动后调用t1.join()，等待t1执行完毕后再继续执行。
t3线程在启动后调用t2.join()，等待t2执行完毕后再继续执行。

通过这种方式，我们可以确保线程按照t1、t2、t3的顺序执行。

2. 使用`ExecutorService`和`Future`

ExecutorService是Java中用于管理线程池的工具，它可以用来控制线程的执行顺序。通过submit()方法提交任务，并使用Future对象来获取任务的执行结果，我们可以确保任务按照指定的顺序执行。

示例代码

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

public class ExecutorServiceExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);

        Future<?> future1 = executor.submit(() -> {
            System.out.println("Task 1 is running");
        });

        Future<?> future2 = executor.submit(() -> {
            try {
                future1.get(); // 等待Task 1执行完毕
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("Task 2 is running");
        });

        Future<?> future3 = executor.submit(() -> {
            try {
                future2.get(); // 等待Task 2执行完毕
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("Task 3 is running");
        });

        executor.shutdown();
    }
}

输出结果

Task 1 is running
Task 2 is running
Task 3 is running

分析

Task 1首先被提交到线程池并执行。
Task 2在提交后调用future1.get()，等待Task 1执行完毕后再继续执行。
Task 3在提交后调用future2.get()，等待Task 2执行完毕后再继续执行。

通过这种方式，我们可以确保任务按照Task 1、Task 2、Task 3的顺序执行。

3. 使用`CountDownLatch`

CountDownLatch是Java中用于控制线程同步的工具，它可以让一个或多个线程等待其他线程完成操作后再继续执行。通过设置CountDownLatch的初始值，并在每个线程完成任务后调用countDown()方法，我们可以控制线程的执行顺序。

示例代码

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    public static void main(String[] args) {
        CountDownLatch latch1 = new CountDownLatch(1);
        CountDownLatch latch2 = new CountDownLatch(1);

        Thread t1 = new Thread(() -> {
            System.out.println("Thread 1 is running");
            latch1.countDown(); // 通知Thread 2可以继续执行
        });

        Thread t2 = new Thread(() -> {
            try {
                latch1.await(); // 等待Thread 1执行完毕
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 2 is running");
            latch2.countDown(); // 通知Thread 3可以继续执行
        });

        Thread t3 = new Thread(() -> {
            try {
                latch2.await(); // 等待Thread 2执行完毕
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 3 is running");
        });

        t1.start();
        t2.start();
        t3.start();
    }
}

输出结果

Thread 1 is running
Thread 2 is running
Thread 3 is running

分析

Thread 1首先启动并执行，执行完毕后调用latch1.countDown()，通知Thread 2可以继续执行。
Thread 2在启动后调用latch1.await()，等待Thread 1执行完毕后再继续执行，执行完毕后调用latch2.countDown()，通知Thread 3可以继续执行。
Thread 3在启动后调用latch2.await()，等待Thread 2执行完毕后再继续执行。

通过这种方式，我们可以确保线程按照Thread 1、Thread 2、Thread 3的顺序执行。

4. 使用`CyclicBarrier`

CyclicBarrier是Java中用于控制多个线程在某个屏障点同步的工具。与CountDownLatch不同，CyclicBarrier可以重复使用，并且可以在所有线程到达屏障点后执行一个指定的操作。

示例代码

import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {
    public static void main(String[] args) {
        CyclicBarrier barrier1 = new CyclicBarrier(2);
        CyclicBarrier barrier2 = new CyclicBarrier(2);

        Thread t1 = new Thread(() -> {
            System.out.println("Thread 1 is running");
            try {
                barrier1.await(); // 等待Thread 2到达屏障点
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        Thread t2 = new Thread(() -> {
            try {
                barrier1.await(); // 等待Thread 1到达屏障点
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("Thread 2 is running");
            try {
                barrier2.await(); // 等待Thread 3到达屏障点
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        Thread t3 = new Thread(() -> {
            try {
                barrier2.await(); // 等待Thread 2到达屏障点
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("Thread 3 is running");
        });

        t1.start();
        t2.start();
        t3.start();
    }
}

输出结果

Thread 1 is running
Thread 2 is running
Thread 3 is running

分析

Thread 1首先启动并执行，执行完毕后调用barrier1.await()，等待Thread 2到达屏障点。
Thread 2在启动后调用barrier1.await()，等待Thread 1到达屏障点，执行完毕后调用barrier2.await()，等待Thread 3到达屏障点。
Thread 3在启动后调用barrier2.await()，等待Thread 2到达屏障点，执行完毕后继续执行。

通过这种方式，我们可以确保线程按照Thread 1、Thread 2、Thread 3的顺序执行。

5. 使用`Semaphore`

Semaphore是Java中用于控制并发访问资源的工具，它可以通过设置许可数来控制同时访问资源的线程数量。通过合理设置Semaphore的许可数，我们可以控制线程的执行顺序。

示例代码

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    public static void main(String[] args) {
        Semaphore semaphore1 = new Semaphore(0);
        Semaphore semaphore2 = new Semaphore(0);

        Thread t1 = new Thread(() -> {
            System.out.println("Thread 1 is running");
            semaphore1.release(); // 释放一个许可，允许Thread 2继续执行
        });

        Thread t2 = new Thread(() -> {
            try {
                semaphore1.acquire(); // 获取一个许可，等待Thread 1释放许可
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 2 is running");
            semaphore2.release(); // 释放一个许可，允许Thread 3继续执行
        });

        Thread t3 = new Thread(() -> {
            try {
                semaphore2.acquire(); // 获取一个许可，等待Thread 2释放许可
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 3 is running");
        });

        t1.start();
        t2.start();
        t3.start();
    }
}

输出结果

Thread 1 is running
Thread 2 is running
Thread 3 is running

分析

Thread 1首先启动并执行，执行完毕后调用semaphore1.release()，释放一个许可，允许Thread 2继续执行。
Thread 2在启动后调用semaphore1.acquire()，获取一个许可，等待Thread 1释放许可，执行完毕后调用semaphore2.release()，释放一个许可，允许Thread 3继续执行。
Thread 3在启动后调用semaphore2.acquire()，获取一个许可，等待Thread 2释放许可，执行完毕后继续执行。

通过这种方式，我们可以确保线程按照Thread 1、Thread 2、Thread 3的顺序执行。

6. 使用`Lock`和`Condition`

Lock和Condition是Java中用于实现线程同步的高级工具。通过使用Lock和Condition，我们可以精确控制线程的执行顺序。

示例代码

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

public class LockConditionExample {
    private static Lock lock = new ReentrantLock();
    private static Condition condition1 = lock.newCondition();
    private static Condition condition2 = lock.newCondition();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            lock.lock();
            try {
                System.out.println("Thread 1 is running");
                condition1.signal(); // 通知Thread 2可以继续执行
            } finally {
                lock.unlock();
            }
        });

        Thread t2 = new Thread(() -> {
            lock.lock();
            try {
                condition1.await(); // 等待Thread 1的通知
                System.out.println("Thread 2 is running");
                condition2.signal(); // 通知Thread 3可以继续执行
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        });

        Thread t3 = new Thread(() -> {
            lock.lock();
            try {
                condition2.await(); // 等待Thread 2的通知
                System.out.println("Thread 3 is running");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        });

        t2.start();
        t1.start();
        t3.start();
    }
}

输出结果

Thread 1 is running
Thread 2 is running
Thread 3 is running

分析

Thread 1首先启动并执行，执行完毕后调用condition1.signal()，通知Thread 2可以继续执行。
Thread 2在启动后调用condition1.await()，等待Thread 1的通知，执行完毕后调用condition2.signal()，通知Thread 3可以继续执行。
Thread 3在启动后调用condition2.await()，等待Thread 2的通知，执行完毕后继续执行。

通过这种方式，我们可以确保线程按照Thread 1、Thread 2、Thread 3的顺序执行。

7. 使用`CompletableFuture`

CompletableFuture是Java 8引入的用于异步编程的工具，它提供了丰富的API来控制任务的执行顺序。通过使用thenApply()、thenAccept()等方法，我们可以轻松地实现任务的顺序执行。

示例代码

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
            System.out.println("Task 1 is running");
        });

        CompletableFuture<Void> future2 = future1.thenRun(() -> {
            System.out.println("Task 2 is running");
        });

        CompletableFuture<Void> future3 = future2.thenRun(() -> {
            System.out.println("Task 3 is running");
        });

        future3.join(); // 等待所有任务执行完毕
    }
}

输出结果

Task 1 is running
Task 2 is running
Task 3 is running

分析

Task 1首先被提交并执行。
Task 2在Task 1执行完毕后通过thenRun()方法继续执行。
Task 3在Task 2执行完毕后通过thenRun()方法继续执行。

通过这种方式，我们可以确保任务按照Task 1、Task 2、Task 3的顺序执行。

8. 使用`Phaser`

Phaser是Java 7引入的用于控制多个线程在多个阶段同步的工具。与CyclicBarrier类似，Phaser可以重复使用，并且可以在每个阶段结束后执行指定的操作。

示例代码

import java.util.concurrent.Phaser;

public class PhaserExample {
    public static void main(String[] args) {
        Phaser phaser = new Phaser(1);

        Thread t1 = new Thread(() -> {
            System.out.println("Thread 1 is running");
            phaser.arriveAndAwaitAdvance(); // 等待其他线程到达当前阶段
        });

        Thread t2 = new Thread(() -> {
            phaser.arriveAndAwaitAdvance(); // 等待其他线程到达当前阶段
            System.out.println("Thread 2 is running");
            phaser.arriveAndAwaitAdvance(); // 等待其他线程到达当前阶段
        });

        Thread t3 = new Thread(() -> {
            phaser.arriveAndAwaitAdvance(); // 等待其他线程到达当前阶段
            System.out.println("Thread 3 is running");
        });

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

        phaser.arriveAndDeregister(); // 主线程到达并注销
    }
}

输出结果

Thread 1 is running
Thread 2 is running
Thread 3 is running

分析

Thread 1首先启动并执行，执行完毕后调用phaser.arriveAndAwaitAdvance()，等待其他线程到达当前阶段。
Thread 2在启动后调用phaser.arriveAndAwaitAdvance()，等待其他线程到达当前阶段，执行完毕后再次调用phaser.arriveAndAwaitAdvance()，等待其他线程到达当前阶段。
Thread 3在启动后调用phaser.arriveAndAwaitAdvance()，等待其他线程到达当前阶段，执行完毕后继续执行。

通过这种方式，我们可以确保线程按照Thread 1、Thread 2、Thread 3的顺序执行。

9. 使用`BlockingQueue`

BlockingQueue是Java中用于实现生产者-消费者模式的工具，它可以在多个线程之间安全地传递数据。通过使用BlockingQueue，我们可以控制线程的执行顺序。

示例代码

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class BlockingQueueExample {
    public static void main(String[] args) {
        BlockingQueue<String> queue = new LinkedBlockingQueue<>();

        Thread t1 = new Thread(() -> {
            System.out.println("Thread 1 is running");
            queue.offer("Thread 1 completed");
        });

        Thread t2 = new Thread(() -> {
            try {
                queue.take(); // 等待Thread 1完成
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 2 is running");
            queue.offer("Thread 2 completed");
        });

        Thread t3 = new Thread(() -> {
            try {
                queue.take(); // 等待Thread 2完成
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 3 is running");
        });

        t1.start();
        t2.start();
        t3.start();
    }
}

输出结果

Thread 1 is running
Thread 2 is running
Thread 3 is running

分析

Thread 1首先启动并执行，执行完毕后将消息放入queue。
Thread 2在启动后调用queue.take()，等待Thread 1完成，执行完毕后将消息放入queue。
Thread 3在启动后调用queue.take()，等待Thread 2完成，执行完毕后继续执行。

通过这种方式，我们可以确保线程按照Thread 1、Thread 2、Thread 3的顺序执行。

10. 使用`ThreadLocal`

ThreadLocal是Java中用于实现线程本地存储的工具，它可以在每个线程中保存独立的变量副本。通过使用`

Java中如何实现让线程按照自己指定的顺序执行

Java中如何实现让线程按照自己指定的顺序执行

1. 使用join()方法

示例代码

输出结果

分析

2. 使用ExecutorService和Future

示例代码

输出结果

分析

3. 使用CountDownLatch

示例代码

输出结果

分析

4. 使用CyclicBarrier

示例代码

输出结果

分析

5. 使用Semaphore

示例代码

输出结果

分析

6. 使用Lock和Condition

示例代码

输出结果

分析

7. 使用CompletableFuture

示例代码

输出结果

分析

8. 使用Phaser

示例代码

输出结果

分析

9. 使用BlockingQueue

示例代码

输出结果

分析

10. 使用ThreadLocal

相关阅读

1. 使用`join()`方法

2. 使用`ExecutorService`和`Future`

3. 使用`CountDownLatch`

4. 使用`CyclicBarrier`

5. 使用`Semaphore`

6. 使用`Lock`和`Condition`

7. 使用`CompletableFuture`

8. 使用`Phaser`

9. 使用`BlockingQueue`

10. 使用`ThreadLocal`