通过使用Semaphore和AtomicBoolean实现了一个名为BinarySemaphore的类，用于在Java中处理多生产者和单消费者的问题。消费者在一个循环中不断检查工作，并在没有任务时等待信号。Producer类提供signalSomethingToDo()方法来通知有工作可用。BinarySemaphore类确保了资源的正确同步和释放。
我按照@Abe所建议的方式解决了类似的情况，但决定使用 Semaphore 与 AtomicBoolean 组合并将其称为BinarySemaphore . 它确实需要对 生产环境 者进行修改，以便在有事情要做时发出信号 .
在BinarySemaphore的代码下面，以及消费者工作循环应该是什么样子的一般概念：
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
public class MultipleProdOneConsumer {
BinarySemaphore workAvailable = new BinarySemaphore();
class Consumer {
volatile boolean stop;
void loop() {
while (!stop) {
doWork();
if (!workAvailable.tryAcquire()) {
// waiting for work
try {
workAvailable.acquire();
} catch (InterruptedException e) {
if (!stop) {
// log error
}
}
}
}
}
void doWork() {}
void stopWork() {
stop = true;
workAvailable.release();
}
}
class Producer {
/* Must be called after work is added to the queue/made available. */
void signalSomethingToDo() {
workAvailable.release();
}
}
class BinarySemaphore {
private final AtomicBoolean havePermit = new AtomicBoolean();
private final Semaphore sync;
public BinarySemaphore() {
this(false);
}
public BinarySemaphore(boolean fair) {
sync = new Semaphore(0, fair);
}
public boolean release() {
boolean released = havePermit.compareAndSet(false, true);
if (released) {
sync.release();
}
return released;
}
public boolean tryAcquire() {
boolean acquired = sync.tryAcquire();
if (acquired) {
havePermit.set(false);
}
return acquired;
}
public boolean tryAcquire(long timeout, TimeUnit tunit) throws InterruptedException {
boolean acquired = sync.tryAcquire(timeout, tunit);
if (acquired) {
havePermit.set(false);
}
return acquired;
}
public void acquire() throws InterruptedException {
sync.acquire();
havePermit.set(false);
}
public void acquireUninterruptibly() {
sync.acquireUninterruptibly();
havePermit.set(false);
}
}
}
扫一扫
4186
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
