1. 
   
2. 
   
3. class StopThread implements Runnable
   
4. {
   
5.         private boolean flag = true;
   
6.         public synchronized void run()
   
7.         {
   
8.                 while(flag)
   
9.                 {
   
10.                         try
    
11.                         {
    
12.                                 wait();//这个方法都做了什么事情？为什么interrupt()方法清除过冻结状态后，会抛出和接收到InterruptedException异常呢？
    
13.                         }
    
14.                         catch (InterruptedException e)
    
15.                         {
    
16.                                 System.out.println(Thread.currentThread().getName()+"...InterruptedException");
    
17.                                 changeFlag();
    
18.                         }
    
19.                         System.out.println(Thread.currentThread().getName()+"...run");
    
20.                 }
    
21.         }
    
22.         public void changeFlag()
    
23.         {
    
24.                 flag = false;
    
25.         }
    
26. }
    
27. 
    
28. class StopThreadDemo
    
29. {
    
30.         public static void main(String[] args)
    
31.         {
    
32.                 StopThread st = new StopThread();
    
33. 
    
34.                 Thread t1 = new Thread(st);
    
35.                 Thread t2 = new Thread(st);
    
36. 
    
37.                 t1.start();
    
38.                 t2.start();
    
39. 
    
40.                 int num = 0;
    
41. 
    
42.                 while(true)
    
43.                 {
    
44.                         if (num++ ==60 )
    
45.                         {
    
46.                                 t1.interrupt();//这个方法都做了什么事情？
    
47.                                 t2.interrupt();
    
48.                                 break;
    
49.                         }
    
50.                         System.out.println(Thread.currentThread().getName()+"..."+num);
    
51.                 }
    
52.         }
    
53. }

复制代码

我不明白的是wait()和interrupt()方法，为什么清除过冻结状态后，刚好会被wait方法抛出和接收到InterruptedException异常呢？这两个方法到底在搞什么名堂？一个是Object里面被继承过来的，一个是Thread类里面的方法，怎么配合的那么默契，他抛什么他接什么，并且直接处理掉了？

因为Object是上帝，所有的类都是他的子类，所以这么默契啊，
主要是由于try{}carth{}，当线程被中断之后，try{}就检测到了有问题，
然后就交给专门处理异常的carch{},这时carch 就会告诉你哪里错了
我想jvm就是这么设计的
纯属个人观点

如果线程在调用 Object 类的 wait()、wait(long) 或 wait(long, int) 方法，或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻，则其中断状态将被清除，它还将收到一个 InterruptedException。

t1.interrupt(); //这个做了中断线程的操作