关于超时任务的实现，多线程同步、kill时，有点让我意外，请各位帮忙看一下是什么原因，谢谢

Question

实现功能：处理一批任务，如果某个任务的处理时间超过最大处理时间，则终止该任务的执行，继续执行下一个任务
实现思路：三线程实现，处理一个任务时，启动一个任务处理线程处理方案，再启动一个定时器线程检测是否超时，并通过一个同步变量保证任务时串行执行的。实现代码如下：疑问：
1、在Java中，类似超时任务的处理有没有其它的实现方式？
2、下面几个异常会无规律地出现，想不明白其中的道理，请明白人帮忙解释一下，
2.1、没有执行“Normal Process”，也没有执行“ending ok!” ：为什么interrupt后，doSomething里没有捕获到异常？     start task!20
ThreadID:27>>> starting!
ThreadID: MonitorThread running!
ThreadID:27>>> stoping end!
end task!20
2.2、没有执行“ending ok!” ：stop后，run里后续处理不做了？ start task!18
ThreadID:25>>> starting!
ThreadID: MonitorThread running!
ThreadID:25>>>  AbNormal Proccess! processTime=18000
ThreadID:25>>> stoping end!
2.3、执行了2次“AbNormal Proccess! ”，但没有执行“ending ok!” ：为什么会打印2次？
start task!10
ThreadID:17>>> starting!
ThreadID: MonitorThread running!
ThreadID:17>>>  AbNormal Proccess! processTime=10000ThreadID:17>>>  AbNormal Proccess! processTime=10000ThreadID:17>>> stoping end!
end task!10
代码如下：package MultiThreadTest;import java.util.Timer;
import java.util.TimerTask;public class MainThread {
private Object lock = new Object(); public void waitLock() throws InterruptedException {
synchronized (lock) {
lock.wait();
}
} public void notifyLock() {
synchronized (lock) {
lock.notify();
}
} /**
 * @param args
 * @throws InterruptedException
 */
public static void main(String[] args) { MainThread mainThread = new MainThread(); for (int i = 2; i <= 20; i += 2) { System.out.println("start task!" + i);
ProccessThread proccessThread = new ProccessThread(mainThread,
i * 1000);
MonitorThread monitorThread = new MonitorThread(mainThread);
long maxProccessTime = 8 * 1000;// 每个任务的最大处理时间
Timer timer = new Timer();
timer.schedule(monitorThread, maxProccessTime);
proccessThread.start();
try {
mainThread.waitLock();
} catch (InterruptedException e) {
e.printStackTrace();
}
proccessThread.stop();
timer.cancel();
System.out.println("end task!" + i);
}
}}class MonitorThread extends TimerTask {
private MainThread mt; public MonitorThread(MainThread mt) {
super();
this.mt = mt;
} @Override
public void run() {
System.out.println("ThreadID:" + " MonitorThread running!");
mt.notifyLock();
}}class ProccessThread implements Runnable {
private MainThread mt;
private Thread thread;
private long processTime; public ProccessThread(MainThread mt, long processTime) {
super();
this.mt = mt;
this.processTime = processTime;
} private void doSomething() {
try {
// do something
// thread.sleep(100*1000); //异常情况
// thread.sleep(1*1000); //正常情况
thread.sleep(processTime); // 正常情况
System.out.println("ThreadID:" + thread.getId() + ">>>  Normal Process! processTime=" + processTime); } catch (InterruptedException e) {
// e.printStackTrace();
System.out.println("ThreadID:" + thread.getId() + ">>>  AbNormal Proccess! processTime=" + processTime);
} } public void run() {
System.out.println("ThreadID:" + thread.getId() + ">>> starting!");
doSomething();
mt.notifyLock();
System.out.println("ThreadID:" + thread.getId() + ">>> ending ok!"); } public void start() {
thread = new Thread(this);
thread.start(); } public void stop() {
thread.interrupt();// 如果任务在正常时间内不能退出，认为产生interrupt,强行地退出 （run方法正常结束）
thread.stop();
try {
Thread.sleep(1 * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("ThreadID:" + thread.getId()
+ ">>> stoping end!");
thread = null;
}
}
 

Answer 1

ddddddddddddddddddddddddddddddddddddddddddddd

Answer 2

看了这么长的代码，感觉晕
硬盘数据恢复
济南数据恢复
U盘数据恢复
raid数据恢复

Answer 3

wait(long) 方法就可以超时啊，干嘛再用个线程去监测？

Answer 4

2.3、执行了2次“AbNormal Proccess! ”，但没有执行“ending ok!” ：为什么会打印2次？
start task!10
ThreadID:17>>> starting!
ThreadID: MonitorThread running!
ThreadID:17>>> AbNormal Proccess! processTime=10000ThreadID:17>>> AbNormal Proccess! processTime=10000ThreadID:17>>> stoping end!
end task!10---------------------这有可能是因为AbNormal Proccess发现以后线程并未及时终止，导致再次检查的时候线程还存在，再次抛出了异常。

Answer 5

2.2、没有执行“ending ok!” ：stop后，run里后续处理不做了？ start task!18
ThreadID:25>>> starting!
ThreadID: MonitorThread running!
ThreadID:25>>> AbNormal Proccess! processTime=18000
ThreadID:25>>> stoping end! ---------------------------这个有可能是run后面还没做完线程就被强制终止。我没有细看你的代码，不过根据monitor和mutex_lock的概念猜想的，提供一个debug思路而已

Answer 6

还有你有没有wait你的condition variable？

Answer 7

你将thread.stop();句去掉后再运行看看

Answer 8

yan  hua  liao luan a 

Answer 9

我也在学Java，可惜考试不及格啊，帮不上忙了

Answer 10

grfdffffffffffffffffffffffffffffffffffaaaaaaaaaaaaaaaaaaaaaaaaaa

Answer 11

不懂Java，不过线程中最忌讳的就是你上面的Sleep语句正确的做法应该是建立一个事件通知，主线程等待子线程安全退出后才允许退出。

Answer 12

Java1.5的并发包，解决这一问题非常方便
1.生成一个Executor对象
2.把需要执行的任务定义到Runnable的run函数里，提交给Executor执行并获得一个Future对象
3.调用Future的get(time,timeUnit)函数指定超时时间获取线程运行结果
  如果超时，会抛出超时异常。catch到异常，说明执行错误或超时，抛弃掉就行了。循环1-3步，执行所有的任务.

Answer 13

补充下，如果任务超时或错误，cancel掉任务就行了.