为什么不用stop()方法
一般来说，当一个线程的方法体执行完，这个方法就会结束了。我们一般不直接使用stop方法来终止线程，这可能会导致业务逻辑不完整或者破坏原子性的操作，一段代码可能用来输出某些重要的信息，在方法的执行中使用stop方法终止线程，会使得输出的信息破坏或者不完整；在原子操作比如重入锁的使用时，当一个线程对象多次获得锁会使得计数加一，接下来需要以相同的次数释放锁直到计数减到0，别的线程才能获得锁资源，这种操作是原子性的，因为对线程来说，他们拿到锁和最终释放锁时计数都是为0的，因此这是一种原子性操作，假设在一个对象使用锁的期间，使用stop方法强行终止线程，这会导致锁的计数不为0，即破坏了原子性操作。综合来说，我们如果要正确地终止一个线程，不应该使用stop()这种过时的方法。
比较常用的是以下两种方法：
1、使用while循环轮询标志位，为false则退出循环，结束方法体，终止线程。
2、使用interrupt()方法在线程阻塞状态下结束线程。
方法1：使用标志位
这种方法是我尝试终止线程时最初采用的方法，使用起来很方便，原理也很简单，只要在while循环里持续判断一个Boolean变量的值就可以了，一旦满足离开循环的条件，那么就可以离开线程的方法体，结束线程。
1、代码实现：
public class Test {
boolean flag=true;
public static void main(String[] args){
Test test = new Test();
test.demo();
}
public void demo(){
Thread t1 = new Thread(){
public void run() //重写run方法
{
while(flag==true)
{
System.out.println("线程在执行");
}
System.out.println("线程结束了。。。。。。。。");
}
};
t1.start();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
flag=false;
}
}
2、运行结果：
线程在执行
线程在执行
线程在执行
线程在执行
线程在执行
线程在执行
线程在执行
线程在执行
线程结束了。。。。。。。。
3、分析：我们先创建一个线程并运行它，在while循环里不断输出“线程在执行”，然后我们修改标志位为false，离开循环并结束了线程。
方法2：使用Interrupt方法（中断）
使用中断的方法可以正确结束一个线程。
使用到的API介绍：
1、interrupt()方法：对某个线程对象调用这个方法就可以把它的中断标志位置为true，但它不能立刻结束一个线程。
2、currentThread()方法：静态方法，用线程类调用获得当前线程对象的引用。
4、sleep()：使当前线程睡眠，释放资源但是不释放锁。
5、join()：等待线程终止，停住调用这个方法的当前线程，等待指定的线程运行结束。减少程序运行的不确定性。
6、start()：启动一个线程。
7、interrupted()方法：是静态方法，测试当前线程是否被中断，同时清除中断标志。也就是说，在中断标志置位后第一次调用返回true，第二次调用返回false。
8、isinterrupt()方法：这个方法由对象调用，测试线程是否已经被中断，仅仅返回标志的状态，不会对标志有任何影响。
轮询中断标志退出线程：
思路：
main方法中新建并启动线程，然后延时一段时间，置位子线程的中断标志。子线程检测到中断标志被置位，则离开循环，结束线程。
代码：
public class Test {
public static void main(String[] args){
Test test = new Test();
test.demo();
}
public void demo(){
Thread tt = new Thread()
{
public void run() {
int add=0; //记录循环次数
System.out.println("线程开始");
while(true)
{
if(this.isInterrupted())
break;
add++;
System.out.println("执行次数:"+add);
}
System.out.println("线程结束");
}
};
tt.start();
try {
Thread.sleep(5);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
tt.interrupt();
}
}
运行结果：
子线程主动抛异常，并捕获，结束线程（解决上述方案在break后还会执行后续代码的问题）
思路：
子线程try，catch代码块，准备捕获中断异常。子线程在检测到中断标志后，主动throw一个异常，被捕获并执行捕获处理程序，结束线程。
代码：
public class Test {
public static void main(String[] args){
Test test = new Test();
test.demo();
}
public void demo(){
Thread tt = new Thread()
{
public void run() {
int add=0; //记录循环次数
System.out.println("线程开始");
try{
while(true){
if(this.isInterrupted()){
System.out.println("检测到中断标志为true，抛一个异常");
throw new InterruptedException();
}
add++;
System.out.println("执行次数:"+add);
}
}catch(InterruptedException e){
System.out.println("接收到了抛出的异常，直接结束线程");
e.printStackTrace();
}
}
};
tt.start();
try {
Thread.sleep(5);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
tt.interrupt();
}
}
运行结果：
在线程睡眠时置位中断标志：
思路：
新建、运行线程并让其睡眠，然后在main方法中把中断标志置为true，子线程在睡眠中会不断查询这个标志，检测到标志为true则抛出一个中断异常，结束线程。若把sleep换为join，效果相同（都是陷入阻塞状态）。
代码：
public class Test {
public static void main(String[] args){
Test test = new Test();
test.demo();
}
public void demo(){
Thread tt = new Thread(){
public void run() {
System.out.println("线程开始");
try{
sleep(3000);
}catch(InterruptedException e){
System.out.println("捕获到了一个中断异常");
System.out.println("线程结束");
e.printStackTrace();
}
}
};
tt.start();
try {
Thread.sleep(50);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
tt.interrupt();
}
}
运行结果：
