如何停止线程？
        过去用stop不过现在已经过时

我们知道。开启多线程运行，运行代码通常是循环结构
所以只要控停止循环，就可以让run方法结束，也就是线程结束

特殊情况是：
当线程处于了冻结状态，
线程由于处于冻结状态，并读不到标记，那么线程就不会结束

当没有指定的方式让冻结的线程恢复到运行状态中来的时候，就需要对冻结进行解除！
解决是：
        Thread类提供了该方法   interrupt();
        该方法可以解除wait(),sleep();join()

1. class Test implements Runnable
   
2. {
   
3.         private boolean flag = true;
   
4.         //public void run()不加同步，没有changeFlag()方法，就只有线程0和线程1在交替执行，死循环，，，没有到main线程
   
5.         //public void run()不加同步，有changeFlag()方法，线程0和线程1，mian线程交替执行。正常结束
   
6.         public synchronized void run()//加上同步，其实只有一个线程在运行run()里面的内容，threa0和main线程交替，正常结束
   
7.                                                                         //因为线程同步。里面又是条件总是满足的循环（直到changeFlag()执行）
   
8.         {
   
9.                 while(flag)
   
10.                 {               
    
11.                         try       
    
12.                         {
    
13.                                 wait();//看下面的分析
    
14.                         }
    
15. 
    
16.                         catch (InterruptedException e)
    
17.                         {
    
18.                                 System.out.println(Thread.currentThread().getName()+"**exception");
    
19.                                 flag = false;
    
20.                         }
    
21.                         System.out.println(Thread.currentThread().getName()+"...run");
    
22.                 }
    
23.         }
    
24.         public void changeFlag()
    
25.         {
    
26.                 flag = false;
    
27.         }
    
28. }
    
29. class InterruptThread
    
30. {
    
31.         public static void main(String[] args)
    
32.         {
    
33.                 Test t = new Test();
    
34.                 Thread t1 = new Thread(t);
    
35.                 Thread t2 = new Thread(t);
    
36.                 t1.start();
    
37.                 t2.start();
    
38. 
    
39.                 int num =0;
    
40.                 while(true)
    
41.                 {
    
42.                         if(num++ == 6000)
    
43.                         {
    
44.                                 t1.interrupt();
    
45.                                 t2.interrupt();
    
46.                                 //t.changeFlag();
    
47.                                 break;
    
48.                         }
    
49.                         System.out.println(Thread.currentThread().getName()+num);
    
50.                 }
    
51. 
    
52.         }
    
53. }
    
54. 
    
55. /*解析：
    
56. //run()方法同步,拥有changeFlag()功能,且有wait()操作,这时候,即使有changeFlag().无法正常结束
    
57. //因为Thread0执行，判断flag(true),进入wait状态，(重点)然后释放锁，thread1获得执行
    
58. //thread1执行，判断flag(true),进入wait状态，此时thread0和thread1都处于wait（冻结）状态。
    
59. //两个线程都是一开始就被wait了，还没来得及知道flag的值已经变化
    
60. //也就是说，两个线程都已是wait状态，即使后来改变了flag的值，因为冻结在那里，无法动，仍无法正常结束
    
61. 
    
62. 怎样才能正常结束？
    
63. 方法一（自己想的，哈哈）
    
64. 这时候就需要interrupt()强行唤醒wait。先打破wait状态，在改变flag的值就可以正常结束
    
65. 在main线程中的这几行代码即可
    
66.                         if(num++ == 6000)
    
67.                         {
    
68.                                 t1.interrupt();
    
69.                                 t2.interrupt();
    
70.                                 t.changeFlag();
    
71.                                 break;
    
72.                         }
    
73. 方法二：
    
74. 还是先打破wait状态，然后在catch中将flag直接赋值false
    
75. run()里面:
    
76.         catch (InterruptedException e)
    
77.         {
    
78.                 System.out.println(Thread.currentThread().getName()+"**exception");
    
79.                 flag = false;
    
80.         }
    
81. mian线程：
    
82.         if(num++ == 6000)
    
83.         {
    
84.                 t1.interrupt();
    
85.                 t2.interrupt();
    
86.                 break;
    
87.         }
    
88.         其实都一样，都是先打破wait,然后或者在catch处理的时候将置flag为false
    
89.                                 或者在mian里面单独处理！
    
90. */

复制代码

如何停止线程？
        过去用stop不过现在已经过时

我们知道。开启多线程运行，运行代码通常是循环结构
所以只要控停止循环，就可以让run方法结束，也就是线程结束

特殊情况是：
当线程处于了冻结状态，
线程由于处于冻结状态，并读不到标记，那么线程就不会结束

当没有指定的方式让冻结的线程恢复到运行状态中来的时候，就需要对冻结进行解除！
解决是：
        Thread类提供了该方法   interrupt();
        该方法可以解除wait(),sleep();join()

1. class Test implements Runnable
   
2. {
   
3.         private boolean flag = true;
   
4.         //public void run()不加同步，没有changeFlag()方法，就只有线程0和线程1在交替执行，死循环，，，没有到main线程
   
5.         //public void run()不加同步，有changeFlag()方法，线程0和线程1，mian线程交替执行。正常结束
   
6.         public synchronized void run()//加上同步，其实只有一个线程在运行run()里面的内容，threa0和main线程交替，正常结束
   
7.                                                                         //因为线程同步。里面又是条件总是满足的循环（直到changeFlag()执行）
   
8.         {
   
9.                 while(flag)
   
10.                 {               
    
11.                         try       
    
12.                         {
    
13.                                 wait();//看下面的分析
    
14.                         }
    
15. 
    
16.                         catch (InterruptedException e)
    
17.                         {
    
18.                                 System.out.println(Thread.currentThread().getName()+"**exception");
    
19.                                 flag = false;
    
20.                         }
    
21.                         System.out.println(Thread.currentThread().getName()+"...run");
    
22.                 }
    
23.         }
    
24.         public void changeFlag()
    
25.         {
    
26.                 flag = false;
    
27.         }
    
28. }
    
29. class InterruptThread
    
30. {
    
31.         public static void main(String[] args)
    
32.         {
    
33.                 Test t = new Test();
    
34.                 Thread t1 = new Thread(t);
    
35.                 Thread t2 = new Thread(t);
    
36.                 t1.start();
    
37.                 t2.start();
    
38. 
    
39.                 int num =0;
    
40.                 while(true)
    
41.                 {
    
42.                         if(num++ == 6000)
    
43.                         {
    
44.                                 t1.interrupt();
    
45.                                 t2.interrupt();
    
46.                                 //t.changeFlag();
    
47.                                 break;
    
48.                         }
    
49.                         System.out.println(Thread.currentThread().getName()+num);
    
50.                 }
    
51. 
    
52.         }
    
53. }
    
54. 
    
55. /*解析：
    
56. //run()方法同步,拥有changeFlag()功能,且有wait()操作,这时候,即使有changeFlag().无法正常结束
    
57. //因为Thread0执行，判断flag(true),进入wait状态，(重点)然后释放锁，thread1获得执行
    
58. //thread1执行，判断flag(true),进入wait状态，此时thread0和thread1都处于wait（冻结）状态。
    
59. //两个线程都是一开始就被wait了，还没来得及知道flag的值已经变化
    
60. //也就是说，两个线程都已是wait状态，即使后来改变了flag的值，因为冻结在那里，无法动，仍无法正常结束
    
61. 
    
62. 怎样才能正常结束？
    
63. 方法一（自己想的，哈哈）
    
64. 这时候就需要interrupt()强行唤醒wait。先打破wait状态，在改变flag的值就可以正常结束
    
65. 在main线程中的这几行代码即可
    
66.                         if(num++ == 6000)
    
67.                         {
    
68.                                 t1.interrupt();
    
69.                                 t2.interrupt();
    
70.                                 t.changeFlag();
    
71.                                 break;
    
72.                         }
    
73. 方法二：
    
74. 还是先打破wait状态，然后在catch中将flag直接赋值false
    
75. run()里面:
    
76.         catch (InterruptedException e)
    
77.         {
    
78.                 System.out.println(Thread.currentThread().getName()+"**exception");
    
79.                 flag = false;
    
80.         }
    
81. mian线程：
    
82.         if(num++ == 6000)
    
83.         {
    
84.                 t1.interrupt();
    
85.                 t2.interrupt();
    
86.                 break;
    
87.         }
    
88.         其实都一样，都是先打破wait,然后或者在catch处理的时候将置flag为false
    
89.                                 或者在mian里面单独处理！
    
90. */

复制代码