Question

我在主程序中创建了三个线程。我在每个线程中都有循环。在run（）方法中执行语句后，每个线程自动被销毁或杀死。正确？我的理解是否正确？

是否有任何Java标准引用，它提到不需要显式地杀死一个线程，它本身就是这样做的。我一直在尝试阅读和浏览许多文章。但仍然没有100％的信心。

如果有任何专家能够回复并帮助我，我将不胜感激。在此先感谢!!!

public class Demo {
    TestA A = new TestA("TestA",threadAList);
    TestA B = new TestB("TestB",threadBList);
    TestA C = new TestC("TestC",threadCList);
}

class TestA implements Runnable {
    Thread t;

    public TestA(String name,List threadAList) {
        System.out.println(name);
        this.threadAList = threadAList;
        t = new Thread(this);
        t.start();
    }

    public void run() {
        try {
            System.out.println("TestA Thread started");
        }
        catch(Exception e) {
            e.printStackTrace(log);
            doing some action to move the faild file to a failure folder    
        }
        finally {
            log.close();
        }
    }
}

Answer 1

是的，一旦Runnable的{{1}}方法返回，该线程就会自动销毁并可用于垃圾回收。

Answer 2

线程在完成执行后自动过期。然而，在你的代码中提供一个点（即在关闭时）你确保线程已经完成（或等待它们finsih）这是一个好的做法，这也会让你阻止任何线程是否陷入无限循环。

Answer 3

当你的线程退出run（）方法时，它会死掉并被垃圾收集。没有必要明确杀死它。事实上，你永远不应该“杀死”或“停止”线程。线程必须通过完成run方法或者死亡而正常退出，因为抛出了未捕获的异常。确保您了解可以抛出InterruptedException的条件，并了解如何正确响应它。

http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/Thread.html

public void run() {
   try {
      while( !Thread.currentThread().isInterrupted() ) {
         try {
            // do some long running work here
         } catch( ExceptionThatDoesntStopTheThread ex ) {
            logger.warn( "Hey I got an exception, but I'm not going anywhere", ex );
         }
      }
      // if you are forced to catch InterruptedException (wait(), sleep(), etc) 
      // put it outside the loop as it signifies someone has asked this thread to 
      // shutdown.
   } catch( InterruptedException ex ) {
      logger.info("Interrupted exception received shutting down.");
   } finally {
      // clean up anything you need to handle, and log a statement
      logger.info("Thread done.");
   }
}

如果客户端想要请求线程关闭它，只需要在线程实例上调用interrupt（）：

Thread someThread = new Thread( new MyRunnable() );
...
someThread.interrupt();

Answer 4

表现良好的线程没有被杀死，它们会自行死亡。它们如何死亡，或者它们如何被告知死亡不是Java本身的一部分，而是应用程序的工件。

由于进程的严重性，在Java中杀死线程是不受欢迎的。就像OutOfMemory异常一样，许多类的设计并不是为了让地毯从它们下方拉出来。许多人检查明确检查的异常，或者他们自己控制的其他“预期”事件，但是很少有人处理JVM中可能发生的真正的蓝色事件（例如OOM和线程死亡）。例如，如果一个类执行静态初始化程序“只发生一次”，并且该初始化程序被中断，那么该类将“永远毁掉”。

这就是支持杀死线程的原因，但不建议这样做。

Answer 5

这是一个教学示例，用于演示如何在没有公开操作的情况下删除线程。

The output looks like:
    I'm dying.
    I've been burried.

class Test {
static boolean flag = true;
public static void main(String[] args) throws Exception {
    class T extends Thread {
        public T(Runnable r) {
            super(r);
        }
        protected void finalize() {
            System.out.println("I've been burried.");
            flag=false;
        }
    }
    T t = new T(new Runnable(){
        public void run() {
            System.out.println("I'm dying.");
        }});
    t.start();
    t=null;
    while(flag) {System.gc(); Thread.sleep(13);};
}    
}

我们应该明确杀死一个线程吗？

5 个答案: