独占锁和共享锁底层原理分析

　　独占锁模式
　　前面说到，ReentrantLock锁就是基于独占锁实现的，独占锁的加锁和解锁操作都是通过互斥方式实现的。
　　加锁流程
　　在AQS中，是通过acquire()方法来加锁的，源码如下：    public final void acquire(int arg) {         if (!tryAcquire(arg) &&             acquireQueued(addWaiter(Node.EXCLUSIVE), arg))             selfInterrupt();     } 复制代码
　　首先映入眼帘的是tryAcquire(arg)方法，翻译过来是尝试获取锁的意思，由于是用&&连接，只有tryAcquire(arg)方法失败时才会往下执行，当tryAcquire(arg)方法成功返回true时表示获取资源成功，对于tryAcquire(arg)方法，里面没有实现具体的东西，只是抛出了一个异常，具体逻辑是由AQS的子类实现的：    protected boolean tryAcquire(int arg) {         throw new UnsupportedOperationException();     } 复制代码
　　当tryAcquire(arg)返回为false时，会往后执行addWaiter(Node.EXCLUSIVE)方法，将当前线程封装成独占模式并添加到AQS的等待队列尾部，如果当tryAcquire(arg)返回true，则会直接让当前的线程继续执行，不需要添加到等待队列尾部，点入addWaiter(Node mode)方法，会看到如下源码：private Node addWaiter(Node mode) {                 /* 这个可以参考上面Node的构造方法         Node(Thread thread, Node mode) {     // Used by addWaiter             this.nextWaiter = mode;             this.thread = thread;         }         */                  //构造新的等待线程节点         Node node = new Node(Thread.currentThread(), mode);                 //新建临时节点pred指向尾节点         Node pred = tail;         //队列不为空的话，通过CAS机制将node放到队列尾部         if (pred != null) {             //将node的prev域指向尾节点             node.prev = pred;             //通过CAS机制将node放到队列尾部             if (compareAndSetTail(pred, node)) {                 //将原来尾节点的next域指向当前node节点，node现在为尾节点                 pred.next = node;//形成双向链表                 return node;             }         }         //如果队列为空的话         enq(node);         return node;     } 复制代码
　　在多线程并发情况下，如果有多个线程同时争夺尾节点的位置，会调用enq(node)方法，使用CAS自旋机制挂到双向链表的尾部，下面是源码：    private Node enq(final Node node) {         //死循环(自旋)         for (;;) {             Node t = tail;             //尾节点为null，说明头结点也为null，可能是还没有创建队列的时候             if (t == null) {                  //多线程并发情况下，利用CAS机制创建头结点和尾节点，CAS保证此时只有一个头节点被创建，下次自旋时，就会满足队列不为空的条件                 if (compareAndSetHead(new Node()))                     tail = head;             } else {                 //如果存在尾节点，将当前节点的prev域指向尾节点                 node.prev = t;                 //利用CAS机制完成双向链表的绑定，让之前尾节点指向当前node节点                 if (compareAndSetTail(t, node)) {                     t.next = node;                     return t;                 }             }         }     } 复制代码
　　接下来看一看compareAndSetTail方法使用CAS乐观锁机制的方法源码：    private final boolean compareAndSetTail(Node expect, Node update) {         return unsafe.compareAndSwapObject(this, tailOffset, expect, update);     } 复制代码
　　上述代码讨论到，使用tryAcquire(int arg)方法返回false时，再使用addWaiter(Node mode)方法，将当前线程放入到队列的尾部。acquireQueued(final Node node, int arg)方法，等待休息直到其他线程唤醒    final boolean acquireQueued(final Node node, int arg) {         //拿到资源失败情况置为true，表示没有拿到资源         boolean failed = true;         try {             //用于判断线程是否中断过，默认没有中断过             boolean interrupted = false;             for (;;) {                 //获取node的前置节点                 final Node p = node.predecessor();                 //如果当前节点的前驱节点是头结点，并且当前节点尝试成功获取了资源                 if (p == head && tryAcquire(arg)) {                     //就将当前节点设为头结点                     setHead(node);                     //释放之前的头结点，利于垃圾回收                     p.next = null; // help GC                     //表示获取资源成功                     failed = false;                     //返回线程是否被中断过                     return interrupted;                 }                 //获取资源失败后线程等待，并检查是否被中断过                 if (shouldParkAfterFailedAcquire(p, node) &&                     parkAndCheckInterrupt())                     //线程是否被中断过                     interrupted = true;             }         } finally {             if (failed)                 cancelAcquire(node);         }     } 复制代码
　　如果当前的前驱节点表示头结点，并且获取资源成功，那么直接将当前线程设为头结点，释放之前头结点与后继节点的链接，帮助垃圾回收（GC），如果前面当前节点的前驱不为头结点或者没有获取到资源，那么会调用shouldParkAfterFailedAcquire(Node pred, Node node)方法来判断当前线程是否能够进入waiting状态，如果可以进入，并且进入到了阻塞状态，那会阻塞，直到调用了LockSupport中的unpark()方法唤醒线程。    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {         //保存前驱节点的状态         /*         提示：         当waitState>0时，表示该线程处于取消状态（线程中断或者等待锁超时），需要移除线程；         当waitState=0时，默认值，表示初始化状态，表示线程还未完成初始化操作；         当waitState<0，表示有效状态，线程处于可唤醒状态。         */         int ws = pred.waitStatus;         //等待唤醒后置节点，SIGNAL为-1         if (ws == Node.SIGNAL)             return true;         //如果前置节点不是正常的等待状态（CANCELLED结束状态），那么从当前节点开始往前寻找正常的等待状态         if (ws > 0) {             do {                 //后面的节点断开与前驱节点的链接                 node.prev = pred = pred.prev;             } while (pred.waitStatus > 0);             //双向连接             pred.next = node;         } else { //小于0时，可能为共享锁             compareAndSetWaitStatus(pred, ws, Node.SIGNAL);         }         return false;     }  复制代码
　　如果前驱节点的SIGNAL值为-1，会返回true。
　　compareAndSetWaitStatus(pred, ws, Node.SIGNAL)方法内部也使用了CAS锁机制，源码：    private static final boolean compareAndSetWaitStatus(Node node,                                                          int expect,                                                          int update) {         return unsafe.compareAndSwapInt(node, waitStatusOffset,                                         expect, update);     } 复制代码
　　如果shouldParkAfterFailedAcquire(Node pred, Node node)方法返回true，则会调用parkAndCheckInterrupt()方法阻塞当前线程，线程等待，如果线程被中断过则返回true：private final boolean parkAndCheckInterrupt() {     // 调用park让线程进入wait状态     LockSupport.park(this);     // 检查线程是否中断过。     return Thread.interrupted(); } 复制代码
　　如果线程在等待的过程中被中断过，那么获取到资源后会通知线程中断：    /**      * Convenience method to interrupt current thread.      */     static void selfInterrupt() {         Thread.currentThread().interrupt();     } 复制代码
　　acquire()竞争获取锁资源流程时，首先会调用tryAcquire()方法去尝试获取资源,如果成功获取到资源，则直接进入临界区执行代码；如果没有获取到资源，则将此线程封装成一个结点放入队列尾部分，调用park()方法让线程等待，并且标记为独占模式。如果线程被唤醒(unPark)时，会尝试获取锁资源，如果在等待过程中，线程被中断过则返回true，没有被中断过返回false。如果线程在等待过程中被中断过，它是不会响应，只是在获取到资源后直接调用自我中断方法selfInterrupt()，将中断线程。
　　释放独占锁
　　在独占锁中，释放锁的入口是release()方法，源码如下：    public final boolean release(long arg) {         if (tryRelease(arg)) {             Node h = head;             if (h != null && h.waitStatus != 0)                 //唤醒后继节点                 unparkSuccessor(h);             return true;         }         return false;     } 复制代码
　　点入tryRelease(arg)方法尝试释放锁，可以看出，其和tryAcquire()方法一样，也没有具体的实现，只是抛出了UnsupportedOperationException()异常，具体的逻辑由AQS的子类实现：    protected boolean tryRelease(long arg) {         throw new UnsupportedOperationException();     } 复制代码
　　如果tryRelease(long arg)方法返回true，会判断头结点是否为空，并且waitStatus是否为0（为0则代码初始化阶段），如果不为0，那么下面会调用unparkSuccessor()方法，唤醒后继节点，我们来查看unparkSuccessor()方法的源码：    private void unparkSuccessor(Node node) {         int ws = node.waitStatus;         //如果当前状态为有效状态         if (ws < 0)             //CAS操作将waitState置为0             compareAndSetWaitStatus(node, ws, 0);         Node s = node.next;         //下一个节点（线程）为空或已取消         if (s == null || s.waitStatus > 0) {             s = null;             //从后往前遍历，寻找有效的节点             for (Node t = tail; t != null && t != node; t = t.prev)                 if (t.waitStatus <= 0)                     s = t;         }         if (s != null)             //找到则唤醒后继节点             LockSupport.unpark(s.thread);     } 复制代码
　　unparkSuccessor(Node node)方法实现的是唤醒后继节点，当当前节点的waitStatus状态小于0时，表示该状态为有效状态，会使用CAS机制将当前线程设为初始化状态0，之后找到下一个需要唤醒的节点，如果下一个需要唤醒的节点为空或者为取消状态则将当前线程置为null，之后从尾节点往前遍历，寻找有效的节点，找到了且不为null的话，就唤醒该节点（线程）。共享模式加锁
　　在共享模式下加锁的方法入口为acquireShared(long arg)方法，其源码如下：    public final void acquireShared(long arg) {         if (tryAcquireShared(arg) < 0)             doAcquireShared(arg);     } 复制代码
　　进入到tryAcquireShared(arg)方法，此方法为尝试获取资源，得到如下源码，与独占模式获取锁一样，tryAcquireShared(long arg)没有实现具体的逻辑，由AQS的子类实现：    protected long tryAcquireShared(long arg) {         throw new UnsupportedOperationException();     } 复制代码
　　tryAcquireShared(arg)会有三种返回值：当返回值为负数时，表示获取资源失败；当返回值为0时，表示获取资源成功，没有剩余资源；当返回值为正数时，表示当前线程获取到了资源，仍然有资源剩余。
　　当tryAcquireShared(arg)方法返回为false时，表示获取资源失败，会往下进行doAcquireShared(arg)方法，此方法会将线程放入到等待队列尾部休息，点入 doAcquireShared(arg)方法的源码得：    private void doAcquireShared(long arg) {         //将节点加入到队列尾部         final Node node = addWaiter(Node.SHARED);         //获取资源成功的标志，初始为获取不到         boolean failed = true;         try {             //中断的标志             boolean interrupted = false;             //自旋             for (;;) {                 //获取当前节点的前驱节点                 final Node p = node.predecessor();                 //如果前驱节点是头节点的话                 if (p == head) {                     //返回还剩下多少资源                     long r = tryAcquireShared(arg);                     if (r >= 0) {                         //如果资源还足够的话，将头结点指向自己，如果还有剩余资源，可以唤醒后面的节点                         setHeadAndPropagate(node, r);                         //断开之前的头结点，便于垃圾回收                         p.next = null; // help GC                         if (interrupted)                             selfInterrupt();                         failed = false;                         return;                     }                 }                 if (shouldParkAfterFailedAcquire(p, node) &&                     parkAndCheckInterrupt())                     interrupted = true;             }         } finally {             if (failed)                 cancelAcquire(node);         }     } 复制代码
　　在共享模式下，当线程被唤醒拿到资源时，如果还有剩余资源，会继续唤醒后继的线程。如果被唤醒的线程发现资源不够用时会再次进入休眠。这个情况下，就算排在首位线程后面的线程需要更少的资源，也会因为前面资源不够而等待，不会先执行后面的线程。
　　对于上面代码中出现的setHeadAndPropagate()方法，点入查看得到以下源码：    private void setHeadAndPropagate(Node node, long propagate) {         //将头结点赋值为h         Node h = head; // Record old head for check below         //将当前节点设置为头结点         setHead(node);         //如果还有剩余资源的话，会唤醒后面的节点（线程）         if (propagate > 0 || h == null || h.waitStatus < 0 ||             (h = head) == null || h.waitStatus < 0) {             Node s = node.next;             if (s == null || s.isShared())                 //唤醒后继节点                 doReleaseShared();         }     } 复制代码
　　释放共享资源
　　释放共享资源方法为doReleaseShared()   private void doReleaseShared() {         //自旋         for (;;) {             Node h = head;             //头结点不为空并且头结点不等于尾节点             if (h != null && h != tail) {                 //拿到头结点的等待状态                 int ws = h.waitStatus;                 //如果当前节点为等待唤醒的节点                 if (ws == Node.SIGNAL) {                     //将当前节点等待状态初始化，来唤醒线程                     if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))                         continue;                                 // loop to recheck cases                     unparkSuccessor(h);//唤醒后继线程                 }                 //如果线程处于初始化状态，并且还有剩余资源                 else if (ws == 0 &&                          !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))                     continue;                // loop on failed CAS             }             //如果没有后继节点，退出自旋             if (h == head)                   // loop if head changed                 break;         }     } 复制代码
　　在 doReleaseShared()方法中，通过自旋的方式获取头节点，当头节点不为空，且队列不为空时，判断头节点的waitStatus状态的值是否为SIGNAL(-1)。当满足条件时，会通过CAS将头节点的waitStatus状态值设置为0，如果CAS操作设置失败，则继续自旋。如果CAS操作设置成功，则唤醒队列中的后继节点。
　　如果头节点的waitStatus状态值为0，并且在通过CAS操作将头节点的waitStatus状态设置为PROPAGATE(-3)时失败，则继续自旋逻辑。
　　如果在自旋的过程中发现没有后继节点了，则退出自旋逻辑。
　　本篇文章就分享到这里了，后续将会分享各种其他关于并发编程的知识，感谢大佬认真读完支持咯 ~
　　文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起讨论 希望能和诸佬们一起努力，今后进入到心仪的公司 再次感谢各位小伙伴儿们的支持
　　作者：小威要向诸佬学习呀
　　链接：https://juejin.cn/post/7164692725332181022