为什么wait ，notify， notifyAll ，这些方法要定义在object类中？

1. class Resource{  <font color="#ff0000">//这里的这个Resource类中封装了线程任务类中要执行的的代码。要实现的是两个线程要交替运行。</font>
   
2.                                 String name;
   
3.                                 String sex;
   
4. 
   
5.                                  boolean flag = true;
   
6.                                 public synchronized void put(String name,String sex){
   
7.                                         if(!flag){
   
8.                                                 try {
   
9.                                                         wait();//当标志位为false，线程wait这里其实是r.wait();<span style="color: rgb(255, 0, 0);">Resource r = new Resource().对象r就要使用wait方法。</span>
   
10.                                                 } catch (InterruptedException e1){}
    
11.                                         }
    
12.                                         this.name = name;
    
13.                                         this .sex = sex;
    
14.                                        
    
15.                                         flag = false;        //执行完后，将标志位状态改变。
    
16.                                         notify();                //并且唤醒一个线程这里其实是r.notify();
    
17.                                 }
    
18.                                
    
19.                                 public synchronized void get(){
    
20.                                         if(flag){
    
21.                                                 try {
    
22.                                                         wait();    //当标志位为true，线程wait。这里其实是r.wait();
    
23.                                                 } catch (InterruptedException e1){}
    
24.                                                 }
    
25.                                         System.out.println(name+"....."+sex);
    
26.                                        
    
27.                                         flag = true;//执行完后，将标志位状态改变。
    
28.                                         notify();//并且唤醒一个线程这里其实是r.notify();
    
29.                                         }
    
30.                                 }
    
31. 
    
32.                                 class Input implements Runnable{
    
33.                                         Resource r ;
    
34.                                         private int x=0;
    
35.                                         Input(Resource r){
    
36.                                                 this.r = r;
    
37.                                         }
    
38.                                         public  void run(){   //这里有一个线程任务
    
39.                                                 while(true){
    
40.                                                         if(x == 0){
    
41.                                                                 r.put("zhangsan","nan");//这里可以将同步代码封装
    
42.                                                         }else{
    
43.                                                                 r.put("lisi","nv");
    
44.                                                         }
    
45.                                                         x = (x+1)%2;
    
46.                                                 }
    
47.                                         }
    
48.                                 }
    
49. 
    
50.                                 class Output implements Runnable{
    
51.                                         Resource r ;
    
52.                                         Output(Resource r){
    
53.                                                 this.r = r;
    
54.                                         }
    
55.                                        
    
56.                                         public void run(){ //这里有一个线程任务
    
57.                                                 while(true){
    
58.                                                         r.get();        //这里可以将同步代码封装
    
59.                                                 }
    
60.                                         }
    
61.                                 }
    

复制代码

因为锁的对象可以是任意类型的，就是synchronized（e）中的e是任意类型的，然后wait   notify啊等等都要标明是哪个锁的，所以是Object类的

任意子类都能用的当然就定义在Object（所有类的父类）中了。
await asignal这些就没有定义在Object中了。