至少需要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();
}
}