点击上方“码农突围”，马上关注

这里是码农充电第一站，回复“666”，获取一份专属大礼包

真爱，请设置“星标”或点个“在看

 作者：浪舟子

 blog.csdn.net/qq_40400960/article/details/112651249

我们知道像stop、suspend这几种中断或者阻塞线程的方法在较高java版本中已经被标记上了@Deprecated过期标签，那么为什么她们曾经登上了java的历史舞台而又渐渐的推出了舞台呢，到底是人性的扭曲还是道德的沦丧呢，亦或是她们不思进取被取而代之呢，如果是被取而代之，那么取而代之的又是何方人也，本文我们将一探究竟。

一、stop的落幕

首先stop方法的作用是什么呢，用java源码中的一句注释来了解一下：Forces the thread to stop executing.，即强制线程停止执行，'Forces’似乎已经透漏出了stop方法的蛮狠无理。那么我们再看看java开发者是怎们解释stop被淘汰了的：

我们从中可以看出以下几点：

1. stop这种方法本质上是不安全的
2. 使用Thread.stop停止线程会导致它解锁所有已锁定的监视器，即直接释放当前线程已经获取到的所有锁，使得当前线程直接进入阻塞状态

我们举例来看一下上边提到的两点：

public static void main(String[] args) throws InterruptedException {
        Object o1=new Object();
        Object o2=new Object();
        Thread t1=new Thread(()->{
              synchronized (o1)
              {
                  synchronized (o2)
                  {
                      try {
                          System.out.println("t1获取到锁");
                          Thread.sleep(5000);
                          System.out.println("t1结束");
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                  }
              }
        });
        t1.start();
        Thread.sleep(1000);
        Thread t2=new Thread(()->{
            synchronized (o1)
            {
                synchronized (o2)
                {
                    try {
                        System.out.println("t2获取到锁");
                        Thread.sleep(5000);
                        System.out.println("t2结束");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t2.start();
        t1.stop();
    }

运行结果：

可以看到，当线程t1在获取到o1和o2两个锁开始执行，在还没有执行结束的时候，主线程调用了t1的stop方法中断了t1的执行，释放了t1线程获取到的所有锁，中断后t2获取到了o1和o2锁，开始执行直到结束，而t1却夭折在了sleep的时候，sleep后的代码没有执行。

因此使用stop我们在不知道线程到底运行到了什么地方，暴力的中断了线程，如果sleep后的代码是资源释放、重要业务逻辑等比较重要的代码的话，亦或是其他线程依赖t1线程的运行结果，那直接中断将可能造成很严重的后果。

那么不建议使用stop中断线程我们应该怎么去优雅的结束一个线程呢，我们可以存java开发者的注释中窥探到一种解决方案：

可以看到java开发者推荐我们使用以下两种方法来优雅的停止线程：

1.定义一个变量，由目标线程去不断的检查变量的状态，当变量达到某个状态时停止线程。

代码举例如下：

volatile static boolean flag=false;
public static void main(String[] args) throws InterruptedException {
        Object o1=new Object();
        Thread t1=new Thread(()->{
              synchronized (o1)
              {
                  try {
                      System.out.println("t1获取到锁");
                      while (!flag)
                          Thread.sleep(5000);//执行业务逻辑
                      System.out.println("t1结束");
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
        });
        t1.start();
        Thread.sleep(1000);
        Thread t2=new Thread(()->{
            synchronized (o1)
            {
                try {
                    System.out.println("t2获取到锁");
                    Thread.sleep(5000);//执行业务逻辑
                    System.out.println("t2结束");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t2.start();
        flag=true;
    }

运行结果：

2.使用interrupt方法中断线程。

代码举例如下：

public static void main(String[] args) throws InterruptedException {
        Object o1=new Object();
        Thread t1=new Thread(()->{
              synchronized (o1)
              {
                  System.out.println("t1获取到锁");
                  while (!Thread.currentThread().isInterrupted()) {
                      for (int i = 0; i < 100; i++) {
                          if(i==50)
                              System.out.println();
                          System.out.print(i+" ");
                      }
                      System.out.println();
                  }
                  System.out.println("t1结束");
              }
        });
        t1.start();
        Thread t2=new Thread(()->{
            synchronized (o1)
            {
                try {
                    System.out.println("t2获取到锁");
                    Thread.sleep(5000);//执行业务逻辑
                    System.out.println("t2结束");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t2.start();
        t1.interrupt();
    }

运行结果：

我们用while (!Thread.currentThread().isInterrupted())来不断判断当前线程是否被中断，中断的话则让线程自然消亡并释放锁。可以看到调用interrupt方法后并不会像stop那样暴力的中断线程，会等到当前运行的逻辑结束后再检查是否中断，非常的优雅。

注：运行举例代码可能不会打印出数字，这是因为t1线程运行到while(!Thread.currentThread().isInterrupted())时，主线程已经调了interrupt方法，因此多次运行可能会打印出数字。

二、suspend的落幕

suspend方法的作用是挂起某个线程直到调用resume方法来恢复该线程，但是调用了suspend方法后并不会释放被挂起线程获取到的锁，正因如此就给suspend和resume这哥俩贴上了容易引发死锁的标签，当然这也正是导致suspend和resume退出历史舞台的罪魁祸首。同样我们看看java开发者为suspend的淘汰给出的理由：

从中我们可以得出以下结论：

1. suspend具有天然的死锁倾向
2. 当某个线程被suspend后，该线程持有的锁不会被释放，其他线程也就不能访问这些资源
3. suspend某个线程后，如果在resume的过程中出现异常导致resume方法执行失败，则lock无法释放，导致死锁

接下来模拟一下由suspend引起的死锁场景，Talk is cheap,show my code：

public static void main(String[] args) throws InterruptedException {
        Object o1=new Object();
        Object o2=new Object();
        Thread t1=new Thread(()->{
              synchronized (o1)
              {
                  System.out.println("t1获取到o1锁开始执行");
                  try {
                      Thread.sleep(5000);//模拟执行业务逻辑
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
                  System.out.println("t1执行结束");
              }
        });
        t1.start();
        Thread t2=new Thread(()->{
            synchronized (o2)
            {
                System.out.println("t2获取到o2开始执行");
                try {
                    Thread.sleep(2000);//执行耗时业务
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (o1)
                {
                    System.out.println("t2获取到o1锁开始继续执行");
                }
                System.out.println("t2执行结束");
            }
        });
        t2.start();

        Thread.sleep(1000);
        t1.suspend();
        //假设抛出了一个未知异常
        int i=1/0;
        t1.resume();
    }

运行结果：

可以看到，整个程序卡的死死的，在调用resume恢复t1线程之前抛出了一个未知异常，导致t1一直挂起进而无法释放o1锁，而t2需要获取到o1锁后才能继续执行，但苦苦等待，奈何o1被t1拿捏的死死的，从此整个程序就陷入了无尽的等待中----死锁。

- END -
最近热文
•  杀毒软件 McAfee 创始人自杀，75 年传奇人生画下句号
•  大专学历造假改成了 211 拿到了抖音 Offer
•  霸气！女学霸考692分想当“程序媛”，女王式发言：也没见男生考得比我好
•  腾讯面试官：如何停止一个正在运行的线程？我一脸蒙蔽。。。