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

当没有指定方式让冻结的线程恢复到运行状态时，这时需要对冻结进行清除。

强制让线程恢复到运行状态中来。这样就可以操作标记让线程结束。

Thread类中提供了该方法 interrupt();

恢复运行不是有notify吗？为什么还要interrupt();

问题已经解决

1. public class InterruptDemo {
   
2. 
   
3.         /**
   
4.          * 线程的终止       
   
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();//中断线程的冻结状态。跟notify/signal的区别是这是强制中断的，中断后抛出异常。
    
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. }

复制代码

这样我们就将t1线程和t2线程结束了。否则t1和t2会一直等待。这就是interrupt()的停止线程的作用。

class ThreadA {
        public static void main(String[] args) {
               
                        ThreadB b=new ThreadB();
                        b.start();
                        System.out.println("b is start....");
                        synchronized(b)//b指的是ThreadB是对象
                        {
                                try
                                {
                                System.out.println("Waiting for b to complete...");
                                b.wait();//释放了执行权，并释放了锁。被唤醒的线程会继续往下执行
                                System.out.println("Completed.Now back to main thread");
                                }catch (InterruptedException e){}
                        }
                        System.out.println("Total is :"+b.total);
        }
}
                        class ThreadB extends Thread
                        {
                                int total;
                                public void run()
                                {
                                        synchronized(this)//this代表本来对象的引用
                                        {
                                                System.out.println("ThreadB is running..");
                                                for (int i=0;i<100;i++ )
                                                {
                                                        total +=i;
                                                        System.out.println("total is "+total);
                                                }
                                        notify(); //唤醒等待的线程
                                        }       
                                }
                        }
线程同步(重点)（synchronized）
        (1)产生线程安全的原因
                A:多个线程访问出现延迟。
                B:线程访问的随机性

                注：线程安全问题在理想状态下，不容易出现，但一旦出现对软件的影响是非常大的。
        (2)如果判断一个线程程序有没有安全问题呢？
                A:多个线程操作共享数据
                B:这个操作是分多条语句执行的。
        (3)解决线程安全问题的方式
                A:同步代码块
                B:格式:
                        synchronized(对象)
                        {
                                //需要被同步的代码
                        }
        (4)同步代码块问题：
                A:同步代码块的锁是任意同一对象。
                B:当你发现你把某个程序加了同步后，还没有解决线程安全问题。
                  这个时候，你需要考虑你使用的是否是同一把锁(对象);


希望能够帮助你！！！！

sleep()方法是使线程停止一段时间的方法。在sleep 时间间隔期满后，线程不一定立即恢复执行。这是因为在那个时刻，其它线程可能正在运行而且没有被调度为放弃执行，除非(a)"醒来"的线程具有更高的优先级。　(b)正在运行的线程因为其它原因而阻塞。
　　wait()是线程交互时，如果线程对一个同步对象x 发出一个wait()调用，该线程会暂停执行，被调对象进入等待状态，直到被唤醒或等待时间到。

但我还是不怎么明白，就跑去论坛上找文章，看到了下面这篇，讲的不错，收录下来。

下面是我原来在CJSDN论坛上看到的一个贴子，涉及到同步,wait(),notify()等概念的理解，我试着根据原来的一些回复和Think in Java上的相关概念将wait()和notify()这两个方法剖析了一下，欢迎指教.

问题如下：

file://分析这段程序，并解释一下，着重讲讲synchronized、wait(),notify 谢谢！
class ThreadA
{
public static void main(String[] args)
{
ThreadB b=new ThreadB();
b.start();
System.out.println("b is start....");
synchronized(b)//括号里的b是什么意思,起什么作用?
{
try

{
System.out.println("Waiting for b to complete...");
b.wait();//这一句是什么意思，究竟让谁wait?
System.out.println("Completed.Now back to main thread");
}catch (InterruptedException e){}
}
System.out.println("Total is :"+b.total);
}
}

class ThreadB extends Thread
{
int total;
public void run()
{
synchronized(this)
{
System.out.println("ThreadB is running..");
for (int i=0;i<100;i++ )
{
total +=i;
System.out.println("total is "+total);
}
notify();
}
}
}

要分析这个程序,首先要理解notify()和wait(),为什么在前几天纪录线程的时候没有纪录这两个方法呢,因为这两个方法本来就不属于Thread类,而是属于最底层的object基础类的,也就是说不光是Thread，每个对象都有notify和wait的功能，为什么？因为他们是用来操纵锁的,而每个对象都有锁,锁是每个对象的基础,既然锁是基础的,那么操纵锁的方法当然也是最基础了.

再往下看之前呢,首先最好复习一下Think in Java的14.3.1中第3部分内容：等待和通知,也就是wait()和notify了.

按照Think in Java中的解释:"wait()允许我们将线程置入"睡眠"状态，同时又"积极"地等待条件发生改变.而且只有在一个notify()或notifyAll()发生变化的时候，线程才会被唤醒，并检查条件是否有变."

我们来解释一下这句话.
"wait()允许我们将线程置入"睡眠"状态",也就是说,wait也是让当前线程阻塞的,这一点和sleep或者suspend是相同的.那和sleep,suspend有什么区别呢?

区别在于"(wait)同时又"积极"地等待条件发生改变",这一点很关键,sleep和suspend无法做到.因为我们有时候需要通过同步（synchronized）的帮助来防止线程之间的冲突，而一旦使用同步,就要锁定对象，也就是获取对象锁,其它要使用该对象锁的线程都只能排队等着,等到同步方法或者同步块里的程序全部运行完才有机会.在同步方法和同步块中,无论sleep()还是suspend()都不可能自己被调用的时候解除锁定,他们都霸占着正在使用的对象锁不放.
而wait却可以,它可以让同步方法或者同步块暂时放弃对象锁,而将它暂时让给其它需要对象锁的人(这里应该是程序块,或线程)用,这意味着可在执行wait()期间调用线程对象中的其他同步方法!在其它情况下(sleep啊,suspend啊),这是不可能的.
但是注意我前面说的,只是暂时放弃对象锁,暂时给其它线程使用,我wait所在的线程还是要把这个对象锁收回来的呀.wait什么?就是wait别人用完了还给我啊！
好,那怎么把对象锁收回来呢?
第一种方法,限定借出去的时间.在wait()中设置参数,比如wait(1000),以毫秒为单位,就表明我只借出去1秒中,一秒钟之后,我自动收回.
第二种方法,让借出去的人通知我,他用完了,要还给我了.这时,我马上就收回来.哎,假如我设了1小时之后收回,别人只用了半小时就完了,那怎么办呢?*!当然用完了就收回了,还管我设的是多长时间啊.

那么别人怎么通知我呢?相信大家都可以想到了,notify(),这就是最后一句话"而且只有在一个notify()或notifyAll()发生变化的时候，线程才会被唤醒"的意思了.
因此,我们可将一个wait()和notify()置入任何同步方法或同步块内部，无论在那个类里是否准备进行涉及线程的处理。而且实际上,我们也只能在同步方法或者同步块里面调用wait()和notify().

这个时候我们来解释上面的程序,简直是易如反掌了.

synchronized(b){...}；的意思是定义一个同步块,使用b作为资源锁。b.wait();的意思是临时释放锁，并阻塞当前线程,好让其他使用同一把锁的线程有机会执行,在这里要用同一把锁的就是b线程本身.这个线程在执行到一定地方后用notify()通知wait的线程,锁已经用完,待notify()所在的同步块运行完之后,wait所在的线程就可以继续执行.