如何对一个方法的执行时间进行超时控制？

[luopowusheng]

比如说我希望某一方法的执行时间不超过10秒钟
如果超过这个时间，程序退出或者抛出异常
这个功能如何实现？

[newjoe30]

[Quote=引用楼主 luopowusheng 的帖子:]
比如说我希望某一方法的执行时间不超过10秒钟
如果超过这个时间，程序退出或者抛出异常
这个功能如何实现？
[/Quote]

楼主应该看看多线程方面的书。一个长时间的运算的方法，应该单独放在一个线程上，而不应该放在主线程上。如果要实现楼主的功能，你的方法还是应该在一个单独的线程上，这样才能让其他线程上，停止你的方法。

否则只能修改你的方法来实现了，就是在你的方法上的循环语句的每次循环中，加入是否已超时的判断。

[luopowusheng]

程序原本是在一个单独的线程上的，只是因为某一方法执行时长的不确定性，我希望能对其进行控制。
这必然要重新启动一个线程，但现在的问题是：重新启动的线程即使判断了此方法超时，抛出了异常，
也没有办法在主线程上捕获此异常，对主线程进行控制处理

[luopowusheng]

五楼的代码我试了下
程序似乎根本就不执行call()里面的代码~~~

[Dan1980]

用一个线程去停止另一个线程是不安全的，Java中不建议这样做，所以线程的stop()方法是deprecated的。线程应该自己终止自己，即退出run()方法的执行。

对这个问题有一个实现方法就是，让想要被超时控制的任务自己去定义自己的超时条件，这样，控制超时的线程不需要深入被控制线程的内部就可以把该线程定为已超时。超时以后要执行的具体代码由被控制任务自己定义。

首先为一个想要被超时控制的任务定义一个接口TimedRunnable，该接口继承自Runnable，即它可以做为单独线程来运行。
接口中定义一个方法expire()，该方法被控制线程在判断该任务超时的时候调用：

public interface TimedRunnable extends Runnable {
	void expire();
}

下面设计控制类TimedTaskExecuter，该类有一个静态方法execute()，用来执行超时任务。
同时在类内部定义一个嵌套类ExpiringThread，它就是控制超时的线程，继承自Thread。
控制类的execute()方法中启动两个线程，一个是任务线程，一个是控制超时的线程。控制超时的线程会sleep一定时间，任务线程被限制在这个时间之前完成。一旦控制线程被唤醒，就会调用任务线程的expire()方法，这也就意味着任务超时。
当然，控制线程并没有真正去停止任务任程，只是调用了它的一个方法expire()。它告诉任务线程，必须在expire()这个方法中设法停止自己。

public class TimedTaskExecuter {
	
	private static class ExpiringThread extends Thread {
		TimedRunnable timed;
		long expired;
		ExpiringThread(TimedRunnable task, long expiredTime) {
			timed = task;
			expired = expiredTime;
		}
		public void run() {
			try {
				Thread.sleep(expired);
			} catch (InterruptedException e) { e.printStackTrace(); }
			timed.expire();
		}
	}

	public static void execute(TimedRunnable task, long expiredTime) {
		new Thread(task).start();
		new ExpiringThread(task, expiredTime).start();
	}
}

下面是一个测试程序，该程序实现了TimedRunnable接口，也就是说它愿意被执行超时控制。
可以看到，任务在超时的时候会停止自己，这个逻辑是任务自身定义的（用一个expired标志变量）。
expire()方法还给了任务在超时的时候执行更多清理工作的灵活性，比如关闭流和数据库连接等等。

public class ExpiringTest implements TimedRunnable {

	private boolean expired;

	public void run() {
		while (!expired) {
			try {
				System.out.println("I'm still running...");
				Thread.sleep(100);
			} catch (InterruptedException e) { e.printStackTrace(); }
		}
		System.out.println("expired!");
	}

	public synchronized void expire() {
		expired = true;
	}

	public static void main(String[] args) {
		TimedTaskExecuter.execute(new ExpiringTest(), 1000);
	}

}

[Dan1980]

当然也可以为所有超时任务定义一个抽象的超类TimedTask：

public abstract class TimedTask implements TimedRunnable {

    private boolean expired;

    public synchronized void expire() {
        expired = true;
    }

}

任何类只要继承TimedTask，就自动具有超时逻辑。当然，如果覆盖了expire()方法，则必须调用super.expire()。

[missmile]

[Quote=引用 11 楼 newjoe30 的回复:]
引用楼主 luopowusheng 的帖子:
比如说我希望某一方法的执行时间不超过10秒钟
如果超过这个时间，程序退出或者抛出异常
这个功能如何实现？


楼主应该看看多线程方面的书。一个长时间的运算的方法，应该单独放在一个线程上，而不应该放在主线程上。如果要实现楼主的功能，你的方法还是应该在一个单独的线程上，这样才能让其他线程上，停止你的方法。

否则只能修改你的方法来实现了，就是在你的方法上的循环语句的…
[/Quote]

支持

[ansj]

import java.util.Date;


public class Test {
public static void main(String[] args) {
Test test = new Test() ;
try {
test.fun() ;
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

public void fun() throws Exception{
Date d1 = new Date() ;
for(int i=0 ; i<100000 ; i++){
System.out.println(i);
if((new Date().getTime()-d1.getTime())>100){

throw new Exception("方法运行超时");

}
}
}
}


这样是可以不知道楼主嫌弃不

[KOOK_OKKO]

来个笨方法，呵呵

public static void main(String[] args) {
		long past = new Date().getTime();
		System.out.println("wait 10 sec....");
		while (true) {
			if (new Date().getTime() - past > 10000) {
				break;
			}
		}
		System.out.println("10 sec is past");
	}

[say___baby]

[wangyan7777]

用線程同步的辦法來解決.侍服線程和主線程通過一個變量來交流.

[danielzhan]

VC里面经常使用WaitForSingleObject(....)实现同步.
一下的文章就是在Java中实现类似的功能.文章很长,慢慢看.
http://www.ddj.com/java/184410467

[bzwm]

/**
 * @author bzwm
 *
 */
public class MethodTimeOut {
	public static void main(String args[]){
		Executer e = new Executer("obj->bzwm");
		
		e.start();
		
		try {
			e.join(1000);
		} catch (InterruptedException e1) {
			System.out.println(e.toString());
		}
		e.interrupt();
		System.out.println(e.isOver());
	}
}

class Executer extends Thread{
	
	private Object obj = null;
	
	private boolean isOver = false;
	
	public Executer(Object o){
		obj = o;
	}
	
	public void run(){
		doSomething();
	}
	
	private void doSomething(){
		System.out.println("Start do something with " + obj);
		
		try {
			sleep(1500);
		} catch (InterruptedException e) {
		}
		
		System.out.println("do something with " + obj + " over");
		isOver = true;
	}
	
	public boolean isOver(){
		return isOver;
	}
}

这样行吗

[Iangao]

请参考:对现有代码的同步(异步)调用 , 这个方法也许可以解决你的问题.

[luopowusheng]

问题目前虽然没有得到解决，但并不影响从楼上各位所给的方法中汲取解决思路
快过年了，还是结帖了吧~~~

[abc130314]

不知道符不符合你的要求
[ run() 运行完时，记得一定要改变 isFinished() 所表示的运行状态。]

    public static void g(NewInterface obj) throws Exception {
        Thread t = new Thread(obj);
        t.start();
        t.join(3 * 1000);
        if (!obj.isFinished()) {
            obj.interrupt();
            throw new Exception();
        }
    }

    public interface NewInterface extends Runnable {

        boolean isFinished();

        void interrupt();
    }

[fountian]

[Quote=引用 19 楼 dan1980 的回复:]

用一个线程去停止另一个线程是不安全的，Java中不建议这样做，所以线程的stop()方法是deprecated的。线程应该自己终止自己，即退出run()方法的执行。

对这个问题有一个实现方法就是，让想要被超时控制的任务自己去定义自己的超时条件，这样，控制超时的线程不需要深入被控制线程的内部就可以把该线程定为已超时。超时以后要执行的具体代码由被控制任务自己定义。

首先为一个想要被超时控……
[/Quote]


09年的帖子，也得回复一下，免得后面的兄弟再误入歧途，
呵呵，上面引用这位兄弟理解错了，他的意思是：在你的代码里中的

System.out.println("I'm still running...");

这行就就执行了N久,你咋怎么办啊？遇到同样的问题，今天看到这个帖子看了半天。。。。。

[一头头]

[Quote=引用 29 楼 fountian 的回复:]


09年的帖子，也得回复一下，免得后面的兄弟再误入歧途，
呵呵，上面引用这位兄弟理解错了，他的意思是：在你的代码里中的

Java code

System.out.println("I'm still running...");


这行就就执行了N久,你咋怎么办啊？遇到同样的问题，今天看到这个帖子看了半天。。。。。
[/Quote]


这是一个standard java无法解决的问题

使用asynchronized可以绝决这个问题 不过这个包需要在real-time Java里面找到http://java.sun.com/javase/technologies/realtime/index.jsp

[一头头]

specify the solution: The Asynchronous transfer of control. aka ATC

GOOD LUCK!

[number]

语言都和我一样是小学体育老师教的，回的人这多，就没一个看明白他意思，或者没一个明白自己代码问题在哪里的嘛。。。悲剧啊！

[liuhuanleijava]