Java并发编程-自己实现一个公平锁

1.公平锁的公平性是依赖等待队列实现的，当一个线程释放锁后，会唤醒等待队列中的第一个线程。下面是一个可重入的公平锁实现：

public class FairLock {
    private boolean isLocked = false;
    private Thread lockingThread = null;
    // 等待队列
    private List<QueueObject> waitingThreads = new ArrayList<>();

    public synchronized void lock() throws InterruptedException {
        QueueObject queueObject = new QueueObject();
        boolean isLockedForThisThread = true;
        synchronized (this) {
            waitingThreads.add(queueObject);
        }

        while (isLockedForThisThread) {
            synchronized (this) {
                isLockedForThisThread = isLocked || waitingThreads.get(0) != queueObject;
                if (!isLockedForThisThread) {
                    isLocked = true;
                    waitingThreads.remove(queueObject);
                    lockingThread = Thread.currentThread();
                    return;
                }
            }

            try {
                queueObject.doWait();
            } catch (InterruptedException e) {
                synchronized (this) {
                    waitingThreads.remove(queueObject);
                }
                throw e;
            }
        }
    }

    public synchronized void unlock() {
        if (this.lockingThread != Thread.currentThread()) {
            throw new IllegalMonitorStateException("Calling threads has not locked this lock");
        }
        isLocked = false;
        lockingThread = null;
        if (waitingThreads.size() > 0) {
            // 每次唤醒等待队列中的第一个线程
            waitingThreads.get(0).doNotify();
        }
    }

}

public class QueueObject {

    private boolean isNotified = false;

    public synchronized void doWait() throws InterruptedException {
        while (!isNotified) {
            this.wait();
        }

        this.isNotified = false;
    }

    public synchronized void doNotify() {
        this.isNotified = true;
        this.notify();
    }

    public boolean equals(Object obj) {
        return this == obj;
    }
}