如何正确停止Java中的线程？

我需要一个解决方案来正确停止Java中的线程。

我有IndexProcessor实现Runnable接口的类：

public class IndexProcessor implements Runnable {

    private static final Logger LOGGER = LoggerFactory.getLogger(IndexProcessor.class);

    @Override
    public void run() {
        boolean run = true;
        while (run) {
            try {
                LOGGER.debug("Sleeping...");
                Thread.sleep((long) 15000);

                LOGGER.debug("Processing");
            } catch (InterruptedException e) {
                LOGGER.error("Exception", e);
                run = false;
            }
        }

    }
}

我有ServletContextListener启动和停止线程的类：

public class SearchEngineContextListener implements ServletContextListener {

    private static final Logger LOGGER = LoggerFactory.getLogger(SearchEngineContextListener.class);

    private Thread thread = null;

    @Override
    public void contextInitialized(ServletContextEvent event) {
        thread = new Thread(new IndexProcessor());
        LOGGER.debug("Starting thread: " + thread);
        thread.start();
        LOGGER.debug("Background process successfully started.");
    }

    @Override
    public void contextDestroyed(ServletContextEvent event) {
        LOGGER.debug("Stopping thread: " + thread);
        if (thread != null) {
            thread.interrupt();
            LOGGER.debug("Thread successfully stopped.");
        }
    }
}

但是当我关闭tomcat时，我在IndexProcessor类中得到了异常：

2012-06-09 17:04:50,671 [Thread-3] ERROR  IndexProcessor Exception
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at lt.ccl.searchengine.processor.IndexProcessor.run(IndexProcessor.java:22)
    at java.lang.Thread.run(Unknown Source)

我正在使用JDK 1.6。所以问题是：

如何停止线程并且不引发任何异常？

PS我不想使用.stop();方法，因为它已被弃用。

在IndexProcessor类中，您需要一种设置标志的方法，该标志通知线程它将需要终止，类似于run您刚刚在类范围中使用的变量。

当您希望停止线程时，可以设置该标志并join()在线程上调用并等待其结束。

通过使用volatile变量或使用与用作变量的变量同步的getter和setter方法，确保该标志是线程安全的。

public class IndexProcessor implements Runnable {

    private static final Logger LOGGER = LoggerFactory.getLogger(IndexProcessor.class);
    private volatile boolean running = true;

    public void terminate() {
        running = false;
    }

    @Override
    public void run() {
        while (running) {
            try {
                LOGGER.debug("Sleeping...");
                Thread.sleep((long) 15000);

                LOGGER.debug("Processing");
            } catch (InterruptedException e) {
                LOGGER.error("Exception", e);
                running = false;
            }
        }

    }
}

然后在SearchEngineContextListener：

public class SearchEngineContextListener implements ServletContextListener {

    private static final Logger LOGGER = LoggerFactory.getLogger(SearchEngineContextListener.class);

    private Thread thread = null;
    private IndexProcessor runnable = null;

    @Override
    public void contextInitialized(ServletContextEvent event) {
        runnable = new IndexProcessor();
        thread = new Thread(runnable);
        LOGGER.debug("Starting thread: " + thread);
        thread.start();
        LOGGER.debug("Background process successfully started.");
    }

    @Override
    public void contextDestroyed(ServletContextEvent event) {
        LOGGER.debug("Stopping thread: " + thread);
        if (thread != null) {
            runnable.terminate();
            thread.join();
            LOGGER.debug("Thread successfully stopped.");
        }
    }
}

使用Thread.interrupt()是一种完全可以接受的方式。实际上，它可能比上面建议的标志更可取。原因是，如果您处于可中断的阻塞调用（例如Thread.sleep或使用java.nio Channel操作），则实际上可以立即摆脱这些干扰。

如果使用标志，则必须等待阻止操作完成，然后才能检查标志。在某些情况下，您仍然必须执行此操作，例如使用标准的InputStream/ OutputStream不可中断。

在这种情况下，当线程被中断时，它不会中断IO，但是，您可以轻松地在代码中常规执行此操作（并且应该在可以安全地停止和清理的关键时刻执行此操作）

if (Thread.currentThread().isInterrupted()) {
  // cleanup and stop execution
  // for example a break in a loop
}

就像我说的那样，它的主要优点Thread.interrupt()是您可以立即中断可中断的调用，而使用标志方法是无法做到的。

简单的答案：您可以通过以下两种常见方式之一在内部停止线程：

• run方法命中一个return子例程。
• 运行方法完成，并隐式返回。

您还可以外部停止线程：

• 致电system.exit（这会杀死您的整个过程）
• 调用线程对象的interrupt()方法*
• 查看线程是否具有听起来像它将起作用的已实现方法（如kill()或stop()）

*：期望这应该停止线程。但是，线程在发生这种情况时实际执行的操作完全取决于开发人员在创建线程实现时编写的内容。

在run方法实现中while(boolean){}，您会看到一个常见的模式是，其中boolean通常是一个名为的名称isRunning，它是其线程类的成员变量，是易失的，并且通常可由其他线程通过setter方法（例如）进行访问kill() { isRunnable=false; }。这些子例程很不错，因为它们允许线程在终止之前释放其持有的所有资源。

您应该始终通过检查run()循环中的标志（如果有）来结束线程。

您的线程应如下所示：

public class IndexProcessor implements Runnable {

    private static final Logger LOGGER = LoggerFactory.getLogger(IndexProcessor.class);
    private volatile boolean execute;

    @Override
    public void run() {
        this.execute = true;
        while (this.execute) {
            try {
                LOGGER.debug("Sleeping...");
                Thread.sleep((long) 15000);

                LOGGER.debug("Processing");
            } catch (InterruptedException e) {
                LOGGER.error("Exception", e);
                this.execute = false;
            }
        }
    }

    public void stopExecuting() {
        this.execute = false;
    }
}

然后，您可以通过调用结束线程thread.stopExecuting()。这样线程就结束了，但是这可能要花费15秒（由于您的睡眠）。如果确实很紧急，您仍然可以调用thread.interrupt（）-但首选方式应该始终是检查标志。

为了避免等待15秒，您可以像这样分散睡眠：

        ...
        try {
            LOGGER.debug("Sleeping...");
            for (int i = 0; (i < 150) && this.execute; i++) {
                Thread.sleep((long) 100);
            }

            LOGGER.debug("Processing");
        } catch (InterruptedException e) {
        ...

通常，线程在中断时会终止。那么，为什么不使用本地布尔值呢？尝试isInterrupted（）：

Thread t = new Thread(new Runnable(){
        @Override
        public void run() {
            while(!Thread.currentThread().isInterrupted()){
                // do stuff         
            }   
        }});
    t.start();

    // Sleep a second, and then interrupt
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {}
    t.interrupt();

ref- 如何杀死线程？不使用stop（）;

为了同步线程，我更喜欢使用CountDownLatchwhich来帮助线程等到执行完毕。在这种情况下，将CountDownLatch使用具有给定计数的实例来建立工作者类。到的呼叫await的方法将阻塞，直到当前的计数达到零由于的调用countDown方法或超时集为止。这种方法允许立即中断线程，而不必等待经过指定的等待时间：

public class IndexProcessor implements Runnable {

    private static final Logger LOGGER = LoggerFactory.getLogger(IndexProcessor.class);

    private final CountDownLatch countdownlatch;
    public IndexProcessor(CountDownLatch countdownlatch) {
        this.countdownlatch = countdownlatch;
    }


    public void run() {
        try {
            while (!countdownlatch.await(15000, TimeUnit.MILLISECONDS)) {
                LOGGER.debug("Processing...");
            }
        } catch (InterruptedException e) {
            LOGGER.error("Exception", e);
            run = false;
        }

    }
}

当您要完成其他线程的执行时，请在CountDownLatch和join主线程上执行countDown ：

public class SearchEngineContextListener implements ServletContextListener {

    private static final Logger LOGGER = LoggerFactory.getLogger(SearchEngineContextListener.class);

    private Thread thread = null;
    private IndexProcessor runnable = null;
    private CountDownLatch countdownLatch = null;

    @Override
    public void contextInitialized(ServletContextEvent event) {
        countdownLatch = new CountDownLatch(1);
        Thread thread = new Thread(new IndexProcessor(countdownLatch));
        LOGGER.debug("Starting thread: " + thread);
        thread.start();
        LOGGER.debug("Background process successfully started.");
    }

    @Override
    public void contextDestroyed(ServletContextEvent event) {
        LOGGER.debug("Stopping thread: " + thread);
        if (countdownLatch != null) 
        {
            countdownLatch.countDown();
        } 
        if (thread != null) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                LOGGER.error("Exception", e);
            }
            LOGGER.debug("Thread successfully stopped.");
        } 
    }
}

一些补充信息。Java文档中建议同时使用标志和中断。

https://docs.oracle.com/javase/8/docs/technotes/guides/concurrency/threadPrimitiveDeprecation.html

private volatile Thread blinker;

public void stop() {
    blinker = null;
}

public void run() {
    Thread thisThread = Thread.currentThread();
    while (blinker == thisThread) {
        try {
            Thread.sleep(interval);
        } catch (InterruptedException e){
        }
        repaint();
    }
}

对于长时间等待的线程（例如，输入），请使用 Thread.interrupt

public void stop() {
     Thread moribund = waiter;
      waiter = null;
      moribund.interrupt();
 }

我没有在Android上使用该中断，因此我使用了这种方法，效果很好：

boolean shouldCheckUpdates = true;

private void startupCheckForUpdatesEveryFewSeconds() {
    threadCheckChat = new Thread(new CheckUpdates());
    threadCheckChat.start();
}

private class CheckUpdates implements Runnable{
    public void run() {
        while (shouldCheckUpdates){
            System.out.println("Do your thing here");
        }
    }
}

 public void stop(){
        shouldCheckUpdates = false;
 }

有时我会在onDestroy（）/ contextDestroyed（）中尝试1000次

      @Override
    protected void onDestroy() {
        boolean retry = true;
        int counter = 0;
        while(retry && counter<1000)
        {
            counter++;
            try{thread.setRunnung(false);
                thread.join();
                retry = false;
                thread = null; //garbage can coll
            }catch(InterruptedException e){e.printStackTrace();}
        }

    }