java通过线程控制程序执行超时_hanCSDN_20130815

package com.common;

public class InArgs_MyRunner {
	private Object classNewInstance; // 使用的对象
	private String methodname; // 调用的方法名
	private Object[] args; // 调用的参数
	private String breakMethodname; // 调用的中止方法名
	private Object[] breakArgs; // 调用中止方法的参数

	public InArgs_MyRunner() {
	}

	public InArgs_MyRunner(Object classNewInstance, String methodname, Object[] args,
			String breakMethodname, Object[] breakArgs) {
		this.classNewInstance = classNewInstance;
		this.methodname = methodname;
		this.args = args;
		this.breakMethodname = breakMethodname;
		this.breakArgs = breakArgs;
	}

	public Object getClassNewInstance() {
		return classNewInstance;
	}

	public void setClassNewInstance(Object classNewInstance) {
		this.classNewInstance = classNewInstance;
	}

	public String getMethodname() {
		return methodname;
	}

	public void setMethodname(String methodname) {
		this.methodname = methodname;
	}

	public Object[] getArgs() {
		return args;
	}

	public void setArgs(Object[] args) {
		this.args = args;
	}

	public String getBreakMethodname() {
		return breakMethodname;
	}

	public void setBreakMethodname(String breakMethodname) {
		this.breakMethodname = breakMethodname;
	}

	public Object[] getBreakArgs() {
		return breakArgs;
	}

	public void setBreakArgs(Object[] breakArgs) {
		this.breakArgs = breakArgs;
	}

}

package com.common;

public class InArgs_MyTimer {
	private long needRequestTime; // 请求返回限制时间

	public InArgs_MyTimer() {

	}

	public InArgs_MyTimer(long needRequestTime) {
		this.needRequestTime = needRequestTime;
	}

	public long getNeedRequestTime() {
		return needRequestTime;
	}

	public void setNeedRequestTime(long needRequestTime) {
		this.needRequestTime = needRequestTime;
	}
}

package com.common;

import java.lang.reflect.Method;

public class MyRunner extends Thread {
	
	private InArgs_MyRunner inargs_myrunner;
	private OutArgs outargs;
	
	

	public MyRunner(InArgs_MyRunner inargs_myrunner, OutArgs outargs) {
		super();
		this.inargs_myrunner = inargs_myrunner;
		this.outargs = outargs;
	}


	@Override
	public void run() {
		if (inargs_myrunner.getMethodname() != null) {
			try {
				// Class clazz = Class.forName(arg[0]); // 得到类名
				Class clazz = inargs_myrunner.getClassNewInstance().getClass();
				Class[] clazzs = null;
				if(inargs_myrunner.getArgs()!=null&&inargs_myrunner.getArgs().length>0){
				clazzs = new Class[inargs_myrunner.getArgs().length]; // 得到参数类型
				for (int i = 0, len = inargs_myrunner.getArgs().length; i < len; i++) {
					clazzs[i] = inargs_myrunner.getArgs()[i].getClass();
				}
				}
				Method method = null;
				try {
					method = clazz.getDeclaredMethod(inargs_myrunner.getMethodname(), clazzs);// 根据参数查找方法，也有可能出错，由于反射要求严格，比如说，传一个子类对象过去，他不会找到父类方法的参数
					outargs.setResult(method.invoke(inargs_myrunner.getClassNewInstance(), inargs_myrunner.getArgs()));
					outargs.setReturnType(method.getReturnType());
					outargs.setComplete(true);
				} catch (Exception e) {
					// e.printStackTrace();
					Method[] methods = clazz.getDeclaredMethods();
					for (int i = 0; i < methods.length; i++) {
						Method currMethod = methods[i];
						// 如果名字相同，参数数目相同，我们简单的认为就是我们的方法
						if (currMethod.getName().equals(inargs_myrunner.getMethodname())
								&& currMethod.getParameterTypes().length == inargs_myrunner.getArgs().length) {
							method = currMethod;
							try {
								outargs.setResult(method.invoke(inargs_myrunner.getClassNewInstance(), inargs_myrunner.getArgs()));
								outargs.setReturnType(method.getReturnType());
								outargs.setComplete(true);
								break;
							} catch (Exception e1) {
								continue;
							}
						}
					}
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}


	public InArgs_MyRunner getInargs_myrunner() {
		return inargs_myrunner;
	}

	public void setInargs_myrunner(InArgs_MyRunner inargs_myrunner) {
		this.inargs_myrunner = inargs_myrunner;
	}

	public OutArgs getOutargs() {
		return outargs;
	}

	public void setOutargs(OutArgs outargs) {
		this.outargs = outargs;
	}

	
	
}

package com.common;

import java.lang.reflect.Method;
import java.util.Timer;
import java.util.TimerTask;

/**
 * 
 * @author Administrator 用于程序超时处理
 */

public class MyTimer extends Thread {

	private InArgs_MyTimer inargs_mytimer;
	private MyRunner myRunner; // 主程序

	public MyTimer() {

	}

	public MyTimer(InArgs_MyTimer inargs_mytimer, MyRunner myRunner) {
		this.inargs_mytimer = inargs_mytimer;
		this.myRunner = myRunner;
		myRunner.getOutargs().setNeedRequestTime(inargs_mytimer.getNeedRequestTime());
	}

	@Override
	public void run() {
		final Timer timer = new Timer();
		timer.scheduleAtFixedRate(new TimerTask() {
			public void run() {
				System.out.println("现在过去的时间为"
						+ myRunner.getOutargs().getUseredRequestTime() + "毫秒");
				if (myRunner.getOutargs().isComplete()) {
					System.out.println("程序在"
							+ myRunner.getOutargs().getUseredRequestTime()
							+ "毫秒后执行完毕");
					myRunner.getOutargs().setPrograme(true);
					timer.cancel();
				}
				if (myRunner.getOutargs().getUseredRequestTime() >= inargs_mytimer
						.getNeedRequestTime()) {
					Class[] clazzs = null;
					if (myRunner.getInargs_myrunner().getBreakArgs() != null
							&& myRunner.getInargs_myrunner().getBreakArgs().length > 0) {
						clazzs = new Class[myRunner.getInargs_myrunner()
								.getBreakArgs().length]; // 得到参数类型
						for (int i = 0, len = myRunner.getInargs_myrunner()
								.getBreakArgs().length; i < len; i++) {
							clazzs[i] = myRunner.getInargs_myrunner()
									.getBreakArgs()[i].getClass();
						}
					}
					try {
						Method method = myRunner
								.getInargs_myrunner()
								.getClassNewInstance()
								.getClass()
								.getDeclaredMethod(
										myRunner.getInargs_myrunner()
												.getBreakMethodname(), clazzs);
						method.invoke(myRunner.getInargs_myrunner()
								.getClassNewInstance(), myRunner
								.getInargs_myrunner().getBreakArgs());
					} catch (Exception e) {
						e.printStackTrace();
					}
					System.out.println("程序在"
							+ myRunner.getOutargs().getUseredRequestTime()
							+ "毫秒后,因为执行超时被强制停止");
					myRunner.getOutargs().setPrograme(true);
					timer.cancel();
				}
				myRunner.getOutargs().setUseredRequestTime(
						myRunner.getOutargs().getUseredRequestTime() + 1000);
			}
		}, 0, 1000);
	}

	public MyRunner getRunner() {
		return myRunner;
	}

	public void setRunner(MyRunner myRunner) {
		this.myRunner = myRunner;
	}

	public InArgs_MyTimer getInargs_mytimer() {
		return inargs_mytimer;
	}

	public void setInargs_mytimer(InArgs_MyTimer inargs_mytimer) {
		this.inargs_mytimer = inargs_mytimer;
	}

	public MyRunner getMyRunner() {
		return myRunner;
	}

	public void setMyRunner(MyRunner myRunner) {
		this.myRunner = myRunner;
	}

}

package com.common;

public class OutArgs {

	private long needRequestTime; // 请求返回限制时间
	private long useredRequestTime; // 请求使用的时间
	private boolean complete; // 后台程序是否完成
	private boolean programe; // 主程序是否完成
	private Object result; // 返回值
	private Class returnType; // 返回类型

	public OutArgs() {

	}

	public OutArgs(long needRequestTime, long useredRequestTime,
			boolean programe, Object result, Class returnType) {
		this.needRequestTime = needRequestTime;
		this.useredRequestTime = useredRequestTime;
		this.programe = programe;
		this.result = result;
		this.returnType = returnType;
	}

	public boolean isPrograme() {
		return programe;
	}

	public void setPrograme(boolean programe) {
		this.programe = programe;
	}

	public Object getResult() {
		return result;
	}

	public void setResult(Object result) {
		this.result = result;
	}

	public Class getReturnType() {
		return returnType;
	}

	public void setReturnType(Class returnType) {
		this.returnType = returnType;
	}

	public long getNeedRequestTime() {
		return needRequestTime;
	}

	public void setNeedRequestTime(long needRequestTime) {
		this.needRequestTime = needRequestTime;
	}

	public long getUseredRequestTime() {
		return useredRequestTime;
	}

	public void setUseredRequestTime(long useredRequestTime) {
		this.useredRequestTime = useredRequestTime;
	}

	public boolean isComplete() {
		return complete;
	}

	public void setComplete(boolean complete) {
		this.complete = complete;
	}

}

package com.common;

public class TimerActionInterf {

	private InArgs_MyRunner inargs_myrunner;
	private InArgs_MyTimer inargs_mytimer;
	private OutArgs outargs;
	private boolean isNeedTimer; // 是否需要定时器

	public TimerActionInterf(InArgs_MyRunner inargs_myrunner,
			InArgs_MyTimer inargs_mytimer, OutArgs outargs, boolean isNeedTimer) {
		super();
		this.inargs_myrunner = inargs_myrunner;
		this.inargs_mytimer = inargs_mytimer;
		this.outargs = outargs;
		this.isNeedTimer = isNeedTimer;
	}

	public void execute() {
		MyRunner myRunner = new MyRunner(inargs_myrunner, outargs);
		MyTimer myTimer = new MyTimer(inargs_mytimer, myRunner);
		if (isNeedTimer)
			/**
			 * Thread.setDaemon的用法 
			 * 1. setDaemon需要在start方法调用之前使用 
			 * 2.线程划分为用户线程和后台(daemon)进程，setDaemon将线程设置为后台进程
			 * 3.如果jvm中都是后台进程，当前jvm将exit。（随之而来的，所有的一切烟消云散，包括后台线程啦） 
			 * 4. 主线程结束后， 1）用户线程将会继续运行 2） 如果没有用户线程，都是后台进程的话，那么jvm结束
			 */
			myRunner.setDaemon(true);
		myRunner.start();
		if (isNeedTimer)
			myTimer.start();
	}

	public boolean isNeedTimer() {
		return isNeedTimer;
	}

	public void setNeedTimer(boolean isNeedTimer) {
		this.isNeedTimer = isNeedTimer;
	}

	public InArgs_MyRunner getInargs_myrunner() {
		return inargs_myrunner;
	}

	public void setInargs_myrunner(InArgs_MyRunner inargs_myrunner) {
		this.inargs_myrunner = inargs_myrunner;
	}

	public InArgs_MyTimer getInargs_mytimer() {
		return inargs_mytimer;
	}

	public void setInargs_mytimer(InArgs_MyTimer inargs_mytimer) {
		this.inargs_mytimer = inargs_mytimer;
	}

	public OutArgs getOutargs() {
		return outargs;
	}

	public void setOutargs(OutArgs outargs) {
		this.outargs = outargs;
	}

}

package com.common;

public class Stu {
	
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "[Stu]{name:"+name+"}";
	}
	
	

}

package com.test;

import com.common.InArgs_MyRunner;
import com.common.InArgs_MyTimer;
import com.common.OutArgs;
import com.common.Stu;
import com.common.TimerActionInterf;

public class Test7 {

	public Stu needExecuteMethod() throws InterruptedException {
		Thread.sleep(1000);
		System.out.println("Test7--> needExecuteMethod()");
		Stu stu = new Stu();
		stu.setName("bate");
		return stu;
	}

	public void stopExecuteMethod() {
		System.out.println("Test7--> stopExecuteMethod()");
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Test7 test7 = new Test7();
		InArgs_MyRunner inargs_myrunner = new InArgs_MyRunner(test7,
				"needExecuteMethod", null, "stopExecuteMethod", null);
		InArgs_MyTimer inargs_mytimer = new InArgs_MyTimer(3 * 1000);
		OutArgs outargs = new OutArgs();
		TimerActionInterf tifa = new TimerActionInterf(inargs_myrunner,
				inargs_mytimer, outargs, true);
		tifa.execute();
		while (true) {
			if (outargs.isPrograme()) {
				if (outargs.isComplete()) {
					System.out.println("请求成功");
					System.out.println("outargs.getNeedRequestTime()->"
							+ outargs.getNeedRequestTime());
					System.out.println("outargs.getUseredRequestTime()->"
							+ outargs.getUseredRequestTime());
					System.out.println("outargs.isComplete()->"
							+ outargs.isComplete());
					System.out.println("outargs.isPrograme()->"
							+ outargs.isPrograme());
					System.out.println("outargs.getReturnType()->"
							+ outargs.getReturnType());
					System.out.println("outargs.getResult()->"
							+ outargs.getResult());
					
					Stu stu = (Stu)outargs.getResult();
					System.out.println(stu);
					
				} else {
					System.out.println("请求超时");
					System.out.println("outargs.getNeedRequestTime()->"
							+ outargs.getNeedRequestTime());
					System.out.println("outargs.getUseredRequestTime()->"
							+ outargs.getUseredRequestTime());
					System.out.println("outargs.isComplete()->"
							+ outargs.isComplete());
					System.out.println("outargs.isPrograme()->"
							+ outargs.isPrograme());
					System.out.println("outargs.getReturnType()->"
							+ outargs.getReturnType());
					System.out.println("outargs.getResult()->"
							+ outargs.getResult());
				}
				break;
			}
		}
	}
}