黑马程序员技术交流社区

标题: 多线程，停止 [打印本页]
作者: 史政法    时间: 2013-2-22 11:58
标题: 多线程，停止


  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. }

  28. class StopThreadDemo
  29. {
  30.         public static void main(String[] args)
  31.         {
  32.                 StopThread st = new StopThread();

  34.                 Thread t1 = new Thread(st);
  35.                 Thread t2 = new Thread(st);

  37.                 t1.start();
  38.                 t2.start();

  40.                 int num = 0;

  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类里面的方法，怎么配合的那么默契，他抛什么他接什么，并且直接处理掉了？

作者: 胥文    时间: 2013-2-22 13:18
因为Object是上帝，所有的类都是他的子类，所以这么默契啊，
主要是由于try{}carth{}，当线程被中断之后，try{}就检测到了有问题，
然后就交给专门处理异常的carch{},这时carch 就会告诉你哪里错了
我想jvm就是这么设计的
纯属个人观点
作者: 罗海云    时间: 2013-2-22 13:21
如果线程在调用 Object 类的 wait()、wait(long) 或 wait(long, int) 方法，或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻，则其中断状态将被清除，它还将收到一个 InterruptedException。

作者: 罗海云    时间: 2013-2-22 13:22
t1.interrupt(); //这个做了中断线程的操作



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2