面试被问ReentrantLock的公平锁与非公平锁，区别…

2020-05-12 16:09:10来源：博客园阅读 ()

面试被问ReentrantLock的公平锁与非公平锁，区别以及实现

面试被问ReentrantLock的公平锁与非公平锁的区别以及实现。

案例

public class LockDemo {
   public static void main(String[] args) {
       Lock lock = new ReentrantLock();
       try {
           lock.lock();
           System.out.println("获得锁");
      } finally {
           lock.unlock();
           System.out.println("释放锁");
      }
  }
}

运行结果

先看ReentrantLock的构造方法源码：

private final Sync sync;
public ReentrantLock() {
    sync = new NonfairSync();
}

所以，记住默认是非公平锁，有在new 的时候参数为true的时候才变成了公平锁。

再看Sync是个什么东东

abstract static class Sync extends AbstractQueuedSynchronizer {
}

可以看出这个是继承于AQS的一个静态抽象内部类。有两个子类

这两个类也就是我们所说的公平锁与非公平锁。

还可以通过手动设置公平锁与非公平锁

public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

FairSync公平锁

static final class FairSync extends Sync {
       private static final long serialVersionUID =-3000897897090466540L;

       final void lock() {
           acquire(1);
      }       //尝试直接获取锁，返回值是boolean，代表是否获取到锁       //返回true：        //1.没有线程在等待锁；        //2.重入锁，线程本来就持有锁，也就可以理所当然可以直接获取       protected final boolean tryAcquire(int acquires) {
           final Thread current = Thread.currentThread();
           int c = getState();
           if (c == 0) {
               //关键点
               if (!hasQueuedPredecessors() &&
                   compareAndSetState(0, acquires)) {
                   setExclusiveOwnerThread(current);
                   return true;
              }
          }
           //判断是有锁的线程是否为当前线程。
           //可重入就在这里体现的，同一个线程多次调用lock方法
           else if (current == getExclusiveOwnerThread()) {
               int nextc = c + acquires;
               if (nextc < 0)
                   throw new Error("Maximum lock count exceeded");
               setState(nextc);
               return true;
          }
           return false;
      }
  }

hasQueuedPredecessors()判断队列是否还有别的线程在等待锁，没有的话就尝试获取lock 。

compareAndSetState(0, acquires)尝试获取锁

NonfairSync非公平锁

static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;

    /**
     * Performs lock. Try immediate barge, backing up to normal
     * acquire on failure.
     */
    final void lock() {
        //不管AQS队列有没有等待的线程，直接开始抢
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
           acquire(1);
    }

    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

compareAndSetState(0, 1)首先用一个CAS操作，判断state是否是0（表示当前锁未被占用），如果是0则把它置为1，并且

setExclusiveOwnerThread(Thread.currentThread());

设置当前线程为该锁的独占线程，表示获取锁成功。当多个线程同时尝试占用同一个锁时，CAS操作只能保证一个线程操作成功，剩下的只能乖乖的去排队啦。

总结

公平锁和非公平锁只有两处不同：

非公平锁在调用 lock 后，首先就会调用 CAS 进行一次抢锁，如果这个时候恰巧锁没有被占用，那么直接就获取到锁返回了。
非公平锁在 CAS 失败后，和公平锁一样都会进入到 tryAcquire 方法，在 tryAcquire 方法中，如果发现锁这个时候被释放了（state == 0），非公平锁会直接 CAS 抢锁，但是公平锁会判断等待队列是否有线程处于等待状态，如果有则不去抢锁，乖乖排到后面。

公平锁和非公平锁就这两点区别，如果这两次 CAS 都不成功，那么后面非公平锁和公平锁是一样的，都要进入到阻塞队列等待唤醒。

相对来说，非公平锁会有更好的性能，因为它的吞吐量比较大。当然，非公平锁让获取锁的时间变得更加不确定，可能会导致在阻塞队列中的线程长期处于饥饿状态。

最后这里小编整理了一套面试资料，让你面试不慌张