1. public class InterruptDemo {
   
2. 
   
3.         /**
   
4.          * @param args
   
5.          */
   
6.         public static void main(String[] args)
   
7.         {
   
8.                 StopThread st=new StopThread();
   
9.                 Thread t1=new Thread(st);
   
10.                 Thread t2=new Thread(st);
    
11.                 t1.start();
    
12.                 t2.start();
    
13.                 //int num=0;
    
14.                 //while(true)
    
15.                 //{
    
16.                         //if(num++==60)
    
17.                         //{
    
18.                                 t1.interrupt();
    
19.                                 t2.interrupt();
    
20.                                 //break;
    
21.                         //}
    
22.                         //System.out.println(Thread.currentThread().getName()+"...."+num);
    
23.                 //}       
    
24.         }
    
25. }
    
26. class StopThread implements Runnable
    
27. {
    
28.         private boolean flag=true;
    
29.         public synchronized void run()
    
30.         {
    
31.                 while(flag)
    
32.                 {
    
33.                         try
    
34.                         {
    
35.                                 wait();
    
36.                         }
    
37.                         catch(InterruptedException e)
    
38.                         {
    
39.                                 System.out.println(Thread.currentThread().getName()+"...Exception");
    
40.                                 flag=false;
    
41.                         }
    
42.                         System.out.println(Thread.currentThread().getName()+"...run");
    
43.                 }
    
44.         }
    
45. }

复制代码

为什么打印结果只有
Thread-0...ExceptionThread-0...run
呢？两个线程都调用了Interrupt()呀？
加上循环后又有了
Thread-1...ExceptionThread-1...run？

1. class InterruptDemo
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 StopThread st=new StopThread();
   
6.                 Thread t1=new Thread(st);
   
7.                 Thread t2=new Thread(st);
   
8.                 t1.start();
   
9.                 t2.start();
   
10.                 t1.interrupt();
    
11.                 t2.interrupt();
    
12. 
    
13.         }
    
14. }
    
15. class StopThread implements Runnable
    
16. {
    
17.         private boolean flag=true;
    
18.         public synchronized void run()
    
19. 
    
20.         {
    
21.                 while(flag)
    
22.                 {
    
23.                         try
    
24.                         {
    
25.                                 wait();
    
26.                         }
    
27.                         catch(InterruptedException e)
    
28.                         {
    
29.                                 System.out.println(Thread.currentThread().getName()+"...Exception");                              
    
30.                                  flag=false;[color=Red]Thread-0被强制清除冻结状态后，打印了Thread-0...Exception,然后把标记改为了false,在往下打印了Thread-0...run。至此因为标记被改变，程序就结束了。所以没有后来的了[/color]
    
31.                         }
    
32.                         System.out.println(Thread.currentThread().getName()+"...run");
    
33.                 }
    
34.         }
    
35. }

复制代码

复制代码

首先要说wait
线程在执行wait的时候实际是放弃同步操作的
也就是说你一waitThread0，Thread1就有权利执行同步代码块的内容了
在进行t2.interrupt();的时候理应发生异常导致Thread1线程唤醒并打印出
Thread-1...ExceptionThread-1...run？
但是问题出在你调用t2.start()的时候
Thread1还没来得及执行wait就被执行了t2.interrupt();
此时便不会抛出异常，就不会打印Thread-1...Exception
同时由于Thread0抛异常时修改了循环标志
也不会打印Thread-1...run
这种情况不光会出现而且出现的几率相当高
有两种方法可以证明这一点
第一：加延迟，其实你的那60次循环就相当于加延迟
第二：多线程，你多生成几个线程让他们同时启动，并都调用interrupt();多运行几次
这时你就会发现多个线程里面
有几个线程有时得不到运行
但是有时候又会运行
而且你可以在run方法内的while循环内外前后都设置一个打印语句
这样你就可以轻松看见每个线程的运行顺序和运行轨迹了。。。
希望对你能有所帮助。。。
对于线程总会有很多不可思议的地方
因为线程的执行本身就是随机的，不是顺序执行

public class InterruptDemo {

        /**

         * @param args

         */

        public static void main(String[] args)

        {

                StopThread st=new StopThread();

                Thread t1=new Thread(st);

                Thread t2=new Thread(st);

                t1.start();//t1等待

                t2.start();//t2等待

                //int num=0;

                //while(true)

                //{

                        //if(num++==60)

                        //{

                                t1.interrupt();//t1被强制唤醒并重新判断while(flag)，flag=true，所以往下执行catch（）｛｝，flag变为false。

                                t2.interrupt();//t1被强制唤醒并重新判断while(flag)，flag=false，所以就不会再往下了。在while语句中，线程被唤醒后都会重新判断条件，如果为真就往下执行while语句，如果假就不会了。if语句中，线程被唤醒后就会直接往下执行。如果把while(flag)改成if(flag),Thread-1...ExceptionThread-1...run也会出现的。

                                //break;

                        //}

                        //System.out.println(Thread.currentThread().getName()+"...."+num);

                //}        
        }

}

class StopThread implements Runnable

{

        private boolean flag=true;

        public synchronized void run()

        {

                while(flag)

                {

                        try

                        {

                                wait();

                        }

                        catch(InterruptedException e)

                        {

                                System.out.println(Thread.currentThread().getName()+"...Exception");

                                flag=false;

                        }

                        System.out.println(Thread.currentThread().getName()+"...run");

                }

        }

}

叶征东 发表于 2012-8-5 12:20
public class InterruptDemo {

        /**

同学这个为什么只有Thread-0我懂了，为什么将interrupt语句的上下的注释的语句去掉后，就能打印出Thread-1了呢？

侯宪博 发表于 2012-8-5 01:26
首先要说wait
线程在执行wait的时候实际是放弃同步操作的
也就是说你一waitThread0，Thread1就有权利执行同 ...

同学这个为什么只有Thread-0我懂了，为什么将interrupt语句的上下的注释的语句去掉后，就能打印出Thread-1了呢？

左建飞 发表于 2012-8-5 18:12
同学这个为什么只有Thread-0我懂了，为什么将interrupt语句的上下的注释的语句去掉后，就能打印出Thread- ...

童鞋，你回复我这句话证明你没好好看我给你的回复。。。你注释的是单纯的60次循环，在循环的过程中Thread1得到了锁并执行了wait。。。

侯宪博 发表于 2012-8-5 18:51
童鞋，你回复我这句话证明你没好好看我给你的回复。。。你注释的是单纯的60次循环，在循环的过程中Thread ...

童鞋。我错了。嗯。我又认认真真的看了一遍你的回复。为了证明我看了，我复述你的回复如下：
加了延迟，Thread-0、Thread-1、都有更大的机会执行wait()；而不加延迟可能俩线程有一个线程没有执行wait()，从而导致了一个线程打印不出。
但是，同学，我还是笨的不懂，不是执行了一个线程后，flag就被置为false了么？那么就应该只打印一个呀。那么不就结束了么？为什么会打印俩了？

左建飞 发表于 2012-8-5 19:29
童鞋。我错了。嗯。我又认认真真的看了一遍你的回复。为了证明我看了，我复述你的回复如下：
加了延迟，T ...

这次问到点子上了，其实在线程0wait的时候他就已经放弃锁了
所以当线程1得到锁以后就会进去执行，执行到wait，线程1也wait了
就都放弃了锁
但是，当线程0和线程1执行interrupt();的时候都是等待状态就都会发生InterruptedException异常
然后就会执行catch语句块接着顺序执行
执行catch语句就会打印Thread-0...Exception和read-1...Exception
接着顺序执行就会打印Thread-0...run和Thread-1...run
也就是说flag虽说已经false了，异常处理是直接就跳进去的
不信你在run方法里while语句内外前后多加几个输出语句你就知道了
你小子还是没把我的回复理解透啊。。。
希望你在多试几遍，
至于异常为什么直接往里跳，那就是异常的知识了
你再查查资料好不。。。
继续加油哈。。。

侯宪博 发表于 2012-8-5 20:12
这次问到点子上了，其实在线程0wait的时候他就已经放弃锁了
所以当线程1得到锁以后就会进去执行，执行到w ...

完全懂了。哥们威武。
加延迟，俩个都执行到了wait(),虽然执行了t1.interrupt()后flag变成了false，但是不影响t2.interrupt()。因为t2的wait()已经执行到了。
不加延迟，俩个线程中有可能因为还没执行到wait()，但是主线程已经执行到了interrupt而没有执行异常。而导致了只打印了一个异常的错误。
是这个意思么？

左建飞 发表于 2012-8-5 21:25
完全懂了。哥们威武。
加延迟，俩个都执行到了wait(),虽然执行了t1.interrupt()后flag变成了false，但是 ...

看你骨骼清奇，维护世界和平的重任就交给你了。呵呵。。。哥们你中了。。。希望我的回答带给你些许帮助。。。:lol

问题已解决！