1、使用stop()方法，已被弃用。原因是：stop()是立即终止，会导致一些数据被到处理一部分就会被终止，而用户并不知道哪些数据被处理，哪些没有被处理，产生了不完整的“残疾”数据，不符合完整性，所以被废弃。So, forget it!
2、使用volatile标志位
看一个简单的例子：
首先，实现一个Runnable接口，在其中定义volatile标志位，在run()方法中使用标志位控制程序运行
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
public class MyRunnable implements Runnable { //定义退出标志，true会一直执行，false会退出循环 //使用volatile目的是保证可见性，一处修改了标志，处处都要去主存读取新的值，而不是使用缓存 public volatile boolean flag = true; public void run() { System.out.println("第" + Thread.currentThread().getName() + "个线程创建"); try { Thread.sleep(1000L); } catch (InterruptedException e) { e.printStackTrace(); } //退出标志生效位置 while (flag) { } System.out.println("第" + Thread.currentThread().getName() + "个线程终止"); } } |
然后，在main()方法中创建线程，在合适的时候，修改标志位，终止运行中的线程。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
public class TreadTest { public static void main(String[] arg) throws InterruptedException { MyRunnable runnable = new MyRunnable(); //创建3个线程 for (int i = 1; i <= 3; i++) { Thread thread = new Thread(runnable, i + ""); thread.start(); } //线程休眠 Thread.sleep(2000L); System.out.println("——————————————————————————"); //修改退出标志，使线程终止 runnable.flag = false; } } |
最后，运行结果，如下：
|
1
2
3
4
5
6
7
|
第1个线程创建第2个线程创建第3个线程创建--------------------------第3个线程终止第1个线程终止第2个线程终止 |
3、使用interrupt()中断的方式，注意使用interrupt()方法中断正在运行中的线程只会修改中断状态位，可以通过isInterrupted()判断。如果使用interrupt()方法中断阻塞中的线程，那么就会抛出InterruptedException异常，可以通过catch捕获异常，然后进行处理后终止线程。有些情况，我们不能判断线程的状态，所以使用interrupt()方法时一定要慎重考虑。
第一种：正在运行中终止
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public class MyThread extends Thread { public void run(){ super.run(); try { for(int i=0; i<500000; i++){ if(this.interrupted()) { System.out.println("线程已经终止， for循环不再执行"); throw new InterruptedException(); } System.out.println("i="+(i+1)); } System.out.println("这是for循环外面的语句，也会被执行"); } catch (InterruptedException e) { System.out.println("进入MyThread.java类中的catch了。。。"); e.printStackTrace(); } }} |
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public class Run { public static void main(String args[]){ Thread thread = new MyThread(); thread.start(); try { Thread.sleep(2000); thread.interrupt(); } catch (InterruptedException e) { e.printStackTrace(); } }} |
运行结果如下：
|
1
2
3
4
5
6
7
8
|
...i=203798i=203799i=203800线程已经终止， for循环不再执行进入MyThread.java类中的catch了。。。java.lang.InterruptedException at thread.MyThread.run(MyThread.java:13) |
第二种：阻塞状态（sleep,wait等）终止
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public class MyThread extends Thread { public void run(){ super.run(); try { System.out.println("线程开始。。。"); Thread.sleep(200000); System.out.println("线程结束。"); } catch (InterruptedException e) { System.out.println("在沉睡中被停止, 进入catch， 调用isInterrupted()方法的结果是：" + this.isInterrupted()); e.printStackTrace(); } }} |
|
1
2
3
4
5
|
线程开始。。。在沉睡中被停止, 进入catch， 调用isInterrupted()方法的结果是：falsejava.lang.InterruptedException: sleep interrupted at java.lang.Thread.sleep(Native Method) at thread.MyThread.run(MyThread.java:12) |
从打印的结果来看， 如果在sleep状态下停止某一线程，会进入catch语句，并且清除停止状态值，使之变为false。
前一个实验是先sleep然后再用interrupt()停止，与之相反的操作在学习过程中也要注意：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
public class MyThread extends Thread { public void run(){ super.run(); try { System.out.println("线程开始。。。"); for(int i=0; i<10000; i++){ System.out.println("i=" + i); } Thread.sleep(200000); System.out.println("线程结束。"); } catch (InterruptedException e) { System.out.println("先停止，再遇到sleep，进入catch异常"); e.printStackTrace(); } }}public class Run { public static void main(String args[]){ Thread thread = new MyThread(); thread.start(); thread.interrupt(); }} |
运行结果：
|
1
2
3
4
5
6
|
i=9998i=9999先停止，再遇到sleep，进入catch异常java.lang.InterruptedException: sleep interrupted at java.lang.Thread.sleep(Native Method) at thread.MyThread.run(MyThread.java:15) |
感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！
