关于一个锁里面的多组监视器该怎么理解？我的理解是哪个线程的run里同步的等待，就是哪个线程的监视器，这么理解对吗

监视器作用在同一把锁上，同一个线上有多个监视器，有一个监视器控制等待，另外几个具体控制具体唤醒的线程

旭辉lin 发表于 2014-9-6 21:26
监视器作用在同一把锁上，同一个线上有多个监视器，有一个监视器控制等待，另外几个具体控制具体唤醒的线程 ...

光看前一句不看后一句吗，再看看后一句，监视器监视哪个线程，该怎么理解，{:2_30:}

1. class Resource {
   
2.         private String name;
   
3.         private int count = 1;
   
4.         private boolean flag = false;
   
5.         Lock lock = new ReentrantLock();
   
6.         Condition producer_con = lock.newCondition();// eclipse提示出故障,如果先敲Condition
   
7.                                                                                                         // producer_con=然后出提示
   
8.         Condition consumer_con = lock.newCondition();
   
9. 
   
10.         public void setName(String name) {//生产线
    
11.                 lock.lock();
    
12.                 try {
    
13.                         while (flag) {
    
14.                                 try {
    
15.                                         producer_con.await();//生产等待
    
16.                                 } catch (InterruptedException e) {
    
17.                                         e.printStackTrace();
    
18.                                 }
    
19.                         }
    
20.                         this.name = name + count;
    
21.                         count++;
    
22.                         System.out.println(Thread.currentThread().getName() + "生产者"
    
23.                                         + this.name);
    
24.                         flag = true;
    
25.                         consumer_con.signal();//唤醒消费
    
26.                 } finally {
    
27.                         lock.unlock();
    
28.                 }
    
29. 
    
30.         }
    
31. 
    
32.         public void getName() {//消费线
    
33.                 lock.lock();
    
34.                 try {
    
35.                         while (!flag) {
    
36.                                 try {
    
37.                                         consumer_con.await();//消费等待
    
38.                                 } catch (InterruptedException e) {
    
39.                                         e.printStackTrace();
    
40.                                 }
    
41.                         }
    
42.                         System.out.println(Thread.currentThread().getName()
    
43.                                         + "消费者------------" + this.name);
    
44.                         flag = false;
    
45.                         producer_con.signal();//唤醒生产
    
46.                 } finally {
    
47.                         lock.unlock();
    
48.                 }
    
49. 
    
50.         }
    
51. }

复制代码

旭辉lin 发表于 2014-9-7 09:31

哪个线程的run里同步的等待，就是哪个线程的监视器，这么理解对不对？

嗖都是门...