AQS组件总结

Posted 2020-11-16 lgxblog

ReentrantLock

ReentrantLock是AQS中独占模式的一种实现。内部定义了一个继承了AQS类的Syn类。该类有两个子类。而Syn类定义模板方法lock()方法给子类去实现。其中一个子类是实现公平锁，另一个是实现非公平锁。

非公平锁的实现

非公平锁的实现很简单，通过CAS操作判断state这个变量是不是为0，如果是0，则将state设置为1，并且将持有锁的线程改为当前拿到锁的线程。如果是不是0，则调用aquire()方法去抢占锁。代码如下：

 1      /**
 2      * Performs lock.  Try immediate barge, backing up to normal
 3      * acquire on failure.
 4      */
 5     final void lock() {
 6         if (compareAndSetState(0, 1))
 7             setExclusiveOwnerThread(Thread.currentThread());
 8         else
 9             acquire(1);
10     }

因为acquire()方法需要调用tryAcquire()方法，而AQS定义了一个模板给子类去实现，所以Syn类去实现了这个方法。而Syn的非公平锁的tryAcquire()实际上调用的是Syn的nonfairTryAcquire()方法，代码如下：

 1        protected final boolean tryAcquire(int acquires) {
 2              return nonfairTryAcquire(acquires);
 3         }
 4        final boolean nonfairTryAcquire(int acquires) {
 5             final Thread current = Thread.currentThread();
 6             int c = getState();
 7             if (c == 0) {
 8                 if (compareAndSetState(0, acquires)) {
 9                     setExclusiveOwnerThread(current);
10                     return true;
11                 }
12             }
13             //这里是为什么可重入的原因
14             else if (current == getExclusiveOwnerThread()) {
15             //判断当前线程是不是持有锁的线程，因为该线程在继续获取锁，那么直接将state变量值递增。
16                 int nextc = c + acquires;
17                 if (nextc < 0) // overflow
18                     throw new Error("Maximum lock count exceeded");
19                 setState(nextc);
20                 return true;
21             }
22             //未争抢到返回false
23             return false;
24         }

公平锁

公平锁的实现相比非公平锁的实现，相对来说复杂了一点点，公平锁的加锁方式是直接acquire()方法，因为公平锁不能去抢占。

 1 static final class FairSync extends Sync {
 2         private static final long serialVersionUID = -3000897897090466540L;
 3         //加锁的方法，直接调用acquire()方法继而调用自己实现的tryAcquire()方法
 4         final void lock() {
 5             acquire(1);
 6         }
 7 
 8         /**
 9          * Fair version of tryAcquire.  Don‘t grant access unless
10          * recursive call or no waiters or is first.
11          */
12         protected final boolean tryAcquire(int acquires) {
13             final Thread current = Thread.currentThread();
14             int c = getState();
15             if (c == 0) {
16                 //这里需要判断当前线程是不是在同步队列的队首
17                 if (!hasQueuedPredecessors() &&
18                     compareAndSetState(0, acquires)) {
19                     setExclusiveOwnerThread(current);
20                     return true;
21                 }
22             }
23             //这里的逻辑是和公平锁一样的，就是判断是不是当前线程是不是已经是获取到锁的线程，是的话将state变量值递增
24             else if (current == getExclusiveOwnerThread()) {
25                 int nextc = c + acquires;
26                 if (nextc < 0)
27                     throw new Error("Maximum lock count exceeded");
28                 setState(nextc);
29                 return true;
30             }
31             return false;
32         }
33     }

来看看hasQueuedPredecessors()方法

 1 public final boolean hasQueuedPredecessors() {
 2         // The correctness of this depends on head being initialized
 3         // before tail and on head.next being accurate if the current
 4         // thread is first in queue.
 5         Node t = tail; // Read fields in reverse initialization order
 6         Node h = head;
 7         Node s;
 8         return h != t &&
 9             ((s = h.next) == null || s.thread != Thread.currentThread());
10     }

很显然可以看出，就是判断当前线程是不是同步队列的队首节点，以此来判断是不是有比当前线程等待更久的线程。以此来实现公平。

总结

ReentrantLock相对于synchronized的区别：

1) ReentrantLock可以实现公平锁和非公平锁。

2) ReentrantLock可中断

3) ReentrantLock需要手动加锁，释放锁

4) ReentrantLock是JDK API层面的，而synchronized是JVM层面的