生产者消费者系统

至少需要2个以上消费者生产者生产1~10000 个数字消费者获得数字后，需要随机处理一段时间后输出数字【程序中sleep一段时间来模拟】

import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;

public class ProducerConsumer {

    private static final int MAX_QUEUE_SIZE = 100; // 队列的最大大小
    private static final int MAX_NUMBERS = 10000; // 生产的数字总数
    private static Queue<Integer> queue = new LinkedList<>(); // 共享的队列
    private static Random rand = new Random(); // 用于随机生成消费者处理数字的等待时间

    public static void main(String[] args) throws InterruptedException {
        Thread producerThread = new Thread(new Producer());
        Thread consumerThread1 = new Thread(new Consumer());
        Thread consumerThread2 = new Thread(new Consumer());

        producerThread.start();
        consumerThread1.start();
        consumerThread2.start();

        producerThread.join(); // 等待生产者线程结束
        consumerThread1.join(); // 等待消费者线程结束
        consumerThread2.join(); // 等待消费者线程结束
    }

    private static class Producer implements Runnable {
        @Override
        public void run() {
            for (int i = 1; i <= MAX_NUMBERS; i++) {
                synchronized (queue) {
                    while (queue.size() == MAX_QUEUE_SIZE) { // 等待直到队列不满
                        try {
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    queue.offer(i); // 将数字添加到队列中
                    queue.notifyAll(); // 通知消费者线程队列有新数字
                }
            }
        }
    }

    private static class Consumer implements Runnable {
        @Override
        public void run() {
            while (true) { // 消费者线程一直运行，直到生产者线程结束
                synchronized (queue) {
                    while (queue.isEmpty()) { // 等待直到队列不空
                        try {
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    int number = queue.poll(); // 从队列中取出数字
                    queue.notifyAll(); // 通知生产者线程队列有空闲空间
                    processNumber(number); // 处理数字
                }
            }
        }

        private void processNumber(int number) {
            try {
                Thread.sleep(rand.nextInt(1000)); // 模拟处理数字的等待时间
                System.out.println(number);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
 

import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class ProducerConsumerSystem {

    private static final int MAX_NUMBER = 10000;
    private static final Random RANDOM = new Random();
    private static final int MIN_PROCESSING_TIME = 100;
    private static final int MAX_PROCESSING_TIME = 500;

    private BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();

    class Producer implements Runnable {

        @Override
        public void run() {
            for (int i = 1; i <= MAX_NUMBER; i++) {
                try {
                    queue.put(i);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    return;
                }
            }
        }
    }

    class Consumer implements Runnable {

        @Override
        public void run() {
            while (true) {
                try {
                    Integer number = queue.take();
                    processNumber(number);
                } catch (InterruptedException e) {
//                    Thread.currentThread().interrupt();
//                   return ;
                }
            }
        }

        private void processNumber(Integer number) throws InterruptedException {
            int processingTime = RANDOM.nextInt(MAX_PROCESSING_TIME - MIN_PROCESSING_TIME) + MIN_PROCESSING_TIME;
            Thread.sleep(processingTime);
            System.out.println(number);
        }
    }

    public void run() {
        Thread producerThread = new Thread(new Producer());
        producerThread.start();

        Thread consumerThread1 = new Thread(new Consumer());
        Thread consumerThread2 = new Thread(new Consumer());
        consumerThread1.start();
        consumerThread2.start();

        try {
            producerThread.join();
            consumerThread1.interrupt();
            consumerThread2.interrupt();
            consumerThread1.join();
            consumerThread2.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return;
        }
    }

    public static void main(String[] args) {
        new ProducerConsumerSystem().run();

    }
}