【面试题】三个线程交替打印数字

实现这个功能主要是以下几个点：

1. 锁和条件变量：使用 ReentrantLock 和 Condition 来控制线程的执行顺序
2. 线程任务：定义了 PrintingTask 类，实现了 Runnable 接口，每个线程打印特定范围的数字，并在打印完之后唤醒下一个线程
3. 线程顺序控制：通过 threadNo 变量控制当前应执行的线程，并通过 Condition 对象的 await 和 signal 方法来挂起和唤醒线程
4. 主函数：创建并启动三个线程，确保它们按顺序执行

 

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

public class AlternatePrinting {

    private static final int MAX = 100; // 定义打印的最大值
    private int count = 1; // 当前计数
    private int threadNo = 1; // 当前线程编号
    private final Lock lock = new ReentrantLock(); // 定义锁对象
    private final Condition condition1 = lock.newCondition(); // 条件变量1
    private final Condition condition2 = lock.newCondition(); // 条件变量2
    private final Condition condition3 = lock.newCondition(); // 条件变量3

    public static void main(String[] args) {
        AlternatePrinting alternatePrinting = new AlternatePrinting();
        // 创建并启动三个线程
        Thread t1 = new Thread(alternatePrinting.new PrintingTask(1, alternatePrinting.condition1, alternatePrinting.condition2));
        Thread t2 = new Thread(alternatePrinting.new PrintingTask(2, alternatePrinting.condition2, alternatePrinting.condition3));
        Thread t3 = new Thread(alternatePrinting.new PrintingTask(3, alternatePrinting.condition3, alternatePrinting.condition1));
        t1.start();
        t2.start();
        t3.start();
    }

    // 定义打印任务类，实现Runnable接口
    class PrintingTask implements Runnable {
        private int threadId; // 当前线程的ID
        private Condition currentCondition; // 当前线程的条件变量
        private Condition nextCondition; // 下一个线程的条件变量

        // 构造方法，初始化线程ID和条件变量
        PrintingTask(int threadId, Condition currentCondition, Condition nextCondition) {
            this.threadId = threadId;
            this.currentCondition = currentCondition;
            this.nextCondition = nextCondition;
        }

        @Override
        public void run() {
            while (count <= MAX) {
                lock.lock(); // 获取锁
                try {
                    // 如果当前不是该线程打印，则等待
                    while (threadNo != threadId) {
                        currentCondition.await(); // 当前线程等待
                    }
                    // 打印当前计数，并将计数加1
                    if (count <= MAX) {
                        System.out.println("Thread " + threadId + ": " + count++);
                    }
                    // 更新当前线程编号
                    threadNo = threadId % 3 + 1;
                    // 唤醒下一个线程
                    nextCondition.signal(); // 唤醒下一个线程
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt(); // 处理中断异常
                } finally {
                    lock.unlock(); // 释放锁
                }
            }
        }
    }
}

Condition 是 Java 中并发编程的一部分，它与 Lock 结合使用，用于线程间的协调和通信。Condition 提供了一种比 Object 类中的 wait, notify 和 notifyAll 方法更强大的机制来控制线程的执行顺序

Condition 提供的方法主要有：

• await(): 使当前线程等待，直到其他线程调用 signal() 或 signalAll() 方法唤醒它
• signal(): 唤醒一个等待在该 Condition 上的线程
• signalAll(): 唤醒所有等待在该 Condition 上的线程

用法：

Condition 通常与 Lock 结合使用，通过 Lock 对象来创建 Condition