为什么thread.stop（）不起作用？

Question

我刚刚从sun的文档中了解到，当我调用thread.stop（）方法时，由于抛出ThreadDeath错误，因此run（）方法将终止，并且还释放该线程持有的所有锁，如何证明它？

我尝试了测试程序，如下所示：

    public static void main(String[] args) {
  final Object lock = new Object();
  try {
   Thread t = new Thread() {
    public synchronized void run() {
     try {
      synchronized (lock) {
       long start = System.currentTimeMillis();
       for (int i = 0; i < 10000; i++)
        System.out.println("runing.." + i);
       System.out
         .println((System.currentTimeMillis() - start) / 1000);
      }

     } catch (Throwable ex) {
      System.out.println("Caught in run: " + ex);
      ex.printStackTrace();
     }
    }
   };

   t.start();
   // Give t time to get going...
   Thread.sleep(100);
   t.stop(); // EXPECT COMPILER WARNING
  } catch (Throwable t) {
   System.out.println("Caught in main: " + t);
   t.printStackTrace();
  }

 }

仅当我在run（）方法中放置一个wait（）时，我才能捕获ThreadDeath错误，有人知道jvm如何处理stop（）的细节吗？

    public static void main(String[] args) {
  final Object lock = new Object();
  try {
   Thread t = new Thread() {
    public synchronized void run() {
     try {
      synchronized (lock) {
       wait();
       long start = System.currentTimeMillis();
       for (int i = 0; i < 10000; i++)
        System.out.println("runing.." + i);
       System.out
         .println((System.currentTimeMillis() - start) / 1000);

      }

     } catch (Throwable ex) {
      System.out.println("Caught in run: " + ex);
      ex.printStackTrace();
     }
    }
   };

   t.start();
   // Give t time to get going...
   Thread.sleep(100);
   t.stop(); // EXPECT COMPILER WARNING
  } catch (Throwable t) {
   System.out.println("Caught in main: " + t);
   t.printStackTrace();
  }

 }

Answer 1

简单的答案是，jvm没有可靠的方法来停止线程。 要停止或中断线程，目标线程需要通过进入某些可中断状态（例如sleep（）或wait（））来进行协作。

出于这个原因，Thread.stop（）方法已被弃用（其他原因）。 有关更多详细信息，请参见http://download.oracle.com/javase/1.4.2/docs/guide/misc/threadPrimitiveDeprecation.html 。

Answer 2

我认为我不能比Sun更好地解释。

以下是官方Javadoc的引文：

不推荐使用。 这种方法本质上是不安全的。 使用Thread.stop停止线程会导致它解锁所有已锁定的监视器（由于未经检查的ThreadDeath异常会在堆栈中传播，这是自然的结果）。 如果先前由这些监视器保护的任何对象处于不一致状态，则损坏的对象将对其他线程可见，从而可能导致任意行为。 stop的许多用法应由仅修改某些变量以指示目标线程应停止运行的代码代替。 目标线程应定期检查此变量，如果该变量指示要停止运行，则应按有序方式从其运行方法返回。 如果目标威胁链接文本 d等待较长时间（例如，在条件变量上），则应使用中断方法来中断等待。 有关更多信息，请参见为什么不赞成使用Thread.stop，Thread.suspend和Thread.resume？

参见此处： http : //download.oracle.com/javase/1.4.2/docs/api/java/lang/Thread.html

Answer 3

那是因为该线程在您当前的线程退出睡眠并执行t.stop之前执行。

Answer 4

Thread.stop（）不会停止线程。 而是调用Thread.stop（new ThreadDeath（）），该线程触发线程引发此错误，默认情况下将忽略该错误。 即，如果您抛出任何其他Throwable，则uncaughtException会将其打印到System.err。 来自线程组

public void uncaughtException(Thread t, Throwable e) {
if (parent != null) {
    parent.uncaughtException(t, e);
} else {
        Thread.UncaughtExceptionHandler ueh = 
            Thread.getDefaultUncaughtExceptionHandler();
        if (ueh != null) {
            ueh.uncaughtException(t, e);
        } else if (!(e instanceof ThreadDeath)) {
    System.err.print("Exception in thread \""
             + t.getName() + "\" ");
            e.printStackTrace(System.err);
        }
    }
}

关于此错误，没有其他特殊/不可思议的地方。 您的线程将以与抛出新的ThreadDeath（）时相同的方式展开。 为了进行比较，请尝试

thread.stop(new RuntimeException());

Answer 5

关于Thread.stop的解释非常正确。 构建合作可运行对象的正确方法如下：

public class MyRunnable implements Runnable {
    private volatile boolean stopped = false;
    public void stop() {
        stopped = true;
    }

    public void run() {
       // do stuff
       if (stopped) {
         // cleanup and return;
       }

       // do more stuff

       if (stopped) {
           // cleanup and return;
       }
    }
}

Runnable r = new MyRunnable();
Thread t = new Thread(r);
t.start();
r.stop();
t.join(); // if you want to wait for it to die.

要么

public class MyRunnable implements Runnable {
    public void run() {
       // do stuff
       if (Thread.currentThread().isInterrupted()) {
         // cleanup and return;
       }

       // do more stuff

       if (Thread.currentThread().isInterrupted()) {
           // cleanup and return;
       }
    }
}

Runnable r = new MyRunnable();
Thread t = new Thread(r);
t.start();
t.interrupt();
t.join(); // if you want to wait for it to die.

请注意，无论哪种情况，您的代码中都有战略性的停车点，您可以在其中检查是否应继续进行处理。 第二种方法的优势在于，可以立即中断诸如Thread.sleep和基于java.nio的I / O操作之类的中断感知操作，而不必等待您的停止点。 相反，它们将立即抛出InterruptedException（或者在NIO的情况下为ClosedByInterruptException）。 请注意，基于标准java.io的I / O不支持中断，因此您必须等待编码停止点之一。

Answer 6

真正的答案是Thread类的stop方法调用了私有的stop1方法，该方法已同步。 由于线程的run方法的实现也已同步，因此除非退出run方法，否则无法输入stop1方法。