public class Exercise {
public static void main(String[] args) {
  Exercise ex=new Exercise();
  ex.go();
}
public void go(){
  MyThread mt=new MyThread("one");
  mt.start();
}
}

class MyThread extends Thread{
private String name="";
MyThread(String s){
  name=s;
}
public void run(){
  notwait();  
  System.out.println("finished");
}
public void notwait(){
  while(true){
   try{
    System.out.println("waiting");
    wait();
   }
   catch(InterruptedException e){}
   System.out.println(name);
  }
}
}
结果为
waiting
以下是运行异常显示的东东
Exception in thread "Thread-0" java.lang.IllegalMonitorStateException
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Object.java:485)
at mypackage.MyThread.notwait(Exercise.java:34)
at mypackage.MyThread.run(Exercise.java:24)

1. package Day17;
   
2. public class Test2 {
   
3.         public static void main(String[] args) {
   
4.           Test2 ex=new Test2();
   
5.           ex.go();
   
6.         }
   
7.         public void go(){
   
8.           MyThread mt=new MyThread("one");
   
9.           mt.start();
   
10.         }
    
11.         }
    
12. 
    
13.         class MyThread extends Thread{
    
14.         private String name="";
    
15.         MyThread(String s){
    
16.           name=s;
    
17.         }
    
18.         public void run(){
    
19.           notwait();  
    
20.           System.out.println("finished");
    
21.         }
    
22.         public void notwait(){
    
23.           while(true){
    
24.            try{
    
25.             System.out.println("waiting");
    
26.             wait();
    
27.            }
    
28.            catch(Exception e){}// InterruptedException//线程中断异常.这里不能用这个类
    
29.            System.out.println(name);
    
30.           }
    
31.         }
    
32.         }

复制代码

wait与notify方法都是定义在Object类中，而且是final的，因此会被所有的Java类所继承并且无法重写。
这两个方法要求在调用时线程应该已经获得了对象的锁，因此对这两个方法的调用需要放在synchronized方法或块当中。
当线程执行了wait方法时，它会释放掉对象的锁。
因而，你起了这个线程，没有设置同步方法或同步代码块，因而它不会涉及wait和notify的问题。
再看这个异常的api说明：
抛出的异常表明某一线程已经试图等待对象的监视器，或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程。
监视器即锁，没有synchronized方法或者代码块，因而没有监视器，你调用wait（）当然抛出异常了。