Lock的Condition使用

本文主要是介绍Lock的Condition使用，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Condition 本质是一个接口，它包含如下方法

// 让线程进入等通知待状态 

void await() throws InterruptedException; 
void awaitUninterruptibly();

//让线程进入等待通知状态，超时结束等待状态，并抛出异常  
long awaitNanos(long nanosTimeout) throws InterruptedException; 
boolean await(long time, TimeUnit unit) throws InterruptedException; 
boolean awaitUntil(Date deadline) throws InterruptedException; //将条件队列中的一个线程，从等待通知状态转换为等待锁状态 
void signal(); //将条件队列中的所有线程，从等待通知阻塞状态转换为等待锁阻塞状态
void signalAll();

           一个Condition实例的内部实际上维护了一个队列，队列中的节点表示由于（某些条件不满足而）线程自身调用await方法阻塞的线程。Condition接口中有两个重要的方法，即 await方法和 signal方法。线程调用这个方法之前该线程必须已经获取了Condition实例所依附的锁。这样的原因有两个，（1）对于await方法，它内部会执行释放锁的操作，所以使用前必须获取锁。（2）对于signal方法，是为了避免多个线程同时调用同一个Condition实例的singal方法时引起的（队列）出列竞争。下面是这两个方法的执行流程。

          await方法：

                            1. 入列到条件队列（注意这里不是等待锁的队列）

                            2. 释放锁

                            3. 阻塞自身线程

                             ------------被唤醒后执行-------------

                            4. 尝试去获取锁（执行到这里时线程已不在条件队列中，而是位于等待（锁的）队列中，参见signal方法）

                                4.1 成功，从await方法中返回，执行线程后面的代码

                                4.2 失败，阻塞自己（等待前一个节点释放锁时将它唤醒）

         注意：await方法时自身线程调用的，线程在await方法中阻塞，并没有从await方法中返回，当唤醒后继续执行await方法中后面的代码（也就是获取锁的代码）。可以看出await方法释放了锁，又尝试获得锁。当获取锁不成功的时候当前线程仍然会阻塞到await方法中，等待前一个节点释放锁后再将其唤醒。

         signal方法：

                           1. 将条件队列的队首节点取出，放入等待锁队列的队尾

                           2. 唤醒该节点对应的线程

         注意：signal是由其它线程调用

Lock和Condition的使用例程

public class ConditionCommunication {
/**
* @param args
*/
public static void main(String[] args) {

final Business business = new Business();
new Thread(new Runnable() {
        @Override
      public void run() {
          for(int i=1;i<=50;i++){
              business.sub(i);
                 }

}}).start();
             for(int i=1;i<=50;i++){
              business.main(i);
                 }
     }


         static class Business {
              Lock lock = new ReentrantLock();
              Condition condition = lock.newCondition();
              private boolean bShouldSub = true;
             public  void sub(int i){
                          lock.lock();
                     try{
                       while(!bShouldSub){
                   try {
                     condition.await();
                        } catch (Exception e) {
                    e.printStackTrace();
                    }
            }
                 for(int j=1;j<=10;j++){
                    System.out.println("sub thread sequence of " + j + ",loop of " + i);
         }
             bShouldSub = false;
            condition.signal();
            }finally{
              lock.unlock();
        }
    }
 
           public  void main(int i){
                  lock.lock();
                   try{
                       while(bShouldSub){
try {
                                    condition.await();
                                       } catch (Exception e) {
                                                 e.printStackTrace();
                                                                           }
  }
                                      for(int j=1;j<=100;j++){
                                   System.out.println("main thread sequence of " + j + ",loop of " + i);
                                        }
                             bShouldSub = true;
                              condition.signal();
                       }finally{
                             lock.unlock();
                            }
               }

        }
}

Lock与synchronized的区别

          1. Lock的加锁和解锁都是由java代码配合native方法（调用操作系统的相关方法）实现的，而synchronize的加锁和解锁的过程是由JVM管理的

这篇关于Lock的Condition使用的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！