Java公平锁与非公平锁的核心原理讲解

目录

Lock锁接口方法公平锁简介ReentranLock的公平锁ReentranLock的非公平锁

Lock锁接口方法

前面了解到了synchronized锁，也知道了synchronized锁是一种JVM提供内置锁，但synchronized有一些缺点：比如不支持响应中断，不支持超时，不支持以非阻塞的方式获取锁等。而今天的主角Lock锁，需要我们手动获取锁和释放锁，里面有很多方式来获取锁，比如以阻塞方式获取锁，在指定时间内获取锁，非阻塞模式下抢占锁等，其方法源码如下（位于package java.util.concurrent.locks包下）：

1. //Lock接口下的方法
2. public interface Lock {
3.     //阻塞式抢占锁，如果抢到锁，则向下执行程序；抢占失败线程阻塞，直到释放锁才会进行抢占锁
4.     void lock();
5.     //可中断模式抢占锁，线程调用此方法能够中断线程
6.     void lockInterruptibly() throws InterruptedException;
7.     //非阻塞式尝试获取锁，调用此方法线程不会阻塞，抢到锁返回true，失败返回false
8.     boolean tryLock();
9.     //在指定时间内尝试获取锁，在指定时间内抢到锁成功返回true，失败返回false
10.     boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
11.     //释放锁，线程执行完程序后，调用此方法来释放锁资源
12.     void unlock();
13.     //条件队列
14.     Condition newCondition();
15.     }

复制代码

公平锁简介

公平锁，顾名思义，所有线程获取锁都是公平的。在多线程并发情况下，线程争抢锁时，首先会检查等待队列中是否有其他线程在等待。如果等待队列为空，没有线程在等待，那么当前线程会拿到锁资源；如果等待队列中有其他线程在等待，那么当前线程会排到等待队列的尾部，好比我们排队买东西一样。

ReentranLock的公平锁

ReentranLock类实现了Lock接口，重写了里面的方法，对于ReentranLock类中的公平锁，我们可以看到如下源码：

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

复制代码

在上述构造方法中，新建锁对象是否为公平锁，在于传入的参数是true还是false，在三目运算符中，如果传入参数为true，则会创建一个FairSync()对象赋值给sync，线程获取的锁是公平锁；如果为false则创建一个NonfairSync()对象，线程获取的锁是非公平锁。点入FairSync()方法，得到如下源码：

1.     static final class FairSync extends Sync {
2.         private static final long serialVersionUID = -3000897897090466540L;
4.         final void lock() {
5.             acquire(1);
6.         }
7.         /*这里将acquire方法放于此
8.             public final void acquire(int arg) {
9.         if (!tryAcquire(arg) &&
10.             acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
11.             selfInterrupt();
12.     }
13.         */
14.         protected final boolean tryAcquire(int acquires) {
15.             final Thread current = Thread.currentThread();
16.             //拿到当前锁对象的状态
17.             int c = getState();
18.             //如果没有线程获取到锁
19.             if (c == 0) {
20.                 //首先会判断是否有前驱节点，如果没有就会调用CAS机制更新锁对象状态
21.                 if (!hasQueuedPredecessors() &&
22.                     compareAndSetState(0, acquires)) {
23.                     //设置当前线程拥有锁资源
24.                     setExclusiveOwnerThread(current);
25.                     //如果获取锁资源成功则返回true
26.                     return true;
27.                 }
28.             }
29.             //或者如果拿到锁的就是当前线程
30.             else if (current == getExclusiveOwnerThread()) {
31.                 //将锁的状态+1，考虑到锁重入
32.                 int nextc = c + acquires;
33.                 if (nextc < 0)
34.                     //超过了最大锁的数量
35.                     throw new Error("Maximum lock count exceeded");
36.                 //如果锁数量没有溢出，设置当前锁状态
37.                 setState(nextc);
38.                 //如果成功获取锁资源则返回true
39.                 return true;
40.             }
41.             //如果前两条都不符合，则返回false
42.             return false;
43.         }
44.     }

复制代码

上述代码涉及到了hasQueuedPredecessors()方法，返回true则代表有有前驱节点，点入查看得到以下源码：

1.     public final boolean hasQueuedPredecessors() {
2.         Node t = tail; // Read fields in reverse initialization order
3.         Node h = head;
4.         Node s;
5.         //h!=t，首节点不等于尾节点表示队列中有节点
6.         return h != t &&
7.             (
8.             //s为头结点的下一个节点，返回false表示队列中还有第二个节点，或运算符后面表示，第二个线程不是当前线程
9.             (s = h.next) == null || s.thread != Thread.currentThread()
10.             );
11.     }

复制代码

因此做出总结，使用ReentranLock的公平锁，当线程调用ReentranLock类中的lock()方法时，会首先调用FairSync类中的lock()方法；然后FairSync类中的lock()方法会调用AQS类（AbstractQueuedSynchronizer）中的acquire(1)方法获取资源，前面的文章里也提到过，acquire()方法会调用tryAcquire()方法尝试获取锁，tryAcquire()方法里面没有具体的实现，tryAcquire()方法具体逻辑是由其子类实现的，因此调用的还是FairSync类中的方法。在AQS中的acquire()方法中如果尝试获取资源失败，会调用addWaiter()方法将当前线程封装为Node节点放到等待队列的尾部，并且调用AQS中的acquireQueued方法使线程在等待队列中排队。

ReentranLock的非公平锁

非公平锁就是所有抢占锁的线程都是不公平的，在我们日常生活中就相当于是插队现象，不过也与插队稍微不同。在多线程并发时，每个线程在抢占锁的过程中，都会先尝试获取锁，如果获取成功，则直接指向具体的业务逻辑；如果获取锁失败，则会像公平锁一样在等待队列队尾等待。
在非公平锁模式下，由于刚来的线程可以在队首位置进行一次插队，所以当插队成功时，后面的线程可能会出现长时间等待，无法获取锁资源产生饥饿现象。但是非公平锁性能比公平锁性能更好。
对于ReentranLock类中的非公平锁，实现方式有两种，一种是默认的构造方式，另一种是和上面的一样，源码如下：

1.     //第一种方式，默认实现
2.     public ReentrantLock() {
3.         sync = new NonfairSync();
4.     }
5.     //第二种方式，传入false来创建非公平锁对象
6.     public ReentrantLock(boolean fair) {
7.         sync = fair ? new FairSync() : new NonfairSync();
8.     }

复制代码

对于创建的NonfairSync()类对象，其源码如下：

1.     static final class NonfairSync extends Sync {
2.         private static final long serialVersionUID = 7316153563782823691L;
4.         /**
5.          * Performs lock.  Try immediate barge, backing up to normal
6.          * acquire on failure.
7.          */
8.         final void lock() {
9.             if (compareAndSetState(0, 1))
10.                 setExclusiveOwnerThread(Thread.currentThread());
11.             else
12.                 acquire(1);
13.         }
14.         protected final boolean tryAcquire(int acquires) {
15.             return nonfairTryAcquire(acquires);
16.         }
17.     }

复制代码

在上述代码中，当线程获取锁时，并没有直接将当前线程放入等待队列中，而是先尝试获取锁资源，如果获取锁成功，设置state标志位1成功，则直接将当前线程拿到锁，执行线程业务；如果获取锁资源失败，则调用AQS中的acquire方法获取资源，而acquire()方法会回调上面NonfairSyn类中的tryAcquire()方法，然后又会回调Sync类中的nonfairTryAcquire()方法（NonfairSync类继承了Sync类） ，点击nonfairTryAcquire(acquires)查看源码：

1.         final boolean nonfairTryAcquire(int acquires) {
2.             final Thread current = Thread.currentThread();
3.             int c = getState();
4.             if (c == 0) {
5.                 if (compareAndSetState(0, acquires)) {
6.                     setExclusiveOwnerThread(current);
7.                     return true;
8.                 }
9.             }
10.             else if (current == getExclusiveOwnerThread()) {
11.                 int nextc = c + acquires;
12.                 if (nextc < 0) // overflow
13.                     throw new Error("Maximum lock count exceeded");
14.                 setState(nextc);
15.                 return true;
16.             }
17.             return false;
18.         }

复制代码

由上诉代码，没有将线程放入到等待队列中，只是对锁的状态进行了判断，若标识为0，代表没有线程拿到锁，当前线程会使用CAS机制改变锁状态，并调用setExclusiveOwnerThread(current)方法让当前线程拿到锁。
因此综上所述，在使用ReentranLock中的非公平锁时，首先会调用lock()方法，，而ReentranLock类中lock()方法会调用NonfairSync类中的lock()方法，接着NonfairSync类中的lock()方法会调用AQS中的acquire()方法来获取锁资源,AQS中的acquire()方法又会回调NonfairSync类中tryAcquire()方法尝试获取资源，NonfairSync类中tryAcquire()方法会调用Sync类中的nonfairTryAcquire方法尝试非公平锁获取资源；获取失败的话，AQS中的acquire()方法会调用addWaiter()方法将当前线程封装成Node节点放入到等待队列的队尾，而后AQS中的acquire()方法会调用AQS中的acquireQueued()方法让线程在等待队列中排队。这就是非公平锁的整个流程。
到此这篇关于Java公平锁与非公平锁的核心原理讲解的文章就介绍到这了,更多相关Java公平锁 非公平锁内容请搜索中国红客联盟以前的文章或继续浏览下面的相关文章希望大家以后多多支持中国红客联盟！