Question

我有一个线程生成器，它创建了一些任务对象，然后将它们添加到ArrayBlockingQueue（具有固定大小）。

我也开始了一个多线程的消费者。这是一个固定的线程池（Executors.newFixedThreadPool(threadCount);）。然后我向这个threadPool提交了一些ConsumerWorker入口，每个ConsumerWorker都对上面提到的ArrayBlockingQueue实例进行了引用。

每个此类工作人员将在队列中执行take()并处理该任务。

我的问题是，当没有更多的工作要做时，让工人知道的最佳方法是什么。换句话说，我如何告诉Workers，生产者已经完成了对队列的添加，从这一点开始，每个工作人员在看到Queue为空时应该停止。

我现在得到的是一个设置，其中我的Producer初始化了一个回调，当他完成它的工作（向队列中添加东西）时会触发回调。我还保留了我创建并提交给ThreadPool的所有ConsumerWorkers的列表。当Producer Callback告诉我生产者已完成时，我可以告诉每个工人。此时，他们应该只是继续检查队列是否为空，当它变为空时它们应该停止，从而允许我优雅地关闭ExecutorService线程池。就像这样

public class ConsumerWorker implements Runnable{

private BlockingQueue<Produced> inputQueue;
private volatile boolean isRunning = true;

public ConsumerWorker(BlockingQueue<Produced> inputQueue) {
    this.inputQueue = inputQueue;
}

@Override
public void run() {
    //worker loop keeps taking en element from the queue as long as the producer is still running or as 
    //long as the queue is not empty:
    while(isRunning || !inputQueue.isEmpty()) {
        System.out.println("Consumer "+Thread.currentThread().getName()+" START");
        try {
            Object queueElement = inputQueue.take();
            //process queueElement
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

//this is used to signal from the main thread that he producer has finished adding stuff to the queue
public void setRunning(boolean isRunning) {
    this.isRunning = isRunning;
}

}

这里的问题是我有一个明显的竞争条件，有时生产者会完成，发出信号，消费者工作者会在消耗队列中的所有东西之前停止。

我的问题是同步这个的最佳方法是什么，以便一切正常？我是否应该同步整个部分来检查生产者是否正在运行加上如果队列是空的加上从队列中取出一些块（在队列对象上）？我应该只在ConsumerWorker实例上同步isRunning布尔值的更新吗？还有其他建议吗？

更新，这是我最终使用的工作实施：

public class ConsumerWorker implements Runnable{

private BlockingQueue<Produced> inputQueue;

private final static Produced POISON = new Produced(-1); 

public ConsumerWorker(BlockingQueue<Produced> inputQueue) {
    this.inputQueue = inputQueue;
}

@Override
public void run() {
    //worker loop keeps taking en element from the queue as long as the producer is still running or as 
    //long as the queue is not empty:
    while(true) {
        System.out.println("Consumer "+Thread.currentThread().getName()+" START");
        try {
            Produced queueElement = inputQueue.take();
            Thread.sleep(new Random().nextInt(100));
            if(queueElement==POISON) {
                break;
            }
            //process queueElement
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("Consumer "+Thread.currentThread().getName()+" END");
    }
}

//this is used to signal from the main thread that he producer has finished adding stuff to the queue
public void stopRunning() {
    try {
        inputQueue.put(POISON);
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

}

这很大程度上受到了JohnVint在下面的回答的启发，只有一些小修改。

===由于@ vendhan的评论而更新。

感谢您的观察。你是对的，这个问题的第一个代码片段（以及其他问题）是while(isRunning || !inputQueue.isEmpty())没有意义的那个。

在我实际的最终实现中，我做了一些更接近你更换“||”的建议。（或）与“＆amp;＆amp;” （和），从某种意义上说，每个工人（消费者）现在只检查他从列表中获得的元素是否是毒丸，如果是这样的话（理论上我们可以说工人必须运行而且队列必须不是空的。）

Answer 1

您应该从队列中继续take()。你可以使用毒丸告诉工人停止。例如：

private final Object POISON_PILL = new Object();

@Override
public void run() {
    //worker loop keeps taking en element from the queue as long as the producer is still running or as 
    //long as the queue is not empty:
    while(isRunning) {
        System.out.println("Consumer "+Thread.currentThread().getName()+" START");
        try {
            Object queueElement = inputQueue.take();
            if(queueElement == POISON_PILL) {
                 inputQueue.add(POISON_PILL);//notify other threads to stop
                 return;
            }
            //process queueElement
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

//this is used to signal from the main thread that he producer has finished adding stuff to the queue
public void finish() {
    //you can also clear here if you wanted
    isRunning = false;
    inputQueue.add(POISON_PILL);
}

Answer 2

我会向工人发送一份特殊的工作包，以表明他们应该关闭：

public class ConsumerWorker implements Runnable{

private static final Produced DONE = new Produced();

private BlockingQueue<Produced> inputQueue;

public ConsumerWorker(BlockingQueue<Produced> inputQueue) {
    this.inputQueue = inputQueue;
}

@Override
public void run() {
    for (;;) {
        try {
            Produced item = inputQueue.take();
            if (item == DONE) {
                inputQueue.add(item); // keep in the queue so all workers stop
                break;
            }
            // process `item`
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

}

要停止工作人员，只需将ConsumerWorker.DONE添加到队列中即可。

Answer 3

在您尝试从队列中检索元素的代码块中，使用poll(time,unit)代替take()。

try { 
    Object queueElement = inputQueue.poll(timeout,unit);
     //process queueElement        
 } catch (InterruptedException e) {
        if(!isRunning && queue.isEmpty())
         return ; 
 }

通过指定适当的超时值，确保线程不会阻塞，以防有一个不幸的序列

isRunning是真的
队列变空，因此线程进入阻塞等待（如果使用take()
isRunning设置为false

Answer 4

我们不能使用CountDownLatch来做，其中size是生产者中的记录数。每个消费者在处理完记录后都会countDown。当所有任务完成时，它会越过awaits()方法。然后停止所有你的消费者。随着所有记录的处理。

Answer 5

您可以使用许多策略，但一个简单的策略是使用任务的子类来表示作业的结束。制作人不直接发送此信号。相反，它将此任务子类的实例排入队列。当你的一个消费者完成这项任务并执行它时，会导致信号被发送。

Answer 6

我不得不使用多线程生产者和多线程消费者。我最终得到了一个Scheduler -- N Producers -- M Consumers方案，每个方案通过队列进行通信（总共两个队列）。调度程序使用生成数据的请求填充第一个队列，然后用N“毒丸”填充它。有一个活跃的生产者计数器（原子int），最后一个接收最后一个毒丸的生产者将M毒丸送到消费者队列。

阻塞队列和多线程消费者，如何知道何时停止

6 个答案: