1. class Resource{
   
2.         String name;
   
3.         int age;
   
4.         boolean flag=false;
   
5.         Resource(){}
   
6.         Resource(String name,int age){
   
7.                 this.name=name;
   
8.                 this.age=age;
   
9.         }
   
10. }
    
11. 
    
12. class Input implements Runnable{
    
13.         Resource s=null;
    
14.         Input(Resource s){
    
15.                 this.s=s;
    
16.         }
    
17.         public void run(){
    
18.                 int x=0;
    
19.                 while(true)
    
20.                 synchronized(s){
    
21.                         if(s.flag)
    
22.                                 try{s.wait();}catch(Exception e){}//这里如果我把s.wait()改成wait(),程序运行的结果就和之前不一样了
    
23.           if(x%2==0){
    
24.                                 s.name="lidaofu";
    
25.                                 s.age=24;
    
26.                         }else{
    
27.                                 s.name="李道福";
    
28.                                 s.age=23;
    
29.                         }
    
30.                         x=(x+1)%2;
    
31.                         s.flag=true;
    
32.                         s.notify();
    
33.                 }
    
34.         }
    
35. }
    
36. 
    
37. class Output implements Runnable{
    
38.         Resource s=null;
    
39.         Output(Resource r){
    
40.                 this.s=r;
    
41.         }
    
42.         public void run(){
    
43.                 while(true)
    
44.                 synchronized(s){
    
45.                         if(!s.flag)
    
46.                                 try{s.wait();}catch(Exception e){}
    
47.                         System.out.println(s.name+"++++++"+s.age);
    
48.                         s.flag=false;
    
49.                         s.notify();
    
50.                 }
    
51.         }
    
52. }
    
53. 
    
54. 
    
55. public class ProduConsume{
    
56.         public static void main(String[] args){
    
57.                 Resource r=new Resource();
    
58.                 Input in=new Input(r);
    
59.                 Output out=new Output(r);
    
60.                
    
61.                 Thread th=new Thread(in);
    
62.                 Thread th2=new Thread(out);
    
63.                 th.start();
    
64.                 th2.start();
    
65.         }
    
66. }

复制代码

这里的s.wait()和s.notity()等待，唤醒的是s这个线程池中的线程，那如果我改成wait()，那这个wait()把线程放在那个线程池中的？

一定要指定对象才可以等待吧，否则的话，多线程，就不一定是哪个线程抢到wait执行权······

好像只写 wait的话, 不论哪个线程碰到,都要等待.  

如果你把wait（）上的锁去掉的话，就会出现同步嵌套，非静态默认的锁是this,wait(),notify(),notifyAll()这些方法在使用的时候必须指定线程所持有监视器（锁），因为只有同一个监视器上的被等待线程，可以被同一个监视器上的notify（）唤醒，不可以对不同锁中的线程进行唤醒，所以必须使用同一个监视器（锁）对象来调用这些方法。

这里的s相当于同步中的监视器
如果wait（）前面没有s这类似的监视器的话，那么就不能保证输入域输出线程之间的同步，可能存在安全问题
如果是这样的话，使用wait方法也就没什么作用

wait()方法是Object中的方法，也就是说在调用wait方法的时候需要加上监视器对象，不然的话就成了这个类在调用wait()方法了，也就是相当于程序中的Input.wait()  
这时候就会报wait()的所有者不是监视器对象这个异常了，而你在这里对这个异常做了处理，所以程序会继续运行下去，只不过相当于wait()这个方法是无效的 如果在异常处理语句中加上处理内容，就很容易看出来了

try{wait();}catch(Exception e){System.out.println("fda");
                                e.printStackTrace();}

李政 发表于 2013-9-10 23:11
wait()方法是Object中的方法，也就是说在调用wait方法的时候需要加上监视器对象，不然的话就成了这个类在调 ...

多谢……