1. package manyThreadRun;
   
2. 
   
3. /*
   
4. * Stop方法已经过时。
   
5. *
   
6. * 如何停止线程？
   
7. * 只有一种，run方法结束。
   
8. * 开启多线程运行，运行代码通常是循环结构
   
9. *
   
10. * 只要控制住循环，就可以让run方法结束，也就是线程结束。
    
11. *
    
12. * 特殊情况：
    
13. * 当线程处于冻结状态，
    
14. * 就不会读取到标记，那么线程就不会结束。
    
15. *
    
16. * 当没有指定的方式让冻结的线程恢复到运行状态时，这是需要对冻结进行清除。
    
17. * 强制让线程恢复到运行状态中来。这样就就可以操作标记让线程结束。
    
18. *
    
19. * Thread类提供该方法 interrupt();
    
20. */
    
21. 
    
22. class StopThread implements Runnable {
    
23.         private boolean flag = true;
    
24. 
    
25.         public synchronized void run() {
    
26.                 while (flag) {
    
27.                         try {
    
28.                                 wait();
    
29.                         } catch (InterruptedException e) {
    
30.                                 System.out.println(Thread.currentThread().getName()
    
31.                                                 + "....Exception");
    
32.                                 flag = false;
    
33.                         }
    
34.                         System.out.println(Thread.currentThread().getName() + "....run");
    
35.                 }
    
36.         }
    
37. 
    
38.         public void changeFlag() {
    
39.                 flag = false;
    
40.         }
    
41. }
    
42. 
    
43. public class StopThreadDemo {
    
44. 
    
45.         /**
    
46.          * @param args
    
47.          */
    
48.         public static void main(String[] args) {
    
49.                 StopThread st = new StopThread();
    
50.                 Thread t1 = new Thread(st);
    
51.                 Thread t2 = new Thread(st);
    
52. 
    
53.                 t1.start();
    
54.                 t2.start();
    
55. 
    
56.                 int num = 0;
    
57.                 while (true) {
    
58.                         if (num++ == 60) {
    
59.                                 // st.changeFlag();
    
60.                                 t1.interrupt();
    
61.                                 t2.interrupt();
    
62.                                 break;
    
63.                         }
    
64.                         System.out.println(Thread.currentThread().getName() + "...." + num);
    
65.                 }
    
66.                 System.out.println("over");
    
67.         }
    
68. }
    

复制代码

结果有三种：
1：over
Thread-0....Exception
Thread-0....run
Thread-1....Exception
Thread-1....run
2：over
Thread-0....Exception
Thread-0....run
3：over
Thread-1....Exception
Thread-1....run

为什么结果是三种情况呢？有点糊涂

因为你在run方法上加了一个synchronized。
第一种下情况，就是t1先执行wait了，t2再执行,wait了。main再执行，一口气执行完。t1和t2都进入catch。

其它两种情况，就是当t1,或t2拿到执行权后wait了。然后执行权被main拿到了。它一口气就执行完了。
这时，被wait的线程进入了catch，改变了flag，执行完。最后一个线程判断flag为flase变结束了。

为什么我还是3分？

其实不止这三种情况，先给你解释一下这三种情况的原因：
因为主线程开启t1和t2两个线程的时候是按照先t1，后t2的顺序开启的；
但是哪一个线程先运行取决于CPU的快速切换，也就是线程运行的随机性，所以t1和t2哪一个先执行是不确定的。
t1和t2执行时都会进入wait()，所以谁先进入wait()也就不一定了。

而处于wait状态的等待线程是存在于线程池中的，当主函数interrupt的时候，t1和t2抢占资源的顺序也是随即的。
所以t1和t2谁先被唤醒也就不确定了。

解释一下你的第一种情况：
t1线程先运行进入wait状态，t2后进入wait状态。
等到主线程执行到num==60的时候开始终端wait状态的t1和t2，
t1和t2开始抢占CPU资源，当然在这t1先抢到，所以t1先执行，t2后执行。