Java怎么通过重写Thread类的run方法实现生产者消费者模式

正确做法：用 Runnable + 阻塞队列

业界公认的做法，是把生产者和消费者作为 Runnable 接口的实现，然后交给线程池统一调度。线程间的数据通信用 BlockingQueue（比如 ArrayBlockingQueue）来解决，阻塞等待、线程安全这些问题，队列本身全部包办了。

来看一段关键代码示例：

// 共享缓冲区
BlockingQueue queue = new ArrayBlockingQueue<>(10);

// 生产者
new Thread(() -> {
    for (int i = 0; i < 5; i++) {
        try {
            queue.put("item-" + i); // 满了自动阻塞
            System.out.println("Produced: item-" + i);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}).start();

// 消费者
new Thread(() -> {
    for (int i = 0; i < 5; i++) {
        try {
            String item = queue.take(); // 空了自动阻塞
            System.out.println("Consumed: " + item);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}).start();

这段代码逻辑清晰，耦合度低，而且不用操心同步细节——BlockingQueue 在背后做了一切。

如果非要继承 Thread（仅限教学演示）

当然，如果你只是想研究一下多线程通信的底层原理，或者应付课堂作业，用继承 Thread 也不是不可以。但有几个关键前提必须满足：共享资源必须独立于线程类，同步块必须指向同一把锁，wait/notify 一定要配对出现在 synchronized 块内部。

class SharedBuffer {
    private final List list = new ArrayList<>();
    private final int capacity = 5;

    public synchronized void produce(String item) throws InterruptedException {
        while (list.size() == capacity) wait();
        list.add(item);
        System.out.println("Produced: " + item);
        notifyAll();
    }

    public synchronized String consume() throws InterruptedException {
        while (list.isEmpty()) wait();
        String item = list.remove(0);
        System.out.println("Consumed: " + item);
        notifyAll();
        return item;
    }
}

class Producer extends Thread {
    private final SharedBuffer buffer;
    Producer(SharedBuffer b) { this.buffer = b; }
    public void run() {
        try {
            for (int i = 0; i < 5; i++) buffer.produce("P-" + i);
        } catch (InterruptedException e) { interrupt(); }
    }
}

class Consumer extends Thread {
    private final SharedBuffer buffer;
    Consumer(SharedBuffer b) { this.buffer = b; }
    public void run() {
        try {
            for (int i = 0; i < 5; i++) buffer.consume();
        } catch (InterruptedException e) { interrupt(); }
    }
}

注意，这里的核心要点是：两个子类必须共享同一个 SharedBuffer 实例，所有同步操作都围绕它展开，否则锁就会乱掉。

更现代的替代方案

如果项目是基于 Ja va 8 或更高版本，建议直接用 ExecutorService 管理线程池。配合 BlockingQueue 搞定数据同步，必要时引入 Phaser、CountDownLatch 做更复杂的协调。对于那些高并发、讲究细粒度控制的场景，ReentrantLock + Condition 组合往往比 synchronized + wait/notify 更顺手，能提供更精细的唤醒策略。总而言之，选对工具，比纠结于“能不能继承 Thread”要重要得多。