Java如何保证线程T1，T2，T3 顺序执行？

news2024/10/12 2:12:02

文章目录

- - 方案 1：使用 `Thread.join()`
  - 方案 2：使用 `Lock` 和 `Condition`
  - 方案 3：使用 `CyclicBarrier`
  - 方案 4：使用 `Semaphore`
  - 总结

博主介绍：全网粉丝10w+、CSDN合伙人、华为云特邀云享专家，阿里云专家博主、星级博主，51cto明日之星，热爱技术和分享、专注于Java技术领域
🍅文末获取源码联系🍅
👇🏻 精彩专栏推荐订阅👇🏻 不然下次找不到哟

在 Java 中，要确保线程 T1、T2 和 T3 顺序执行，可以使用多种方式。这里介绍几种常见的方案：
在这里插入图片描述

方案 1：使用 `Thread.join()`

Thread.join() 是最简单直接的方法。调用某个线程的 join() 方法时，当前线程会等待该线程执行完毕后再继续执行。

代码示例：

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

        Thread t2 = new Thread(() -> {
            System.out.println("Thread T2 is running.");
        });

        Thread t3 = new Thread(() -> {
            System.out.println("Thread T3 is running.");
        });

        try {
            t1.start();
            t1.join(); // 等待 t1 结束
            t2.start();
            t2.join(); // 等待 t2 结束
            t3.start();
            t3.join(); // 等待 t3 结束
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在这种方式中，主线程依次启动并等待 T1、T2 和 T3 执行完毕，确保了线程顺序执行。

方案 2：使用 `Lock` 和 `Condition`

通过 ReentrantLock 和 Condition，我们可以更灵活地控制线程的执行顺序。Condition 提供了 await() 和 signal() 方法，可以实现线程之间的精确控制。

代码示例：

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

public class ThreadSequenceLock {
    private static Lock lock = new ReentrantLock();
    private static Condition conditionT2 = lock.newCondition();
    private static Condition conditionT3 = lock.newCondition();
    private static boolean t1Finished = false;
    private static boolean t2Finished = false;

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            lock.lock();
            try {
                System.out.println("Thread T1 is running.");
                t1Finished = true;
                conditionT2.signal(); // 通知 T2 开始
            } finally {
                lock.unlock();
            }
        });

        Thread t2 = new Thread(() -> {
            lock.lock();
            try {
                while (!t1Finished) {
                    conditionT2.await(); // 等待 T1 完成
                }
                System.out.println("Thread T2 is running.");
                t2Finished = true;
                conditionT3.signal(); // 通知 T3 开始
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        });

        Thread t3 = new Thread(() -> {
            lock.lock();
            try {
                while (!t2Finished) {
                    conditionT3.await(); // 等待 T2 完成
                }
                System.out.println("Thread T3 is running.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        });

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

在这个示例中，通过 ReentrantLock 和 Condition 来控制 T2 等待 T1 完成，T3 等待 T2 完成，实现线程的顺序执行。

方案 3：使用 `CyclicBarrier`

CyclicBarrier 允许多个线程在某个点上进行同步。可以通过它来确保线程之间按顺序执行。

代码示例：

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class ThreadSequenceBarrier {
    public static void main(String[] args) {
        CyclicBarrier barrier1 = new CyclicBarrier(2); // 控制 T2 等待 T1
        CyclicBarrier barrier2 = new CyclicBarrier(2); // 控制 T3 等待 T2

        Thread t1 = new Thread(() -> {
            System.out.println("Thread T1 is running.");
            try {
                barrier1.await(); // 让 T2 继续执行
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        });

        Thread t2 = new Thread(() -> {
            try {
                barrier1.await(); // 等待 T1 先执行
                System.out.println("Thread T2 is running.");
                barrier2.await(); // 让 T3 继续执行
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        });

        Thread t3 = new Thread(() -> {
            try {
                barrier2.await(); // 等待 T2 先执行
                System.out.println("Thread T3 is running.");
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        });

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

在此方案中，CyclicBarrier 用于确保线程在特定的同步点等待其他线程达到，从而实现线程按顺序执行。

方案 4：使用 `Semaphore`

Semaphore 信号量可以控制多个线程对共享资源的访问权限。通过设置初始许可数量，我们可以用它来控制线程的执行顺序。

代码示例：

import java.util.concurrent.Semaphore;

public class ThreadSequenceSemaphore {
    public static void main(String[] args) {
        Semaphore semaphoreT1 = new Semaphore(1); // 控制 T1 的执行
        Semaphore semaphoreT2 = new Semaphore(0); // 控制 T2 的执行
        Semaphore semaphoreT3 = new Semaphore(0); // 控制 T3 的执行

        Thread t1 = new Thread(() -> {
            try {
                semaphoreT1.acquire(); // 先获取许可
                System.out.println("Thread T1 is running.");
                semaphoreT2.release(); // 释放 T2 的许可
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread t2 = new Thread(() -> {
            try {
                semaphoreT2.acquire(); // 等待 T1 释放许可
                System.out.println("Thread T2 is running.");
                semaphoreT3.release(); // 释放 T3 的许可
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread t3 = new Thread(() -> {
            try {
                semaphoreT3.acquire(); // 等待 T2 释放许可
                System.out.println("Thread T3 is running.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

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