ReentrantLock代码剖析之ReentrantLock.lockInterruptibly

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

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

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


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

 

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异常。

 

 

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还做了一件事情,cancelAcquirecancelAcquire中有些细节值得玩味,参见代码中笔者注释。

 

 

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
    }
    }


你可能感兴趣的:(ReentrantLock)