java中如何强制停止线程？

0 0

java中如何强制停止线程？3

网上很多方法，什么设置标志，当前线程自己退出，不通过监控线程来停止。这样如果当前线程本身就是需要处理很多任务，但处理这些任务需要有一个时间限制，超过这个时间限制我就必需要强制停止他怎么办呢？

用stop也是不可取的办法。有没有其它的办法呢？

问题补充：

xiaoZ5919 写道

我看tomcat停
止线程有使用抛异常的方式还有一位仁兄提到中断interpreted

我的问题场景是：

void service() {
    methodA();
    methodB();
    methodC();
    methodD();
    methodE();
}

现在service可能执行的时间会大于1分钟，但我想只要service执行时间超过一分钟（这个可以通过检测线程状态来判断是否到了这个时间），然后就强制该service所在的线程停止。不管运行到哪个位置。必需停止。类型于linux下的kill一样强制杀掉进程。

设置标志位如果我的service根本不在循环中，我也不知道该在哪个位置去加flag的判断啊。不可能每个地方都做下flag判断吧？这样的结果是不确定的。

问题补充：

OpenMind 写道

你的service是否操作某些资源，比如IO、数据库连接等等，你可以在外部强制关闭资源，这样处理线程会抛出出异常而结束。这也算是一个方法吧

这种都不是一种绝对的解决办法，如果我的service当前不是在操作IO或者一些外部资源呢，而且我也不知道当前在做什么操作。因为我要的是任何我想它停的时候就得停。

问题补充：

yx200404 写道

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class A {

	//自己设置大小,这里设置的是一个单工作线程
	final ExecutorService exec = Executors.newSingleThreadExecutor();
	
	public void send() {
			TaskThread taskThread = new TaskThread();
			Future<Object> taskFuture = exec.submit(taskThread);
			try {
				//此处看任务线程是否返回值,如果不返回,那么在1分钟后任务线程会被强行终止
				taskFuture.get(1, TimeUnit.MINUTES);
			} catch (InterruptedException ex) {
				//
			} catch (ExecutionException ex) {
				//
			} catch (TimeoutException ex) {
				//
			} finally {
				
			}

	}

	class TaskThread implements Callable<Object> {

		public Object call() throws Exception {
			methodA();  
		    methodB();  
		    methodC();  
		    methodD();  
		    methodE();  
			return false;
		}
	}
	
}

哥们些,什么年代了...还在自己搞"终止"处理~

public class StopThreadTest {
  //自己设置大小,这里设置的是一个单工作线程  
    private static boolean isTO = false;
    final ExecutorService exec = Executors.newSingleThreadExecutor();  
      
    public void send() {  
            TaskThread taskThread = new TaskThread();  
            Future<Object> taskFuture = exec.submit(taskThread);  
            try {  
                //此处看任务线程是否返回值,如果不返回,那么在1分钟后任务线程会被强行终止 
                System.err.println("taskResult:" + taskFuture.get(5, TimeUnit.SECONDS));
                System.err.println("taskStat:" + taskFuture.isCancelled());
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            } catch (ExecutionException ex) {  
                ex.printStackTrace();
            } catch (TimeoutException ex) {  
                ex.printStackTrace();
                isTO = true;
            } finally {  
                  
            }  
  
    }  
    
    public static void main(String[] args) {
        new StopThreadTest().send();
    }
  
    class TaskThread implements Callable<Object> {  
        public Object call() throws Exception {  
            for (int i = 0; i < 100000000; i++) {
                if (i % 100 == 0)
                    i -= 50;
                if (isTO)
                    System.out.println(i);
            }
            return true;  
        }  
    }  
}

为什么5秒后超时了任务线程还一直在运行？？任务线程怎么终止了？？这只是超时。

问题补充：

xiaoZ5919 写道

恩是的这是一个是超时，超过指定时间抛出timeoutexception,而不是终止，

你在taskThread执行的是死循环，这样的操作是对interrupt无效的，http://docs.oracle.com/javase/tutorial/essential/concurrency/interrupt.html
并不是所有的方法可以被中断的，只有blocking的方法例如sleep,wait,join等被阻塞的方法，如果是一个长时间执行的方法是不会被中断，无论是用yx200404提供的future +timeout，本质懂事调用interrupt，有多几篇文章可以参考
http://www.ibm.com/developerworks/java/library/j-jtp05236/index.html

Implementing cancelable tasks

Just because a task is cancelable does not mean it needs to respond to an interrupt request immediately. For tasks that execute code in a loop, it is common to check for interruption only once per loop iteration. Depending on how long the loop takes to execute, it could take some time before the task code notices the thread has been interrupted (either by polling the interrupted status with Thread.isInterrupted() or by calling a blocking method). If the task needs to be more responsive, it can poll the interrupted status more frequently. Blocking methods usually poll the interrupted status immediately on entry, throwing InterruptedException if it is set to improve responsiveness.

所以根本不可能中断一个一直在运行的线程咯。

thread

2012年1月03日 17:18

thebest
0
0 0 4

14个答案按时间排序按投票排序

0 0

shutdownNow也是best-effort尽力而为，不一定能interrupt，就象你执行的这个死循环的任务，肯定中断不了

<p>There are no guarantees beyond best-effort attempts to stop
     * processing actively executing tasks. This implementation
     * cancels tasks via {@link Thread#interrupt}, so any task that
     * fails to respond to interrupts may never terminate.

2012年1月12日 15:09

xiaoZ5919
162
0 0 4

添加评论

0 0

忘记加上exec.shutdownNow();
和xiaoZ5919 说的一样.shutdownNow会尽可能的interrupt

2012年1月12日 14:01

yx200404
371
0 0 5

添加评论

0 0

是的我是这样认为的

2012年1月09日 12:43

xiaoZ5919
162
0 0 4

添加评论

0 0

2012年1月09日 11:43

xiaoZ5919
162
0 0 4

添加评论

0 0

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class A {

	//自己设置大小,这里设置的是一个单工作线程
	final ExecutorService exec = Executors.newSingleThreadExecutor();
	
	public void send() {
			TaskThread taskThread = new TaskThread();
			Future<Object> taskFuture = exec.submit(taskThread);
			try {
				//此处看任务线程是否返回值,如果不返回,那么在1分钟后任务线程会被强行终止
				taskFuture.get(1, TimeUnit.MINUTES);
			} catch (InterruptedException ex) {
				//
			} catch (ExecutionException ex) {
				//
			} catch (TimeoutException ex) {
				//
			} finally {
				
			}

	}

	class TaskThread implements Callable<Object> {

		public Object call() throws Exception {
			methodA();  
		    methodB();  
		    methodC();  
		    methodD();  
		    methodE();  
			return false;
		}
	}
	
}

哥们些,什么年代了...还在自己搞"终止"处理~

2012年1月07日 11:37

yx200404
371
0 0 5

添加评论

0 0

请忽略我写的用interrupt方法，中断完不成这个活儿
具体参照http://www.iteye.com/topic/970055

2012年1月05日 14:10

xiaoZ5919
162
0 0 4

添加评论

0 0

当初我也有过楼主的困惑，其实回过头来想想，你出现了这种好几个方法的调用，还想要停止，对于JAVA是不可行的，从根儿上来说，设计的时候就有问题，建议重新设计这个地方，加入循环判断变量，好让其他线程可以终止此线程

2012年1月04日 22:07

libo_591
131
0 0 3

添加评论

0 0

如果是当前线程，而不是在另外一个线程中调用该线程，我觉得不用监控线程做不到，如是后者可用join(1000)然后线程是否alive,再调用interrupt中断这个线程如是当前线程可用spring+proxy调用方法的开始启动监控线程进行监控

2012年1月04日 21:44

xiaoZ5919
162
0 0 4

添加评论

0 0

你的service是否操作某些资源，比如IO、数据库连接等等，你可以在外部强制关闭资源，这样处理线程会抛出出异常而结束。这也算是一个方法吧

2012年1月04日 19:43

OpenMind
704
0 1 13

添加评论

0 0

   这个问题很多人问，告诉你吧，唯一可行的方法就是设置标志位，当超时到达时，改变标志位状态，然后任务线程每次进行任务之前根据标志位判断是否因该退出。
   用stop等方法强行终止会使任务允许状态不可控。
设置标志位可以是自定义的变量，也可以是Thread的interrupte()方法，本质是一样的。
   针对你的需求，目前只能这样做，但如果你给出详细的场景，也许有更好的方式解决问题。

2012年1月04日 09:00

OpenMind
704
0 1 13

添加评论

0 0

这个问题涉及到超时，那就必须用到监控器。现在有个Timer。可以去看看。

2012年1月03日 20:25

liuqing_2010_07
1023
0 0 5

添加评论

0 0

                if (Thread.interrupted()) {   
                    if (Thread.interrupted()) {   
                        System.out.println("Interrupted...");   
                        break;   
                    }   
                }

连续两次检查我认为是不合理，在我看来没有什么意义。
现在主要是在监控器中用interpreted，stop早已经不推荐了被干掉了。

2012年1月03日 20:23

liuqing_2010_07
1023
0 0 5

添加评论

0 0

看看下面这个能不能满足你的需求：

public class HelloWorld {
	public static void main(String[] args) throws Exception {
		System.out.println("---------------------------------------");
		// “Test2"
		Thread th2 = new Thread(new Test2());
		// 启动 Test2 线程，并在3秒之后中断该线程。
		th2.start();
		Thread.yield();

		System.out.println("Interrupting Test2...");
		th2.interrupt();

		Thread.yield();

		// 主线程结束。
		System.out.println("End of main.");
	}

	private static class Test2 implements Runnable {
		public void run() {
			// 记录线程开始时间。
			long startTime = System.currentTimeMillis();

			System.out.println("Test2 start... "
					+ "Automatically ends in 6 sec.");

			while (true) {
				// 连续判断2次Thread.interrupted()
				if (Thread.interrupted()) {
					if (Thread.interrupted()) {
						System.out.println("Interrupted...");
						break;
					}
				}

				// 如果线程2运行超过6秒将自动结束。
				if (System.currentTimeMillis() - startTime > 6000) {
					System.out.println("5 seconds...");
					break;
				}
			}
			System.out.println("Test2 end");
		}
	}
}

2012年1月03日 19:40