ReentrantLock公平和非公平的区别

ReentrantLock和Synchronized都提供了同步功能，但ReentrantLock与Synchronized相比，更加灵活，提供了以下几个独有的功能：

1.ReenTrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获锁。
2.ReenTrantLock提供了一个Condition（条件）类，用来实现分组唤醒需要唤醒的线程们，而不是像synchronized要么随机醒一个线程要么唤醒全部线程。
3.ReenTrantLock提供了一种能够中断等待锁的线程的机制，通过lock.lockInterruptibly()来实现这个机制。

Synchronized只能是非公平锁
ReenTrantLock默认是非公平锁，但是可以通过构造方法传参true来创建公平锁

下面讲讲公平和非公平到底是什么东西：

public class FairLock implements Runnable{
  public static ReentrantLock lock = new ReentrantLock(true);
   @Override
   public void run() {
       while (true) {
           try {
               lock.lock();
               System.err.println(Thread.currentThread().getName() + "获取到了锁！");
           } finally {
               lock.unlock();
           }
       }
   }
   public static void main(String[] args) throws InterruptedException {
       FairLock test = new FairLock();
       Thread t1 = new Thread(test, "线程1");
       Thread t2 = new Thread(test, "线程2");
       t1.start();t2.start();
   }
}

image.png

公平锁与非公平锁的一个重要区别就在于上图中的2、6、10那个步骤，对应源码如下：

// 非公平锁
final boolean nonfairTryAcquire(int acquires) 
{
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

//公平锁
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;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

分析以上代码，我们可以看到公平锁就是在获取锁之前会先判断等待队列是否为空或者自己是否位于队列头部，该条件通过才能继续获取锁。

在结合兔子喝水的图分析，非公平锁获取所得顺序基本决定在9、10、11这三个事件发生的先后顺序，
1、若在释放锁的时候总是没有新的兔子来打扰，则非公平锁等于公平锁；
2、若释放锁的时候，正好一个兔子来喝水，而此时位于队列头的兔子还没有被唤醒（因为线程上下文切换是需要不少开销的），此时后来的兔子则优先获得锁，成功打破公平，成为非公平锁；

其实对于非公平锁，只要线程进入了等待队列，队列里面依然是FIFO的原则，跟公平锁的顺序是一样的。因为公平锁与非公平锁的release()部分代码是共用AQS的代码。

上文说到的线程切换的开销，其实就是非公平锁效率高于公平锁的原因，因为非公平锁减少了线程挂起的几率，后来的线程有一定几率逃离被挂起的开销。

版权声明：本文为CSDN博主「雨雾清影」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/jk418756/article/details/83305811

最后编辑于：2020.05.18 17:51:35