Java并发编程（3）：线程挂起、恢复与终止的正确方法（含代码）

挂起和恢复线程

Thread 的API中包含两个被淘汰的方法，它们用于临时挂起和重启某个线程，这些方法已经被淘汰，由于它们是不安全的，不稳定的。若是在不合适的时候挂起线程（好比，锁定共享资源时），此时即可能会发生死锁条件——其余线程在等待该线程释放锁，但该线程却被挂起了，便会发生死锁。另外，在长时间计算期间挂起线程也可能致使问题。

下面的代码演示了经过休眠来延缓运行，模拟长时间运行的状况，使线程更可能在不适当的时候被挂起：

 

public class DeprecatedSuspendResume extends Object implements Runnable{
 
 //volatile关键字，表示该变量可能在被一个线程使用的同时，被另外一个线程修改
 private volatile int firstVal;
 private volatile int secondVal;
 
 //判断两者是否相等
 public boolean areValuesEqual(){
 return ( firstVal == secondVal);
 }
 
 public void run() {
 try{
 firstVal = 0;
 secondVal = 0;
 workMethod();
 }catch(InterruptedException x){
 System.out.println("interrupted while in workMethod()");
 }
 }
 
 private void workMethod() throws InterruptedException {
 int val = 1;
 while (true){
 stepOne(val);
 stepTwo(val);
 val++;
 Thread.sleep(200); //再次循环钱休眠200毫秒
 }
 }
 
 //赋值后，休眠300毫秒，从而使线程有机会在stepOne操做和stepTwo操做之间被挂起
 private void stepOne(int newVal) throws InterruptedException{
 firstVal = newVal;
 Thread.sleep(300); //模拟长时间运行的状况
 }
 
 private void stepTwo(int newVal){
 secondVal = newVal;
 }
 
 public static void main(String[] args){
 DeprecatedSuspendResume dsr = new DeprecatedSuspendResume();
 Thread t = new Thread(dsr);
 t.start();
 
 //休眠1秒，让其余线程有机会得到执行
 try {
 Thread.sleep(1000);} 
 catch(InterruptedException x){}
 for (int i = 0; i < 10; i++){
 //挂起线程
 t.suspend();
 System.out.println("dsr.areValuesEqual()=" + dsr.areValuesEqual());
 //恢复线程
 t.resume();
 try{ 
 //线程随机休眠0~2秒
 Thread.sleep((long)(Math.random()*2000.0));
 }catch(InterruptedException x){
 //略
 }
 }
 System.exit(0); //中断应用程序
 }
}

某次运行结果以下：

从areValuesEqual（）返回的值有时为true，有时为false。以上代码中，在设置firstVal以后，但在设置secondVal以前，挂起新线程会产生麻烦，此时输出的结果会为false（状况1），这段时间不适宜挂起线程，但由于线程不能控制什么时候调用它的suspend方法，因此这种状况是不可避免的。

固然，即便线程不被挂起（注释掉挂起和恢复线程的两行代码），若是在main线程中执行asr.areValuesEqual（）进行比较时，恰逢stepOne操做执行完，而stepTwo操做还没执行，那么获得的结果一样多是false（状况2）。

下面咱们给出不用上述两个方法来实现线程挂起和恢复的策略——设置标志位。经过该方法实现线程的挂起和恢复有一个很好的地方，就是能够在线程的指定位置实现线程的挂起和恢复，而不用担忧其不肯定性。

对于上述代码的改进代码以下：

 

public class AlternateSuspendResume extends Object implements Runnable {
 
 private volatile int firstVal;
 private volatile int secondVal;
 //增长标志位，用来实现线程的挂起和恢复
 private volatile boolean suspended;
 
 public boolean areValuesEqual() {
 return ( firstVal == secondVal );
 }
 
 public void run() {
 try {
 suspended = false;
 firstVal = 0;
 secondVal = 0;
 workMethod();
 } catch ( InterruptedException x ) {
 System.out.println("interrupted while in workMethod()");
 }
 }
 
 private void workMethod() throws InterruptedException {
 int val = 1;
 
 while ( true ) {
 //仅当贤臣挂起时，才运行这行代码
 waitWhileSuspended(); 
 
 stepOne(val);
 stepTwo(val);
 val++;
 
 //仅当线程挂起时，才运行这行代码
 waitWhileSuspended(); 
 
 Thread.sleep(200); 
 }
 }
 
 private void stepOne(int newVal) 
 throws InterruptedException {
 
 firstVal = newVal;
 Thread.sleep(300); 
 }
 
 private void stepTwo(int newVal) {
 secondVal = newVal;
 }
 
 public void suspendRequest() {
 suspended = true;
 }
 
 public void resumeRequest() {
 suspended = false;
 }
 
 private void waitWhileSuspended() 
 throws InterruptedException {
 
 //这是一个“繁忙等待”技术的示例。
 //它是非等待条件改变的最佳途径，由于它会不断请求处理器周期地执行检查， 
 //更佳的技术是：使用Java的内置“通知-等待”机制
 while ( suspended ) {
 Thread.sleep(200);
 }
 }
 
 public static void main(String[] args) {
 AlternateSuspendResume asr = 
 new AlternateSuspendResume();
 
 Thread t = new Thread(asr);
 t.start();
 
 //休眠1秒，让其余线程有机会得到执行
 try { Thread.sleep(1000); } 
 catch ( InterruptedException x ) { }
 
 for ( int i = 0; i < 10; i++ ) {
 asr.suspendRequest();
 
 //让线程有机会注意到挂起请求
 //注意：这里休眠时间必定要大于
 //stepOne操做对firstVal赋值后的休眠时间，即300ms，
 //目的是为了防止在执行asr.areValuesEqual（）进行比较时,
 //恰逢stepOne操做执行完，而stepTwo操做还没执行
 try { Thread.sleep(350); } 
 catch ( InterruptedException x ) { }
 
 System.out.println("dsr.areValuesEqual()=" + 
 asr.areValuesEqual());
 
 asr.resumeRequest();
 
 try { 
 //线程随机休眠0~2秒
 Thread.sleep(
 ( long ) (Math.random() * 2000.0) );
 } catch ( InterruptedException x ) {
 //略
 }
 }
 
 System.exit(0); //退出应用程序
 }
}

运行结果以下：

由结果能够看出，输出的全部结果均为true。首先，针对状况1（线程挂起的位置不肯定），这里肯定了线程挂起的位置，不会出现线程在stepOne操做和stepTwo操做之间挂起的状况；针对状况2（main线程中执行asr.areValuesEqual（）进行比较时，恰逢stepOne操做执行完，而stepTwo操做还没执行），在发出挂起请求后，尚未执行asr.areValuesEqual（）操做前，让main线程休眠450ms（>300ms），若是挂起请求发出时，新线程正执行到或即将执行到stepOne操做（若是在其前面的话，就会响应挂起请求，从而挂起线程），那么在stepTwo操做执行前，main线程的休眠还没结束，从而main线程休眠结束后执行asr.areValuesEqual（）操做进行比较时，stepTwo操做已经执行完，所以也不会出现输出结果为false的状况。

能够将ars.suspendRequest（）代码后的sleep代码去掉，或将休眠时间改成200（明显小于300便可）后，查看执行结果，会发现结果中依然会有出现false的状况。以下图所示：

总结：线程的挂起和恢复实现的正确方法是：经过设置标志位，让线程在安全的位置挂起

终止线程

当调用Thread的start（）方法，执行完run（）方法后，或在run（）方法中return，线程便会天然消亡。另外Thread API中包含了一个stop（）方法，能够忽然终止线程。但它在JDK1.2后便被淘汰了，由于它可能致使数据对象的崩溃。一个问题是，当线程终止时，不多有机会执行清理工做；另外一个问题是，当在某个线程上调用stop（）方法时，线程释放它当前持有的全部锁，持有这些锁一定有某种合适的理由——也许是阻止其余线程访问还没有处于一致性状态的数据，忽然释放锁可能使某些对象中的数据处于不一致状态，并且不会出现数据可能崩溃的任何警告。

终止线程的替代方法：一样是使用标志位，经过控制标志位来终止线程。

欢迎工做一到五年的Java工程师朋友们加入Java架构开发 ： 867748702 群内提供免费的Java架构学习资料（里面有高可用、高并发、高性能及分布式、 Jvm性能调优、Spring源码，MyBatis，Netty,Redis,Kafka,Mysql,Zookeeper, Tomcat,Docker,Dubbo,Nginx等多个知识点的架构资料） 合理利用本身每一分每一秒的时间来学习提高本身， 不要再用"没有时间“来掩饰本身思想上的懒惰！趁年轻，使劲拼，给将来的本身一个交代！