欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

转 Java并发编程J.U.C之Condition

程序员文章站 2022-07-12 18:57:08
...

在上一篇中,我们了解了下J.U.C的锁的获取与释放的过程 ,这个过程主要通过在A.Q.S中维持一个等待队列来实现,其中我们也提到了,在A.Q.S中除了一个等待队列之外,还有一个Condition队列,在了解Condition队列之前,先来看一下Condition是怎么回事:

 

 写道
The synchronizer framework provides a ConditionObject class for use by synchronizers that maintain exclusive synchronization and conform to the Lock interface. Any number of condition objects may be attached to a lock object, providing classic monitor-style await, signal, and signalAll operations, including those with timeouts, along with some inspection and monitoring methods.

 

上面的这一段内容摘自Doug Lea的AQS论文 ,从上面这一段话可以看出,Condition主要是为了在J.U.C框架中提供和Java传统的监视器风格的wait,notify和notifyAll方法类似的功能,那么先来解释一下这三个方法的作用:

  • Object.wait()方法:使当前线程释放Object上的监视器并且挂起,直到有另外的线程调用Object.notify()方法或者Object.notifyAll()方法唤醒当前线程,当被唤醒后,Object.wait()方法会尝试重新获取监视器,成功获取后继续往下执行。注意Object.wait()方法只有在当前线程持有Object的监视器的时候才能够调用,不然会抛出异常。
  • Object.notify()方法:用于唤醒另外一个调用了Object.wait()方法的线程,如果有多个都调用了Object.wait()方法,那么就会选择一个线程去notify(),具体选择哪一个和具体的实现有关,当前线程在调用Object.notify()方法以后会就释放Object的监视器,和wait()方法一样,Object.notify()方法只有在当前线程只有Object的监视器的时候才能够调用,不然就会抛出异常。
  • Object.notifyAll()方法:唤醒所有调用了Object.wait()方法的线程,如果有多个线程调用了Object.wait()方法,那么就会引发这些线程之间的竞争,最后谁成功获取到Object的监视器和具体的实现有关,当前线程在调用Object.notifyAll()方法以后会就释放Object的监视器,和wait()方法一样,Object.notifyAll()方法只有在当前线程只有Object的监视器的时候才能够调用,不然就会抛出异常。

那么Condition是如何实现wait,notify和notifyAll方法的功能呢?我们接下来看:

在Condition中,wait,notify和notifyAll方法分别对应了await,signal和signalAll方法,当然Condition也提供了超时的、不可被中断的await()方法,不过我们主要还是看一看await,notify和notifyAll的实现,先看await:

await方法:

Java代码  转 Java并发编程J.U.C之Condition
            
    
    博客分类: Thread threadCondition 
  1. public final void await() throws InterruptedException {  
  2.     if (Thread.interrupted())  
  3.         throw new InterruptedException();  
  4.     Node node = addConditionWaiter();  
  5.     int savedState = fullyRelease(node);  
  6.     int interruptMode = 0;  
  7.     while (!isOnSyncQueue(node)) {  
  8.         LockSupport.park(this);  
  9.         if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)  
  10.             break;  
  11.     }  
  12.     if (acquireQueued(node, savedState) && interruptMode != THROW_IE)  
  13.         interruptMode = REINTERRUPT;  
  14.     if (node.nextWaiter != null)  
  15.         unlinkCancelledWaiters();  
  16.     if (interruptMode != 0)  
  17.         reportInterruptAfterWait(interruptMode);  
  18. }  
 
整个await的过程如下:
  1. 在第2行处,如果当前线程被中断,则抛出中断异常。
  2. 在第4行处,将节点加入到Condition队列中去,这里如果lastWaiter是cancel状态,那么会把它踢出Condition队列。
  3. 在第5行处,调用tryRelease,释放当前线程的锁
  4. 在第7行处,判断节点是否在等待队列中(signal操作会将Node从Condition队列中拿出并且放入到等待队列中去),如果不在等待队列中了,就park当前线程,如果在,就退出循环,这个时候如果被中断,那么就退出循环
  5. 在第12行处,这个时候线程已经被signal()或者signalAll()操作给唤醒了,退出了4中的while循环,尝试再次获取锁,调用acquireQueued方法。

可以看到,这个await的操作过程和Object.wait()方法是一样,只不过await()采用了Condition队列的方式实现了Object.wait()的功能。

signal和signalAll方法:

在了解了await方法的实现以后,signal和signalAll方法的实现就相对简单了,先看看signal方法:

Java代码  转 Java并发编程J.U.C之Condition
            
    
    博客分类: Thread threadCondition 
  1. public final void signal() {  
  2.     if (!isHeldExclusively())  
  3.         throw new IllegalMonitorStateException();  
  4.     Node first = firstWaiter;  
  5.     if (first != null)  
  6.         doSignal(first);  
  7. }  
 
这里先判断当前线程是否持有锁,如果没有持有,则抛出异常,然后判断整个condition队列是否为空,不为空则调用doSignal方法来唤醒线程,看看doSignal方法都干了一些什么:
Java代码  转 Java并发编程J.U.C之Condition
            
    
    博客分类: Thread threadCondition 
  1. private void doSignal(Node first) {  
  2.     do {  
  3.         if ( (firstWaiter = first.nextWaiter) == null)  
  4.             lastWaiter = null;  
  5.         first.nextWaiter = null;  
  6.     } while (!transferForSignal(first) &&  
  7.              (first = firstWaiter) != null);  
  8. }  
 
这个while循环的作用就是将firstWaiter往Condition队列的后面移一位,并且唤醒first,看看while循环中tranferForSignal:
Java代码  转 Java并发编程J.U.C之Condition
            
    
    博客分类: Thread threadCondition 
  1. final boolean transferForSignal(Node node) {  
  2.     /* 
  3.      * If cannot change waitStatus, the node has been cancelled. 
  4.      */  
  5.     if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))  
  6.         return false;  
  7.    
  8.     /* 
  9.      * Splice onto queue and try to set waitStatus of predecessor to 
  10.      * indicate that thread is (probably) waiting. If cancelled or 
  11.      * attempt to set waitStatus fails, wake up to resync (in which 
  12.      * case the waitStatus can be transiently and harmlessly wrong). 
  13.      */  
  14.     Node p = enq(node);  
  15.     int c = p.waitStatus;  
  16.     if (c > 0 || !compareAndSetWaitStatus(p, c, Node.SIGNAL))  
  17.         LockSupport.unpark(node.thread);  
  18.     return true;  
  19. }  
 

这段代码的作用就是修改Node的waitStatus为0,然后将Node插入到等待队列中,并且唤醒Node。

signalAll和signal方法类似,主要的不同在于它不是调用doSignal方法,而是调用doSignalAll方法:

Java代码  转 Java并发编程J.U.C之Condition
            
    
    博客分类: Thread threadCondition 
  1. private void doSignalAll(Node first) {  
  2.     lastWaiter = firstWaiter  = null;  
  3.     do {  
  4.         Node next = first.nextWaiter;  
  5.         first.nextWaiter = null;  
  6.         transferForSignal(first);  
  7.         first = next;  
  8.     } while (first != null);  
  9. }  
 
这个方法就相当于把Condition队列中的所有Node全部取出插入到等待队列中去。

总结:

在了解了await(),signal()和signalAll方法的实现以后,我们再来通过一副gif动画来看一看这一个整体的过程:


转 Java并发编程J.U.C之Condition
            
    
    博客分类: Thread threadCondition 

 

 

相关标签: thread Condition