Question

我需要一个解决方案来正确地停止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。所以问题是：

如何停止线程而不抛出任何异常？

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

Answer 1

使用Thread.interrupt()是完全可以接受的方式。事实上，如上所述，它可能更适合于旗帜。原因在于，如果您处于可中断的阻塞调用（如Thread.sleep或使用java.nio频道操作），您实际上可以立即突破这些调用。

如果您使用标志，则必须等待阻止操作完成，然后您可以检查您的标志。在某些情况下，您无论如何都必须这样做，例如使用不可中断的标准InputStream / OutputStream。

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

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

就像我说的那样，Thread.interrupt()的主要优点是你可以立即打破可中断的调用，这是你不能用标志方法做的。

Answer 2

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

当你想要停止线程时，你设置这个标志并在线程上调用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.");
        }
    }
}

Answer 3

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

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

你也可以永久停止线程：

致电system.exit（这会终止您的整个过程）
调用线程对象的interrupt()方法*
查看该主题是否有一个听起来像是可行的实现方法（如kill()或stop()）

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

您在run方法实现中看到的常见模式是while(boolean){}，其中布尔值通常是名为isRunning的东西，它是其线程类的成员变量，它是＆＃39; s易失性，并且通常可以通过其他类型的setter方法访问，例如kill() { isRunnable=false; }。这些子例程很好，因为它们允许线程在终止之前释放它所拥有的任何资源。

Answer 4

您应该始终通过检查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) {
        ...

Answer 5

如果我们使用JDK 1.0，我们可以调用Thread的弃用方法stop（）来终止它。使用stop（）是非常危险的，因为它会杀死你的线程，即使它处于重要的事情中。没有办法保护自己，所以如果你发现使用stop（）的代码，你应该皱眉。

我们如何干净地关闭线程？

在Java中，启动线程很容易，但关闭它们需要大量的关注和努力。

以下是它在Java中的设计方式。在每个java线程中都有一个称为中断状态标志的标志，我们可以从外部设置，即父线程或主线程。并且线程可能偶尔检查它并停止执行。自愿.. !!方法如下：

Thread loop = new Thread(new Runnable() {
@Override
public void run() {
  while (true) {
    if (Thread.interrupted()) {
      break;
    }
    // Continue to do nothing
  }
}}); loop.start(); loop.interrupt();

来源：How to stop thread in java | MultiThreading

Answer 6

对于同步线程，我更喜欢使用CountDownLatch，这有助于线程等待进程完成。在这种情况下，worker类设置为具有给定计数的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.");
        } 
    }
}

Answer 7

一些补充资料。 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();
 }

Answer 8

我没有在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;
 }

Answer 9

通常，线程在中断时终止。那么，为什么不使用本地布尔值呢？尝试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- How can I kill a thread? without using stop();

Answer 10

有时候我会在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();}
        }

    }

如何在Java中正确停止Thread？

10 个答案: