Java：使用BlockingQueue的生产者/消费者：使用消费者线程wait（）直到另一个对象排队(Java: Producer/Consumer using BlockingQueue: having the consumer thread wait() until another object is queued)

 我最近遇到了一些线程相关的问题，消费者需要积分。 这是原始的，除了占用大量的cpu不断检查队列之外，它工作正常。 这个想法是可以随便调用cuePoint并且主线程继续运行。 
 
import java.util.List;
import java.util.ArrayList;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;


public class PointConsumer implements Runnable {
    public static final int MAX_QUEUE_SIZE=500;

    BlockingQueue<Point> queue;

    public PointConsumer (){
        this.queue=new ArrayBlockingQueue<Point>(MAX_QUEUE_SIZE);
    }

     public void cuePoint(Point p){
        try{
            this.queue.add(p);
        }
        catch(java.lang.IllegalStateException i){}
    }
     public void doFirstPoint(){
        if(queue.size()!=0){
            Point p=queue.poll();
            //operation with p that will take a while
        }
    }

    public void run() {
        while(true){
                  doFirstPoint();
        }
    }

}
 
 我试图通过每次调用cue函数时添加notify（）来修复cpu问题，并将doFirstPoint（）重新处理为这样的事情： 
 
public void doFirstPoint(){

    if(queue.size()!=0){
            //operation with p that will take a while
    }
    else{
        try{
            wait();
        }
        catch(InterruptedException ie){}
    }
}
 
 但是，我发现notify（）和wait（）仅适用于同步函数。 当我使doFirstPoint和cuePoint同步时，调用cuePoint的主线程将保持等待状态。 
 
 我有一些想法来解决这个问题，包括将线程作为一个对象并直接通知它，但我不确定这是否会导致比修复更多的问题，是非常糟糕的形式，还是根本无法工作。 我错过了这个问题的简单解决方案吗？ 

I've been having some thread related problems recently with a consumer that takes points. Here is the original, which works fine except for taking up a lot of cpu constantly checking the queue. The idea is that cuePoint can be called casually and the main thread keeps going.
 
import java.util.List;
import java.util.ArrayList;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;


public class PointConsumer implements Runnable {
    public static final int MAX_QUEUE_SIZE=500;

    BlockingQueue<Point> queue;

    public PointConsumer (){
        this.queue=new ArrayBlockingQueue<Point>(MAX_QUEUE_SIZE);
    }

     public void cuePoint(Point p){
        try{
            this.queue.add(p);
        }
        catch(java.lang.IllegalStateException i){}
    }
     public void doFirstPoint(){
        if(queue.size()!=0){
            Point p=queue.poll();
            //operation with p that will take a while
        }
    }

    public void run() {
        while(true){
                  doFirstPoint();
        }
    }

}
 
I tried to fix the cpu issue by adding notify() every time the cue function is called, and re-working doFirstPoint() to something like this:
 
public void doFirstPoint(){

    if(queue.size()!=0){
            //operation with p that will take a while
    }
    else{
        try{
            wait();
        }
        catch(InterruptedException ie){}
    }
}
 
However, I found out that notify() and wait() only work in synchronized functions. When I make doFirstPoint and cuePoint synchronized, the main thread which has called cuePoint will be kept waiting.
 
I had a few ideas to get around this, including making the thread an object and having it be directly notified, but I wasn't sure if that would cause more problems than it would fix, be very bad form, or simply not work. Is there a simple solution to this problem that I'm missing?

原文：https://stackoverflow.com/questions/5252141