Java实现的公平锁

参考文献：http://tutorials.jenkov.com/java-concurrency/starvation-and-fairness.html

使用公平锁的原因是为了防止饥饿，导致饥饿的原因如下：

1、高优先级线程吞噬所有的低优先级线程的CPU时间（高优先级任务会获取更多的时间片）。
2、线程被永久堵塞在一个等待进入同步块的状态，因为其他线程总是能在它之前持续地对该同步块进行访问。
3、线程在等待一个本身(在其上调用wait())也处于永久等待完成的对象，因为其他线程总是被持续地获得唤醒（notify()并不能保证哪个等待线程被唤醒）。

公平锁就是让等待的线程能够公平地被唤醒，这里的实现是通过维护一个等待队列，每次只有处在队列头部的线程能够被唤醒并获得锁对象。

/*
每一个调用lock()的线程都会进入一个队列，当解锁后，只有队列里的第一个线程被允许锁住FairLock实例，
所有其它的线程都将处于等待状态，直到它们处于队列头部。
* */
public class FairLock {
    private boolean isLocked = false;
    private Thread lockingThread = null;
    private List<QueueObject> waitingThreads = new ArrayList<>();

    public void lock() throws InterruptedException {
        QueueObject queueObject = new QueueObject();//每次调用一次lock就会新建一个临时对象标记当前线程
        boolean isLockedForThisThread = true;
        synchronized (this) {
            waitingThreads.add(queueObject);
            //不管有没有获得FairLock对象锁，先将监视器压入队列。
        }

        while (isLockedForThisThread) {
            synchronized (this) {
                isLockedForThisThread = isLocked || waitingThreads.get(0) != queueObject;
                /*
                当isLockedForThisThread==false的时候，当前线程获取FairLock实例的锁，这要求两个条件：
                1、没有其它线程占用FairLock对象（isLock==false）
                2、当前线程的监视器处在队列头部（主要是为了拦截在FairLock未被占有的时候乱入的不是最先的线程）
                如果当前线程不在头部，那么主动wait()
                */
                if (!isLockedForThisThread) {//满足获取FairLock锁的条件
                    isLocked = true;//标记锁被占用
                    waitingThreads.remove(queueObject);//移除该线程的监视器
                    lockingThread = Thread.currentThread();
                    return;
                }
            }
            //如果FairLock锁已被占，或者当前线程不在队列头，那么调用监视器的doWait()等待
            try {
                queueObject.doWait();
                //如果一个线程从wait()返回，那么它必然在队列头
            } catch (InterruptedException e) {
                synchronized (this) {
                    waitingThreads.remove(queueObject);//出现异常，及时收尾
                }
                throw e;
            }
        }
    }

    public synchronized void unlock() {
        if (this.lockingThread != Thread.currentThread()) {
            throw new IllegalMonitorStateException("Calling thread has not locked this lock");
        }
        isLocked = false;
        lockingThread = null;
        if (!waitingThreads.isEmpty()) {
            waitingThreads.get(0).doNotify();
        }
    }
}

//监听器对象
class QueueObject {
    private boolean isNotified = false;

    public synchronized void doWait() throws InterruptedException {
        /*
        使用while()形式封装监听器的wait()和notify()的好处多多：
        1、防止wait()错过信号
        2、防止假唤醒(spurious wakeups)
        3、多个线程等待相同的信号
        */
        while (!isNotified) {
            this.wait();
        }
        isNotified = false;
    }

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

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