Gemini永久会员 三个线程(A、B、C)交替执行

要实现三个线程(A、B、C)交替执行(即按顺序A→B→C→A→B→C...循环),可以通过线程同步机制(如wait()/notify()或ReentrantLock+Condition)或使用Semaphore信号量来控制。以下是两种常见实现方式:


方法1:使用 wait() 和 notify()

通过共享锁和条件变量实现线程交替执行:

java 复制代码
public class AlternateThreads {
    private static final Object lock = new Object();
    private static int state = 0; // 0:A, 1:B, 2:C

    public static void main(String[] args) {
        new Thread(() -> {
            while (true) {
                synchronized (lock) {
                    while (state % 3 != 0) { // 检查是否是A的轮次
                        try { lock.wait(); } catch (InterruptedException e) {}
                    }
                    System.out.print("A");
                    state++;
                    lock.notifyAll(); // 唤醒其他线程
                }
            }
        }).start();

        new Thread(() -> {
            while (true) {
                synchronized (lock) {
                    while (state % 3 != 1) { // 检查是否是B的轮次
                        try { lock.wait(); } catch (InterruptedException e) {}
                    }
                    System.out.print("B");
                    state++;
                    lock.notifyAll();
                }
            }
        }).start();

        new Thread(() -> {
            while (true) {
                synchronized (lock) {
                    while (state % 3 != 2) { // 检查是否是C的轮次
                        try { lock.wait(); } catch (InterruptedException e) {}
                    }
                    System.out.print("C");
                    state++;
                    lock.notifyAll();
                }
            }
        }).start();
    }
}

输出示例 :ABCABCABC...

关键点:

  1. 共享变量 state 记录当前轮次。
  2. 每个线程通过 wait() 等待自己的轮次,执行后通过 notifyAll() 唤醒其他线程。
  3. synchronized 确保线程安全。

方法2:使用 ReentrantLock + Condition(更灵活)

通过显式锁和条件变量实现更清晰的交替控制:

java 复制代码
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class AlternateThreadsWithLock {
    private static ReentrantLock lock = new ReentrantLock();
    private static Condition conditionA = lock.newCondition();
    private static Condition conditionB = lock.newCondition();
    private static Condition conditionC = lock.newCondition();
    private static int state = 0; // 0:A, 1:B, 2:C

    public static void main(String[] args) {
        new Thread(() -> {
            while (true) {
                lock.lock();
                try {
                    while (state % 3 != 0) {
                        conditionA.await();
                    }
                    System.out.print("A");
                    state++;
                    conditionB.signal(); // 唤醒B
                } catch (InterruptedException e) {}
                finally { lock.unlock(); }
            }
        }).start();

        new Thread(() -> {
            while (true) {
                lock.lock();
                try {
                    while (state % 3 != 1) {
                        conditionB.await();
                    }
                    System.out.print("B");
                    state++;
                    conditionC.signal(); // 唤醒C
                } catch (InterruptedException e) {}
                finally { lock.unlock(); }
            }
        }).start();

        new Thread(() -> {
            while (true) {
                lock.lock();
                try {
                    while (state % 3 != 2) {
                        conditionC.await();
                    }
                    System.out.print("C");
                    state++;
                    conditionA.signal(); // 唤醒A
                } catch (InterruptedException e) {}
                finally { lock.unlock(); }
            }
        }).start();
    }
}

优势:

  • 每个线程有独立的 Condition,避免不必要的唤醒(比 notifyAll() 更高效)。
  • 代码结构更清晰,易于扩展。

方法3:使用 Semaphore 信号量

通过信号量控制线程的执行顺序:

java 复制代码
import java.util.concurrent.Semaphore;

public class AlternateThreadsWithSemaphore {
    private static Semaphore semaphoreA = new Semaphore(1);
    private static Semaphore semaphoreB = new Semaphore(0);
    private static Semaphore semaphoreC = new Semaphore(0);

    public static void main(String[] args) {
        new Thread(() -> {
            while (true) {
                try {
                    semaphoreA.acquire();
                    System.out.print("A");
                    semaphoreB.release();
                } catch (InterruptedException e) {}
            }
        }).start();

        new Thread(() -> {
            while (true) {
                try {
                    semaphoreB.acquire();
                    System.out.print("B");
                    semaphoreC.release();
                } catch (InterruptedException e) {}
            }
        }).start();

        new Thread(() -> {
            while (true) {
                try {
                    semaphoreC.acquire();
                    System.out.print("C");
                    semaphoreA.release();
                } catch (InterruptedException e) {}
            }
        }).start();
    }
}

原理:

  • 初始时 semaphoreA 有一个许可,其他信号量为0。
  • 每个线程执行后释放下一个线程的信号量,形成循环。

总结

  • 简单场景 :用 wait()/notify() 或 Semaphore。
  • 复杂场景 :用 ReentrantLock + Condition(更灵活高效)。
  • 关键点:确保线程按顺序释放资源,避免死锁或竞争条件。

根据需求选择合适的方法即可!

相关推荐
Sashtok1 分钟前
cpp基础知识(10)
c++·后端
摇滚侠6 分钟前
《On Java 中文版 基础卷》阅读笔记 接口 18
java·笔记·python
CoderYanger35 分钟前
Java EE 进阶:9.MyBatis 操作数据库(进阶)(第八弹):MyBatis Generator
java·数据库·spring boot·spring·java-ee·tomcat·mybatis
行百里er1 小时前
【Spring Insight 技术分享】runtime-settings.json 的妙用
后端·开源·监控
databook2 小时前
处理一批 PDF,怎么算真的处理完了
后端·python
苏三说技术3 小时前
为什么越来越多人用 Docling ? - 苏三说技术
后端
nice_lcj5203 小时前
【从零理解计算机网络 · 12】登录态的载体:Cookie、Session、Token 在网络层怎么走
后端·计算机网络·面试·jwt·token·cookie·session
jaysee-sjc3 小时前
【黑马点评】Day02:优惠券秒杀与分布式锁
java·分布式·nginx·spring·node.js·tomcat·maven
谙弆悕博士3 小时前
多智能体架构详解:市场拍卖式架构(Market-based / 竞价协商)
开发语言·架构·去中心化·多智能体·智能体·拍卖架构
秋天的怀念_David4 小时前
算法一千零一夜 · 第三十五夜 · 恢复风暴
java·程序人生·算法