Java多线程求助：如何实现两线程交替计数至各自随机上限

现有代码问题 #

• 无共享状态感知：两个线程的计数上限和运行状态都是私有的，其中一个线程达到上限退出后，另一个线程会永久阻塞在wait()，没有线程唤醒它。
• 输出不符合要求：没有标记线程名称，计数从0开始输出，和预期从1开始的规则不符。
• 缺少单线程运行逻辑：其中一个线程停止后，剩下的线程不需要继续交替等待，应该直接跑完剩余计数。

可运行实现代码 #

import java.util.Random;

public class AlternateCount {
    // 共享锁对象
    private static final Object sync = new Object();
    // 两个线程的计数上限、运行完成标记，设为共享变量
    private static int maxA, maxB;
    private static boolean aFinished = false, bFinished = false;

    static class CountThread extends Thread {
        private final String threadFlag;

        public CountThread(String threadFlag) {
            this.threadFlag = threadFlag;
        }

        @Override
        public void run() {
            // 生成1-20的随机计数上限，存入共享变量
            int threadMax = new Random().nextInt(20) + 1;
            if ("A".equals(threadFlag)) {
                maxA = threadMax;
            } else {
                maxB = threadMax;
            }

            for (int i = 1; i <= threadMax; i++) {
                synchronized (sync) {
                    // 先唤醒另一个处于等待状态的线程
                    sync.notify();
                    // 按要求格式输出
                    System.out.printf("Thread %s:%d%n", threadFlag, i);
                    // 仅当另一个线程还在运行，且当前不是最后一次计数时，才进入等待
                    boolean isOtherRunning = "A".equals(threadFlag) ? !bFinished : !aFinished;
                    if (isOtherRunning && i != threadMax) {
                        try {
                            sync.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
            // 标记当前线程运行完成，最后唤醒一次避免另一个线程仍处于等待状态
            synchronized (sync) {
                if ("A".equals(threadFlag)) {
                    aFinished = true;
                } else {
                    bFinished = true;
                }
                sync.notify();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new CountThread("A").start();
        // 加10ms延迟保证线程A优先执行，稳定输出顺序
        Thread.sleep(10);
        new CountThread("B").start();
    }
}

效果验证 #

你举的示例中应该是写反了两个线程的上限，将代码中线程A的上限设为7、线程B的上限设为4运行，即可完全复现你给出的预期输出。

内容的提问来源于stack exchange，提问作者d0nahuge