• 公平锁

  加锁时考虑排队等待问题，按照申请锁的顺序，按照FIFO规则，先申请的线程先取得锁，其他线程进入队列等待锁的释放，当锁释放后，在队头的线程被唤醒。

• 非公平锁

  加锁时不考虑排队等待问题，直接尝试获取锁。如果此时恰好锁处于unlock，则不管有没有其他线程在等待，直接拿到锁；否则就转化成公平锁的模式，进入队列等待。

• 两者对比

  非公平锁性能比公平锁高5~10倍，因为公平锁需要频繁唤醒队列中的线程，比较消耗资源

  公平锁保证了线程按照先后顺序执行，但效率较低。

  非公平锁效率比较高，但是非公平锁让获取锁的时间变得更加不确定，可能会导致在阻塞队列中的线程长期处于饥饿状态

• 一张很形象的图

tupian.jpg

• 验证代码

  package top.ijuer.JUC.lock;
  
  import org.junit.Test;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.List;
  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReentrantLock;
  
  public class TestReentrantLock {
      private static Lock fairLock = new ReentrantLockMine(true);
      private static Lock unfairLock = new ReentrantLockMine(false);
  
      @Test
      public void unfair() throws InterruptedException {
          testLock("非公平锁", unfairLock);
      }
  
      @Test
      public void fair() throws InterruptedException {
          testLock("公平锁", fairLock);
      }
  
      private void testLock(String type, Lock lock) throws InterruptedException {
          System.out.println(type);
          for (int i = 0; i < 5; i++) {
              Thread thread = new Thread(new Job(lock)){
                  public String toString() {
                      return getName();
                  }
              };
              thread.setName("" + i);
              thread.start();
          }
          Thread.sleep(11000);
      }
  
      private static class Job implements Runnable{
          private Lock lock;
          public Job(Lock lock) {
              this.lock = lock;
          }
  
          public void run() {
              for (int i = 0; i < 2; i++) {
                  lock.lock();
                  try {
                      Thread.sleep(1000);
                      System.out.println("获取锁的当前线程[" + Thread.currentThread().getName() + "], 同步队列中的线程" + ((ReentrantLockMine)lock).getQueuedThreads() + "");
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  } finally {
                      lock.unlock();
                  }
              }
          }
      }
  
      private static class ReentrantLockMine extends ReentrantLock {  //重新实现ReentrantLock类是为了重写getQueuedThreads方法，便于我们试验的观察
          public ReentrantLockMine(boolean fair) {
              super(fair);
          }
  
          @Override
          protected Collection<Thread> getQueuedThreads() {   //获取同步队列中的线程
              List<Thread> arrayList = new ArrayList<>(super.getQueuedThreads());
              Collections.reverse(arrayList);
              return arrayList;
          }
      }
  }
  

image-20200220002919940.png

通过结果可以证明，非公平锁在释放锁完成后会立即尝试第二次抢锁，并且因为其他线程处于挂起状态，所以第二次抢锁大概率会成功，当然只是概率比较大，并不是绝对，比如线程2第二次抢锁就没有抢过线程3，此时抢锁失败的线程2进入队列等待。

公平锁释放的时候并没有尝试去抢锁，乖乖的进入队列等待，让队列头的线程去获得这把锁。

• 拓展

  synchronized 也属于非公平锁