ReentrantLock代码剖析之ReentrantLock.lockInterruptibly

ゝ一世哀愁。 2021-11-15 13:08 346阅读 0赞

ReentrantLock.lockInterruptibly允许在等待时由其它线程调用等待线程的Thread.interrupt方法来中断等待线程的等待而直接返回，这时不用获取锁，而会抛出一个InterruptedException。而ReentrantLock.lock方法不允许Thread.interrupt中断,即使检测到Thread.isInterrupted,一样会继续尝试获取锁，失败则继续休眠。只是在最后获取锁成功后再把当前线程置为interrupted状态。

那lockInterruptibly是如何做到这一点的？

public   void  lockInterruptibly()  throws  InterruptedException \{  
        sync.acquireInterruptibly( 1 );  
    \}

这里调用了AbstractQueuedSynchronizer.acquireInterruptibly方法。如果线程已被中断则直接抛出异常，否则则尝试获取锁，失败则doAcquireInterruptibly

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][] AbstractQueuedSynchronizer.acquireInterruptibly(int arg)

/\*\*   
     \* Acquires in exclusive mode, aborting if interrupted.  
     \* Implemented by first checking interrupt status, then invoking  
     \* at least once \{  @link  \#tryAcquire\}, returning on  
     \* success.  Otherwise the thread is queued, possibly repeatedly  
     \* blocking and unblocking, invoking \{  @link  \#tryAcquire\}  
     \* until success or the thread is interrupted.  This method can be  
     \* used to implement method \{  @link  Lock\#lockInterruptibly\}.  
     \*  
     \*  @param  arg the acquire argument.  This value is conveyed to  
     \*        \{  @link  \#tryAcquire\} but is otherwise uninterpreted and  
     \*        can represent anything you like.  
     \*  @throws  InterruptedException if the current thread is interrupted  
      \*/   
     public   final   void  acquireInterruptibly( int  arg)  throws  InterruptedException \{  
         if  (Thread.interrupted())  
             throw   new  InterruptedException();  
         if  ( ! tryAcquire(arg))  
            doAcquireInterruptibly(arg);  
    \}

AbstractQueuedSynchronizer.doAcquireInterruptibly大体上相当于前面的acquireQueued,关键的区别在于检测到interrupted后的处理，acquireQueued简单的记录下中断曾经发生，然后就象没事人似的去尝试获取锁，失败则休眠。而doAcquireInterruptibly检测到中断则直接退出循环，抛出InterruptedException异常。

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][] AbstractQueuedSynchronizer.doAcquireInterruptibly(int arg)

/\*\*   
     \* Acquires in exclusive interruptible mode.  
     \*  @param  arg the acquire argument  
      \*/   
     private   void  doAcquireInterruptibly( int  arg)  
         throws  InterruptedException \{  
         final  Node node  =  addWaiter(Node.EXCLUSIVE);  
         try  \{  
             for  (;;) \{  
                 final  Node p  =  node.predecessor();  
                 if  (p  ==  head  &&  tryAcquire(arg)) \{  
                    setHead(node);  
                    p.next  =   null ;  //  help GC   
                      return ;  
                \}  
                 /\*   
                acquireQueued代码:  
           if (shouldParkAfterFailedAcquire(p, node) &&  
                    parkAndCheckInterrupt())  
                    interrupted = true;  
 \*/   
                 if  (shouldParkAfterFailedAcquire(p, node)  &&   
                    parkAndCheckInterrupt())  
                     break ;  
            \}  
        \}  catch  (RuntimeException ex) \{  
            cancelAcquire(node);  
             throw  ex;  
        \}  
         //  Arrive here only if interrupted  
         //  取消获取锁尝试，将当前节点从等待队列中移除   
         cancelAcquire(node);  
         throw   new  InterruptedException();  
    \}

在抛出异常之前，doAcquireInterruptibly还做了一件事情，cancelAcquire。cancelAcquire中有些细节值得玩味，参见代码中笔者注释。

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][] AbstractQueuedSynchronizer.cancelAcquire(Node node)

/\*\*   
     \* Cancels an ongoing attempt to acquire.  
     \*  
     \*  @param  node the node  
      \*/   
     private   void  cancelAcquire(Node node) \{  
     //  Ignore if node doesn't exist   
          if  (node  ==   null )  
         return ;  
  
    node.thread  =   null ;  
  
     //  Skip cancelled predecessors  
     //  头节点一定不会是在等待状态，所以不会被cancel,所以这里一定能找到一个节点而不用担心null   
     Node pred  =  node.prev;  
     while  (pred.waitStatus  >   0 )  
        node.prev  =  pred  =  pred.prev;  
  
     //  Getting this before setting waitStatus ensures staleness   
     Node predNext  =  pred.next;  
     //  Can use unconditional write instead of CAS here   
     node.waitStatus  =  Node.CANCELLED;  
  
     //  If we are the tail, remove ourselves   
      if  (node  ==  tail  &&  compareAndSetTail(node, pred)) \{  
        compareAndSetNext(pred, predNext,  null );  
    \}  else  \{  
         //  If "active" predecessor found...   
          if  (pred  !=  head  
         &&  (pred.waitStatus  ==  Node.SIGNAL  
             ||  compareAndSetWaitStatus(pred,  0 , Node.SIGNAL))  
         &&  pred.thread  !=   null ) \{  
  
         //  If successor is active, set predecessor's next link   
         Node next  =  node.next;  
         if  (next  !=   null   &&  next.waitStatus  <=   0 )  
            compareAndSetNext(pred, predNext, next);  
        \}  else  \{  
         /\* 这里如果不调用unparkSuccessor, 若在interrupted之后，执行到上面一句将waitStatus置CANCELLED之前，锁被释放，该线程被唤醒，则释放锁线程的unparkSuccessor不能起到预期作用，所以这里需要调用unparkSuccessor.即使此时持有锁的线程没有释放锁也不会有严重后果，被unpark的线程在获取锁失败后会继续park \*/   
        unparkSuccessor(node);  
        \}  
        node.next  =  node;  //  help GC   
     \}  
    \}

转载于:https://www.cnblogs.com/MichaelPeng/archive/2010/02/18/1669150.html

[ContractedBlock.gif]: https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif
[ExpandedBlockStart.gif]: /images/20211115/1a52485b7bdb48b393843505913565f1.png