AQS中公平锁和非公平锁区别

一、概念

注意：因为ReentrantLock 类可以实现公平锁和非公平锁，所以本文的讲解以该类为主。

1.1 公平锁

多个线程按照申请锁的顺序去获得锁，线程会直接进入队列去排队，永远都是队列的第一位才能得到锁。

1.2 非公平锁

多个线程去获取锁的时候，会直接去尝试获取，获取不到，再去进入等待队列，如果能获取到，就直接获取到锁。在这个过程中，会和队列中的线程竞争，得到锁的顺序并不一定是先到先得。

1.3 ReentrantLock 类

ReentrantLock是一个可重入且独占式的锁，并且同时实现了公平锁和非公平锁，所以本文的讲解以该类为主。

1.3.1 Sync

Sync是RenntrantLock类的一个内部抽象类，官方解释为是一个帮助类。该类继承了AQS，所以具备AQS的大部分属性和方法，同时又重写了一些必要方法：tryRelease(),isHeldExclusively(),也就是说继承该类的类都具有该方法。

同时该类有新加一些自己的方法，供具体的实现类使用：nonfairTryAcquire()，newCondition()。nonfairTryAcquire()是为了非公平锁模式下竞争锁，newCondition()，最终是为了创建条件队列。

1.3.2 NonfairSync

NonfairSync继承了Sync,是一个实现类，重要的方法有：lock(),tryAcquire(int acquires)

1.3.3 FairSync

FairSync继承了Sync,是一个实现类，重要的方法有：lock(),tryAcquire(int acquires)

总结：公平锁和非公平锁在概念上的区分：是否优先进入队列。优先进入队列的线程是公平锁，优先抢占资源的是非公平锁。

二、公平锁和非公平锁重要方法

2.1 lock

使用RenntrantLock构造函数可以构建公平锁和非公平锁，两者区别主要体现在lock方法中，具体有两处，构造方法如下：

//默认非公平锁
public ReentrantLock() {
        sync = new NonfairSync();
    }
//传入true，可以构建公平锁
public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

ReentrantLock的获取锁方法的路径：lock()->acquire()，其中acquire()方法可以参考AQS之理论知识（一）中的讲解，两者的区别是lock方法以及不同实现类重写的tryAcquire()。

2.1.1 NonfairSync 的lock

final void lock() {
   //区别一：非公平锁竞争锁资源会先去竞争锁，而公平锁只会在锁状态为0时才会竞争锁
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

调用NonfairSync 的lock，直接竞争锁，成功的话直接返回。失败的话，执行acquire()，因为AQS是模块方法，所以NonfairSync 需要重写tryAcquire()，在这个方法中当锁状态为0时直接竞争锁，无需查看队列是否有线程。

2.1.2 FairSync的lock

final void lock() {
            acquire(1);
        }
 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;
        }

调用FairSync的lock，直接执行acquire()，因为AQS是模块方法，所以FairSync需要重写tryAcquire()，在这个方法中当锁状态为0时直接竞争锁，需要查看队列是否有线程，有线程的话将新线程添加到队列中，其他业务和非公平锁一致。

总结：

区别一：非公平锁竞争锁资源会先去竞争锁，而公平锁只会在锁状态为0时才会竞争锁；

区别二：公平锁查看队列里面是否有节点，有的话，加入队列，没有的话直接去抢锁；而非公平锁则是直接抢锁。

2.2 unlock

public void unlock() {
        sync.release(1);
    }

    public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

RenntrantLock的解锁调用的是AQS的release()，而解锁调用的tryRelease(arg)是两者共用的。所以解锁的步骤依然是两大步骤：

1、更改锁状态，如果锁被完全释放，同时将独占锁绑定的线程清空。
2、唤醒队列的节点绑定的线程。