黑马程序员技术交流社区

标题: 多线程问题,不知道调用的是哪个类中的方法? [打印本页]

作者: 汤柳清    时间: 2014-2-7 10:34
标题: 多线程问题,不知道调用的是哪个类中的方法?
  1. /*
  2. jdk1.5以后将同步和锁封装成了对象。
  3. 并将操作锁的隐式方式定义到了该对象中,
  4. 将隐式动作变成了显示动作。

  5. Lock接口: 出现替代了同步代码块或者同步函数。将同步的隐式锁操作变成现实锁操作。
  6. 同时更为灵活。可以一个锁上加上多组监视器。
  7. lock():获取锁。
  8. unlock():释放锁,通常需要定义finally代码块中。


  9. Condition接口:出现替代了Object中的wait notify notifyAll方法。
  10.                         将这些监视器方法单独进行了封装,变成Condition监视器对象。
  11.                         可以任意锁进行组合。
  12. await();
  13. signal();
  14. signalAll();



  15. */

  16. import java.util.concurrent.locks.*;

  17. class Resource
  18. {
  19.         private String name;
  20.         private int count = 1;
  21.         private boolean flag = false;

  22. //        创建一个锁对象。
  23.         Lock lock = new ReentrantLock();

  24.         //通过已有的锁获取该锁上的监视器对象。
  25. //        Condition con = lock.newCondition();

  26.         //通过已有的锁获取两组监视器,一组监视生产者,一组监视消费者。
  27.         Condition producer_con = lock.newCondition();
  28.         Condition consumer_con = lock.newCondition();

  29.        
  30.         public  void set(String name)//  t0 t1
  31.         {
  32.                 lock.lock();
  33.                 try
  34.                 {
  35.                         while(flag)
  36. //                        try{lock.wait();}catch(InterruptedException e){}//   t1    t0
  37.                         try{producer_con.await();}catch(InterruptedException e){}//   t1    t0
  38.                
  39.                         this.name = name + count;//烤鸭1  烤鸭2  烤鸭3
  40.                         count++;//2 3 4
  41.                         System.out.println(Thread.currentThread().getName()+"...生产者5.0..."+this.name);//生产烤鸭1 生产烤鸭2 生产烤鸭3
  42.                         flag = true;
  43. //                        notifyAll();
  44. //                        con.signalAll();
  45.                         consumer_con.signal();
  46.                 }
  47.                 finally
  48.                 {
  49.                         lock.unlock();
  50.                 }
  51.                
  52.         }

  53.         public  void out()// t2 t3
  54.         {
  55.                 lock.lock();
  56.                 try
  57.                 {
  58.                         while(!flag)
  59. //                        try{this.wait();}catch(InterruptedException e){}        //t2  t3
  60.                         try{cousumer_con.await();}catch(InterruptedException e){}        //t2  t3
  61.                         System.out.println(Thread.currentThread().getName()+"...消费者.5.0......."+this.name);//消费烤鸭1
  62.                         flag = false;
  63. //                        notifyAll();
  64. //                        con.signalAll();
  65.                         producer_con.signal();
  66.                 }
  67.                 finally
  68.                 {
  69.                         lock.unlock();
  70.                 }
  71.                
  72.         }
  73. }

  74. class Producer implements Runnable
  75. {
  76.         private Resource r;
  77.         Producer(Resource r)
  78.         {
  79.                 this.r = r;
  80.         }
  81.         public void run()
  82.         {
  83.                 while(true)
  84.                 {
  85.                         r.set("烤鸭");
  86.                 }
  87.         }
  88. }

  89. class Consumer implements Runnable
  90. {
  91.         private Resource r;
  92.         Consumer(Resource r)
  93.         {
  94.                 this.r = r;
  95.         }
  96.         public void run()
  97.         {
  98.                 while(true)
  99.                 {
  100.                         r.out();
  101.                 }
  102.         }
  103. }



  104. class  ProducerConsumerDemo2
  105. {
  106.         public static void main(String[] args)
  107.         {
  108.                 Resource r = new Resource();
  109.                 Producer pro = new Producer(r);
  110.                 Consumer con = new Consumer(r);

  111.                 Thread t0 = new Thread(pro);
  112.                 Thread t1 = new Thread(pro);
  113.                 Thread t2 = new Thread(con);
  114.                 Thread t3 = new Thread(con);
  115.                 t0.start();
  116.                 t1.start();
  117.                 t2.start();
  118.                 t3.start();

  119.         }
  120. }
复制代码


有一个问题,Lock lock = new ReentrantLock();这句代码是返回Lock实例,那么lock.lock();这句代码,则是调用类ReentrantLock中的lock()。同理,lock.unlock();也是调用类ReentrantLock中的unlock()。因为Lock是接口,接口中的方法是抽象方法,是没有函数体的。但是new  ReentrantLock();实现了Lock接口,所以就实现了Lock接口中所有方法,所以调用的是类ReentrantLock中的lock()。

但是,代码Condition producer_con = lock.newCondition();
                  Condition consumer_con = lock.newCondition();

lock.newCondition();这句代码返回Condition,这个我知道。那么,在下面的代码中,producer_con.await();调用的是接口Condition中的await方法,但是Condition接口中的方法没有实现,这样调用没有错吗???难道是哪里实现了Condition接口中的方法吗???难道producer_con.await();调用的不是接口Condition中的await方法???请大神帮忙看一下。

cousumer_con.await();同理。





欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2