java 停止线程播放音频_java停止线程

停止线程

停止线程需要一定的技巧。需要做好防范措施，避免“线程不安全”。

使用Thread.interrupt()

使用interrupt停止线程

原理

对线程队形调用interrupt()方法，这个方法仅仅是给线程打一个停止状态的标记，并不会真正停止。

可以通过条件判断检验这个标记后，主动抛出异常并停止线程或后直接return，可以称之为异常法和return法。

判断interrupt标志：

Thread.java提供了两种方法。

静态方法Thread.interrupted()

线程对象的方法example.isInterrupted(),example是线程实例。

两者区别：两者都可以判断是否处于停止状态(或者说是否含有interrulted标志，更容易理解)，但是Thread.interrupted()还具有清除状态标志的功能。

假设线程a 被打入了interrupted标志，那么如果连续调用两次example.isInterrupted()，返回的是true，true

而连续两次调用Thread.interrupted()，返回的则是true、false，这是因为第二次调用Thread.interrupted()的时候，interrupted状态已经被第一次重置了。

A、抛出异常法

(1)运行状态下打入interrupted标志

继承Thread创建MyThread3，遇见interrupted标志后主动抛出InterruptedException。

package foreverly.cn.chapter1;

public class MyThread3 extends Thread {

@Override

public void run() {

super.run();

try {

for (int i = 0; i < 5000; i++) {

//检测是否含有interrupted标志

if (this.isInterrupted()) {

System.out.println("打入了interrupted标志");

System.out.println("这只是个标志，并不会直接停止运行");

// 抛出异常法

throw new InterruptedException();

}

System.out.println("i=" + i);

}

//验证线程确实终止

System.out.println("我在for下面,不会被执行");

} catch (InterruptedException e) {

System.out.println("主动抛出的异常被抓住了");

e.printStackTrace();

}

}

}

测试Test3.java

package foreverly.cn.chapter1;

public class Test3 {

public static void main(String[] args) {

try {

MyThread3 thread = new MyThread3();

thread.start();

Thread.sleep(10);

thread.interrupt();

Thread.sleep(2000);

} catch (InterruptedException e) {

System.out.println("进入main线程的catch,作用于Thread.sleep(2000)");

e.printStackTrace();

}

System.out.println("main线程结束");

}

}

输出结果：

i=1

i=2

......

i=193

i=194

i=195

打入了interrupted标志

这只是个标志，并不会直接停止运行

主动抛出的异常被抓住了

java.lang.InterruptedException

at foreverly.cn.chapter1.MyThread3.run(MyThread3.java:13)

main线程结束

for循环到i=195的时候被打入了interrupted标志，通过 if (this.isInterrupted())判断含有interrupted标志，于是throw new InterruptedException()主动抛出异常并捕获，实现了线程的终止。

当sleep与遇上了interrupted

上面讨论的是运行状态下的线程通过interrupted标志。如果sleep状态的线程被打上interrupted 标记时，或者被interrupted标志的线程调用sleep，会发生什么呢？

(1)先sleep后被打上interrupted标志

package foreverly.cn.chapter1;

public class MyThread2 extends Thread {

@Override

public void run() {

super.run();

try {

System.out.println("run begin");

// 让此线程sleep足够时间

Thread.sleep(200000000);

System.out.println("这里不会执行");

} catch (InterruptedException e) {

System.out.println("在sleep中进入catch");

e.printStackTrace();

}

}

}

是

package foreverly.cn.chapter1;

public class TestMain2 {

public static void main(String[] args) {

MyThread2 thread = new MyThread2();

thread.start();

// 让主线程sleep一段时间，保证thread线程可以进入sleep状态。

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

thread.interrupt();

System.out.println("main end");

}

}

run begin

main end

在sleep中进入catch

java.lang.InterruptedException: sleep interrupted

at java.lang.Thread.sleep(Native Method)

at foreverly.cn.chapter1.MyThread2.run(MyThread2.java:9)

注意，这里的异常并非主动抛出，说明当sleep状态的线程被打入interrupted时，会立即抛出java.lang.InterruptedException:sleep interrupted

(2)先打上interrupted标记后进入sleep

package foreverly.cn.chapter1;

public class MyThread2 extends Thread {

@Override

public void run() {

super.run();

try {

System.out.println("run begin");

while (true) {

if (this.isInterrupted()){

System.out.println("thread线程被打入interrupted标志");

break;

}

System.out.println("thread运行中...");

}

Thread.sleep(20000);

System.out.println("run end");

} catch (InterruptedException e) {

System.out.println("先interrupt，在遇到sleep,进入catch");

e.printStackTrace();

}

}

}

package foreverly.cn.chapter1;

public class TestMain2 {

public static void main(String[] args) {

MyThread2 thread = new MyThread2();

thread.start();

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

thread.interrupt();

System.out.println("main end");

}

}

输出：

thread运行中...

thread运行中...

thread运行中...

thread运行中...

thread运行中...

......

thread运行中...

thread运行中...

thread运行中...

thread运行中...

thread运行中...

thread线程被打入interrupted标志

main end

先interrupt，在遇到sleep,进入catch

java.lang.InterruptedException: sleep interrupted

at java.lang.Thread.sleep(Native Method)

at foreverly.cn.chapter1.MyThread2.run(MyThread2.java:16)

综上可知：会立即抛出java.lang.InterruptedException: sleep interrupted

B、return法

将上述抛出异常并捕获，改为直接return。

更推荐使用异常法，抛出异常可以实现程序的分流，更好的控制程序，而过多的return会污染程序。

C、stop暴力停止

这个方法太暴力了，所以被废弃了。

当对一个线程对象调用stop方法时，线程会立刻停止。(并且会抛出java.lang.ThreadDeath异常，但通常此异常不需要显示捕捉。)

说其暴力，是因为调用后立刻停止，很容易造成数据不同步。

举个例子，线程a的run方法用来改变用户名和密码，并未为了保证线程安全，避免同步修改使用了synchronized。可是，当线程运行时，改变了用户名，此时CPU资源切换到线程b,线程b中通过a.stop()把线程a暴力停止了，那么线程a只修改了用户名，却没修改密码。

所以stop被废弃。