Java - 如何修改信号量实现以使其公平

Question

我正在 Java 中使用 ReentrantLock 实现 SimpleSemaphore。

现在，我想为它添加一个公平标志，使其表现为公平\不公平信号量，如其构造函数中所定义。

这是我的 SimpleSemaphore 代码，我很高兴获得一些有关如何开始实现公平性的提示。谢谢。

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Condition;

/**
 * @class SimpleSemaphore
 *
 * @brief This class provides a simple counting semaphore
 *        implementation using Java a ReentrantLock and a
 *        ConditionObject.  It must implement both "Fair" and
 *        "NonFair" semaphore semantics, just liked Java Semaphores. 
 */
public class SimpleSemaphore {
    private int mPermits;
    private ReentrantLock lock = new ReentrantLock();
    private Condition isZero = lock.newCondition();

    /**
     * Constructor initialize the data members.  
     */
    public SimpleSemaphore (int permits,
                            boolean fair)
    { 
        mPermits = permits;
    }

    /**
     * Acquire one permit from the semaphore in a manner that can
     * be interrupted.
     */
    public void acquire() throws InterruptedException {
        lock.lock();
        while (mPermits == 0)
            isZero.await();
        mPermits--;
        lock.unlock();
    }

    /**
     * Acquire one permit from the semaphore in a manner that
     * cannot be interrupted.
     */
    public void acquireUninterruptibly() {
        lock.lock();
        while (mPermits == 0)
            try {
                isZero.await();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        mPermits--;
        lock.unlock();
    }

    /**
     * Return one permit to the semaphore.
     */
    void release() {
        lock.lock();
        try {
            mPermits++;
            isZero.signal();
        } finally {
            lock.unlock();
        }
    }
}

Answer 1

试试这个

...
    private ReentrantLock lock;
    private Condition isZero;

    public SimpleSemaphore (int permits, boolean fair) { 
        mPermits = permits;
        lock = new ReentrantLock(fair);
        isZero = lock.newCondition();
    }