Thread中打断线程休眠状态，打断后继续执行的两种方式：

1、通过异常方式：
void interrupt() ：中断线程。靠的是异常机制来处理。
如果线程在调用 Object 类的 wait()、wait(long) 或 wait(long, int) 方法，或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻，则其中断状态将被清除，它还将收到一个 InterruptedException。（JDK解释）

package com.sergio.study;
/**
* @ClassName: ThreadTest04
* @Description: 演示打断线程
* @author Sergio Han
* @date 2013-8-5 下午6:41:39
*
*/

public class ThreadTest01 {

        public static void main(String[] args) throws InterruptedException{
               
                Thread t = new Thread(new MyThreadInterrup());
                //给线程起名
                t.setName("t");
               
                //启动线程
                t.start();
               
                //在500ms之后唤醒，计时
                Thread.sleep(500);
               
                //打断线程
                t.interrupt();
        }
}

class MyThreadInterrup implements Runnable
{
        //重写run方法
        public void run()
        {
                try {
                        //此处发生异常
                        Thread.sleep(1000000);
                       
                        //上面方法抛出一个异常，此处语句不会被执行
                        System.out.println("是否会被执行");
                } catch (InterruptedException e) {
                        // 在此处扑获异常信息
                        e.printStackTrace();
                }
               
                for(int i = 0; i < 10; i++)
                {
                        System.out.println(Thread.currentThread().getName() + "-->" + i);
                }
        }
}




2、正确终止一个线程,通过设置一个flag值，经改变其值，然后经if语句判断来打断线程睡眠。

package com.sergio.study;
/**
* @ClassName: ThreadInterrupTest01
* @Description: 演示线程打断
* @author Sergio Han
* @date 2013-8-5 下午7:03:47
*
*/

public class ThreadInterrupTest02{

        public static void main(String[] args)throws InterruptedException {
               
                MyThreadInterrup01 mth = new MyThreadInterrup01();
               
                Thread t = new Thread(mth);
               
                //启动线程
                t.start();
               
                //5000ms后终止
                Thread.sleep(5000);
               
                //通过修改flag的值来给出条件更改，从而终止线程
                mth.flag = false;
        }
}

class MyThreadInterrup01 implements Runnable
{
        //定义一个标识值，设置为true
        boolean flag = true;
       
        //重写runnable接口中的run方法
        public void run()
        {
                for(int i = 0; i < 10; i++)
                {
                        //判断flag真假
                        if(flag)
                        {
                                try {
                                        Thread.sleep(1000);
                                       
                                        //循环输出
                                        System.out.println(Thread.currentThread().getName() + "--->" + i);
                                } catch (InterruptedException e) {
                                        //此处不用再扑获异常信息
                                }
                        }else {
                                //退出循环
                                return;
                        }
                }
        }
}

一个靠的是一场机制，一个靠的是设置flag值。所以推荐第二个方法

值得学习ing!