Java多线程同步求助：按间隔打印字符及线程调度实现

首先，你的代码存在几个关键问题导致无法实现需求：

1. 线程启动错误：调用run()只是执行普通方法，不会创建新线程，必须用start()。
2. 同步锁无效：synchronized(this)锁的是每个线程实例自己，多个线程的锁互不干扰，根本起不到同步共享变量的作用。
3. 逻辑位置错误：把打印、休眠逻辑写在构造函数里，构造函数执行时线程还没启动，完全不是多线程执行的逻辑。
4. 变量不共享：internal等是实例变量，每个线程各自持有，自然无法协同累加。
5. 未处理线程依赖：没有实现第四个线程等待前三个任意一个结束再启动的逻辑。

下面是修正后的完整代码，完全符合你的需求：

共享计数器（保证线程安全） #

用单独的类封装共享计数变量，通过同步方法保证累加操作的原子性：

class SharedCounter {
    private int count = 0;

    public synchronized int incrementAndGet() {
        return ++count;
    }

    public synchronized int getCount() {
        return count;
    }
}

打印线程类 #

重写run()方法，把业务逻辑放在这里，通过构造函数传入参数和共享计数器：

class PrinterThread extends Thread {
    private final String letter;
    private final int printTimes;
    private final long intervalMs;
    private final SharedCounter counter;

    public PrinterThread(String letter, int printTimes, long intervalMs, SharedCounter counter) {
        this.letter = letter;
        this.printTimes = printTimes;
        this.intervalMs = intervalMs;
        this.counter = counter;
    }

    @Override
    public void run() {
        try {
            for (int i = 0; i < printTimes; i++) {
                // 同步System.out避免输出乱序
                synchronized (System.out) {
                    int currentCount = counter.incrementAndGet();
                    System.out.printf("第%d次打印: %s%n", currentCount, letter);
                }
                Thread.sleep(intervalMs);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.err.println("线程[" + getName() + "]被中断");
        }
    }
}

主程序（实现线程依赖） #

启动前三个线程，监听它们的状态，任意一个结束后启动第四个线程：

public class Main {
    public static void main(String[] args) {
        SharedCounter counter = new SharedCounter();
        // 初始化前三个线程：字符、打印次数、间隔毫秒
        PrinterThread t1 = new PrinterThread("A", 10, 100, counter);
        PrinterThread t2 = new PrinterThread("B", 10, 100, counter);
        PrinterThread t3 = new PrinterThread("C", 10, 100, counter);
        PrinterThread t4 = new PrinterThread("D", 10, 100, counter);

        // 启动前三个线程
        t1.start();
        t2.start();
        t3.start();

        // 等待任意一个前序线程结束后启动t4
        while (true) {
            if (!t1.isAlive() || !t2.isAlive() || !t3.isAlive()) {
                t4.start();
                break;
            }
            // 避免空轮询占用CPU
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            }
        }

        // 等待所有线程执行完毕
        try {
            t1.join();
            t2.join();
            t3.join();
            t4.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

关键说明 #

• 共享变量同步：用SharedCounter的同步方法保证计数累加的原子性，避免多线程竞争导致的计数错误。
• 输出同步：对System.out加锁，防止多个线程同时打印导致的输出混乱。
• 线程依赖实现：通过循环监听线程存活状态，一旦前三个中有一个结束，立即启动第四个线程，短休眠避免空轮询。
• 中断处理：正确处理线程中断，恢复中断状态，保证线程可以优雅终止。

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