正在从线程中运行的方法引发java.lang.IllegalMonitorStateException

我正在尝试使用以下方法创建基本的生产者/消费者类：

public class ProducerConsumer {
    private final static int MAX_SIZE = 100;
    private Queue<String> data = new PriorityQueue<>();
    private Lock lock = new ReentrantLock();
    private Condition bufferFull = lock.newCondition();
    private Condition bufferEmpty = lock.newCondition();

    public void produce(){
        while(true) {
            try {
                lock.lock();
                while (data.size() >= MAX_SIZE) {
                    bufferFull.await();
                }
                addData();
                bufferEmpty.notifyAll();
            } catch (InterruptedException e) {
                System.out.println("error produce");
            } finally {
                lock.unlock();
            }
        }
    }
    public void consume(){
        while(true) {
            try {
                lock.lock();
                while (data.isEmpty()) {
                    bufferEmpty.await();
                }
                String value = data.poll();
                System.out.println("Thread " + Thread.currentThread().getName() + " processing value " + value);
                bufferFull.notifyAll();
            } catch (InterruptedException e) {
                System.out.println("error consume");
            } finally {
                lock.unlock();
            }
        }
    }

    private void addData(){
        IntStream.range(0,10).forEach( i ->
                data.add(new Date().toString())
        );
    }

    public void start(int consumerNumber){
        IntStream.range(0,consumerNumber)
                .mapToObj(i -> new Thread(this::consume))
                .collect(Collectors.toList())
                .forEach(Thread::start);

        Thread t = new Thread(this::produce);
        t.start();
    }

} 

公共类生产者消费者{
私有最终静态int MAX_SIZE=100；
专用队列数据=新的优先级队列（）；
private Lock=new ReentrantLock（）；
private Condition bufferFull=lock.newCondition（）；
私有条件bufferEmpty=lock.newCondition（）；
公共产品{
while（true）{
试一试{
lock.lock（）；
while（data.size（）>=最大大小）{
bufferFull.wait（）；
}
addData（）；
bufferEmpty.notifyAll（）；
}捕捉（中断异常e）{
System.out.println（“错误生成”）；
}最后{
lock.unlock（）；
}
}
}
公共消费（）{
while（true）{
试一试{
lock.lock（）；
while（data.isEmpty（））{
bufferEmpty.await（）；
}
字符串值=data.poll（）；
System.out.println（“线程”+线程.currentThread（）.getName（）+“处理值”+值）；
bufferFull.notifyAll（）；
}捕捉（中断异常e）{
System.out.println（“错误消耗”）；
}最后{
lock.unlock（）；
}
}
}
私有void addData（）{
IntStream.range（0,10）.forEach（i->
data.add（新日期（）.toString（））
);
}
公共无效开始（int consumerNumber）{
IntStream.range（0，消费者编号）
.mapToObj（i->新线程（this:：consume））
.collect（收集器.toList（））
.forEach（线程：：开始）；
螺纹t=新螺纹（此：：生产）；
t、 start（）；
}
} 

但是，它不断抛出错误：java.lang.IllegalMonitorStateException。我的问题是，为什么它会抛出这个错误？这个intance的方法是在线程中运行的，所以它们应该拥有条件锁，所以我不理解这个错误背后的含义

---

谢谢你的帮助

bufferEmpty.notifyAll（）

是错误的调用方法。该方法要求您将监视器保持在“bufferEmpty”对象本身上，该对象与您正在使用的

lock

实例无关

正确的调用方法是

bufferEmpty.signalAll();

---

是吗？“抛出表示线程试图在对象的监视器上等待，或通知在对象监视器上等待的其他线程而不拥有指定的监视器。”是的，但我不确定这是什么意思，own as thread locked the condition/lock？@AndyTurner根据我的锁定方式应该是正确的，但引发异常