我需要一个解决方案来正确地停止Java中的线程。
我有IndexProcessorclass,它实现了可运行接口:
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。所以问题是:
我如何停止线程而不抛出任何异常?
附注:我不想使用.stop();方法,因为它已弃用。
使用Thread.interrupt()是一种完全可以接受的方法。事实上,它可能比上面建议的标志更可取。原因是,如果你在一个可中断的阻塞调用(如线程。睡眠或使用java。nio Channel operations),你就可以马上跳出来。
如果你使用一个标志,你必须等待阻塞操作完成,然后你可以检查你的标志。在某些情况下,无论如何你都必须这样做,比如使用标准的不可中断的InputStream/OutputStream。
在这种情况下,当线程中断时,它不会中断IO,但是,您可以在代码中轻松地常规执行此操作(并且应该在可以安全停止和清理的战略点执行此操作)。
if (Thread.currentThread().isInterrupted()) {
// cleanup and stop execution
// for example a break in a loop
}
就像我说的,Thread.interrupt()的主要优点是可以立即中断可中断调用,这是用flag方法做不到的。
您应该始终通过检查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. stopexecution()结束线程。这样线程就干净地结束了,但这需要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) {
...
对于同步线程,我更喜欢使用CountDownLatch,它可以帮助线程等待进程执行完成。在本例中,使用具有给定计数的CountDownLatch实例来设置工作者类。由于调用了countDown方法或达到了超时设置,await方法的调用将阻塞到当前计数为零。这种方法允许立即中断线程,而不需要等待指定的等待时间过去:
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上执行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();
}
简单的回答是:
你可以用以下两种方法之一在内部停止线程:
run方法命中返回子例程。
运行方法完成,并隐式返回。
你也可以从外部停止线程:
电话系统。退出(这会终止整个进程)
调用线程对象的interrupt()方法*
看看线程是否有一个听起来可行的方法(如kill()或stop())
*:期望是这应该停止一个线程。然而,当这种情况发生时,线程实际做什么完全取决于开发人员在创建线程实现时编写的内容。
你在run方法实现中看到的一个常见模式是while(boolean){},其中布尔值通常是名为isRunning的东西,它是其线程类的成员变量,它是volatile的,通常由其他线程通过sort setter方法访问,例如kill() {isRunnable=false;}。这些子例程很好,因为它们允许线程在终止之前释放它所持有的任何资源。