[Java 并发编程] 17. 饥饿与公平

---

前言

一个线程没有获取到CPU时间片，因为CPU时间片总是被其他线程获取，这种情况我们叫它“饥饿”。线程被“饿死”是因为没有获取CPU时间片执行指令。解决“饥饿”的办法成为“公平” —— 所有的线程公平的获取CPU时间片执行指令。

---

一、Java 中常见饥饿的场景

• 具有高优先性的线程比低优先性的线程更容易获取CPU时间片。
• 线程无限期阻塞等待进入synchronized代码块，因为其他线程在不断地被允许访问synchronized代码块。
• 线程调用了wait方法，一直未被唤醒，因为总有其他的线程被唤醒（调用notify方法），而不是它。

1.1 高优先性的线程比低优先性的线程更容易获取CPU时间片

你可以通过setPriority()方法（Thread类的方法，取值范围是[1-10]）设置每个线程的优先级。具有高优先性的线程比低优先性的线程更容易获取CPU时间片，具体怎么执行依赖于我们的操作系统。

1.2 线程无限期阻塞等待进入synchronized代码块

Java synchronized 代码块不保证线程按照等待进入synchronized代码块的顺序进入synchronized代码块，首先等待进入synchronized代码块的线程不一定先进入synchronized代码快。这就意味着系统可能存在某些线程无限期的等待进入synchronized代码块的风险，因为其他线程在不断的访问它。

1.3 线程调用了wait方法，一直未被唤醒

我们都知道wait()、notify()、notifyAll() 方法用于线程通信。在多个等待线程调用了wait()方法时，某个唤醒线程调用了notify() 方法会唤醒某个等待线程，但它不保证某个线程一定会被唤醒，它唤醒的是等待线程中的任意一个线程。因此当多个线程调用了wait方法，其中某些线程可能一直处于等待状态，因为总有线程被唤醒，而不是它们。

---

二、Java 中实现公平

尽管Java中不可能百分之百实现公平，但我们可以实现我们的同步机制来提高不同线程之间的公平性。

示例：synchronized 代码块

public class Synchronizer{

  public synchronized void doSynchronized(){
    //do a lot of work which takes a long time
  }

}

如果多个线程调用doSynchronized()方法，只有一个线程能够进入该方法，其他线程会造成阻塞直到进入doSynchronized()方法的线程退出。如果多个线程被阻塞，当某个线程退出synchronized代码块后，不确定下一次进入synchronized代码块的线程是哪个线程。

2.1 使用Lock代替synchronized代码块

为了提高等待线程进入同步代码块的公平性，通过自定义的Lock代替synchronized代码块。

public class Synchronizer{

    Lock lock = new Lock();

    public synchronized void doSynchronized() throws InterruptedException {
        lock.lock();

        //do something

        lock.unLock();
    }

}

请注意doSynchronized()方法没有使用synchronized关键字声明，取而代之的是Lock类的lock()和unLock()方法，Lock类的实现可以是下面这种方式（也可以使用juc包下的Lock，这里先尝试自己实现Lock）。

/**
 * @author : sungm
 * @date : 2020-09-01 16:21
 */
public class Lock {
    
    private boolean hasLock = false;
    private Thread lockThread = null;
    
    private synchronized void lock() throws InterruptedException {
        if (hasLock) {
            wait();
        }
        hasLock = true;
        lockThread = Thread.currentThread();
    }
    
    private synchronized void unLock() {
        if (lockThread != Thread.currentThread()) {
            throw new IllegalMonitorStateException("Calling thread is not lock thread.");
        }
        
        hasLock = false;
        lockThread = null;
        notify();
    }
    
}

请仔细看Lock类的实现，你会发现当多个线程访问lock()方法时会造成阻塞，因为它使用了synchronized关键字。如果锁已经被锁定，其他线程调用lock方法进入无效状态（调用了wait方法），锁的每次释放，都将唤醒一个wait状态的线程(unLock方法里面调用了notify方法)。

之前我们提到过，当多个线程同时调用synchronized代码块会造成阻塞，synchronized关键字不会确保线程按顺序进入synchronized代码块。同样，当多个线程调用了wait方法，某个唤醒线程调用notify方法不能唤醒某个指定的等待线程。因此上面的示例是不是一个公平的锁，但是我们可以对它做修改，实现一个公平锁。

公平锁： 可参考 java.util.concurrent.locks.ReentrantLock 类中的内部类 FairSync 同步锁。