关于java生产者、消费者的问题

[Blck宋]

今天写生产者、消费者的实例遇到一个问题，不知道有没有懂得，帮忙看一下，不胜感激。
贴一下代码
生产者：

package com.core.producer.cusotmer;

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

public class Producer extends Thread {
	private int MaxSize;
	private Queue<Integer> queue;

	public Producer(int maxSize, Queue<Integer> queue) {
		MaxSize = maxSize;
		this.queue = queue;
	}

	@Override
	public void run() {
		synchronized (queue) {
			while (queue.size() < MaxSize) {
				int value = new Random().nextInt();
				System.out.println("生产者开始生产数据了:" + value);
				queue.add(value);
				
			}
			queue.notifyAll();
			try {
				queue.wait();
			} catch (InterruptedException e1) {
				e1.printStackTrace();
			}
		}
	}
}

消费者：

package com.core.producer.cusotmer;

import java.util.Queue;

public class Customer extends Thread {
	private int MaxSize;
	private Queue<Integer> queue;

	public Customer(int maxSize, Queue<Integer> queue) {
		MaxSize = maxSize;
		this.queue = queue;
	}

	@Override
	public void run() {
		synchronized (queue) {
			while(queue!=null&&queue.size()>0){
				System.out.println("--------消费者开始消费数据："+queue.remove());
			}
			queue.notifyAll();
			try {
				queue.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

测试：

package com.core.producer.cusotmer;

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

public class Test {
	public static void main(String[] args) throws InterruptedException {
		int Max = 3;
		Queue<Integer> queue = new LinkedList<>();
		Producer producer = new Producer(Max, queue);
		Customer customer = new Customer(Max, queue);
		producer.start();
		customer.start();
	}
}

问题是：按照如上代码运行的话，只运行一次就结束。
如图：


但是，如果把生产者、消费者代码中：

queue.notifyAll();
			try {
				queue.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

这些代码移到while循环内部，就能一直运行，但是每次都是生产者生产一个、消费者就消费一个。如图

这样也不符合设计初衷，我是想生产者每次生产一个集合，然后消费者消费一个集合。,不知道有没有大牛能解答一下我的困惑。

[Blck宋]

引用 2 楼 soton_dolphin 的回复:

public class Producer extends Thread {
    private int MaxSize;
    private Queue<Integer> queue;
 
    public Producer(int maxSize, Queue<Integer> queue) {
        MaxSize = maxSize;
        this.queue = queue;
    }
 
    @Override
    public void run() {
        synchronized (queue) {
            while(true){
                if(queue.size() = MaxSize) {
                    queue.wait();
                }

                int value = new Random().nextInt();
                System.out.println("生产者开始生产数据了:" + value);
                queue.add(value);
                queue.notifyAll();
                try {
                    
                } catch (InterruptedException e1) {
                    e1.printStackTrace();
                }
            }
        }
    }
}

改了producer， 体会一下

恩恩，懂了谢谢，需要在生产者、消费者synchronized 模块中添加while(true)循环，保持一直这个线程一直在运行

[lyn584238910]

你想要的是什么效果

[soton_dolphin]

public class Producer extends Thread {
    private int MaxSize;
    private Queue<Integer> queue;
 
    public Producer(int maxSize, Queue<Integer> queue) {
        MaxSize = maxSize;
        this.queue = queue;
    }
 
    @Override
    public void run() {
        synchronized (queue) {
            while(true){
                if(queue.size() = MaxSize) {
                    queue.wait();
                }

                int value = new Random().nextInt();
                System.out.println("生产者开始生产数据了:" + value);
                queue.add(value);
                queue.notifyAll();
                try {
                    
                } catch (InterruptedException e1) {
                    e1.printStackTrace();
                }
            }
        }
    }
}

改了producer， 体会一下

[lyn584238910]

引用 2 楼 soton_dolphin 的回复:

public class Producer extends Thread {
    private int MaxSize;
    private Queue<Integer> queue;
 
    public Producer(int maxSize, Queue<Integer> queue) {
        MaxSize = maxSize;
        this.queue = queue;
    }
 
    @Override
    public void run() {
        synchronized (queue) {
            while(true){
                if(queue.size() = MaxSize) {
                    queue.wait();
                }

                int value = new Random().nextInt();
                System.out.println("生产者开始生产数据了:" + value);
                queue.add(value);
                queue.notifyAll();
                try {
                    
                } catch (InterruptedException e1) {
                    e1.printStackTrace();
                }
            }
        }
    }
}

改了producer， 体会一下

结果没啥区别吧···求解