java Timer

Question

Timer timer = new Timer();
tt = new timertask(loginFrame);
Button.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent event) {
try{
timer.schedule(tt, 0, 1000*60*loginFrame.getti());
}catch(IllegalStateException e){
tt.cancel();//取消任务
tt = new timertask(loginFrame);//创建新任务
timer.schedule(tt, 0, 1000*60*loginFrame.getti());
}
});通过点击，产生一个任务。如果上一个任务没有完成，则结束上一个任务，并创建一个新的任务。上面的代码可以做到这样吗？
我通过多次调试发现，可能是不能，但自己不确定。想问下大牛，如果要实现我要的效果，代码需要修改吗？如果需要修改，错误出在哪里，该怎么改？或者能够设计这样一个实验，让我实现我要的效果。

Answer 1

现在应该使用ScheduledExecutorService，提交一个任务返回一个Future。isDone检测是否完成、否则cancel

Answer 2

你这样写好像不对吧  timer.schedule（）这个方法只是每个多长时间就重新执行一次操作 没有判断上一个是否结束的功能吧

Answer 3

你的主要问题是：
  tt.cancel();//取消任务
这句话的作用理解错误，它不能取消已经执行中的任务，它只是取消任务调度而已。
取消任务需要你自己有处理机制，而不能靠调度器的cancel()。

Answer 4

cancel()的确是退出任务。
你那样的做法貌似不科学啊。
Timer作为一个定时器，本来就是定时执行一次任务。针对你的需求其实应该可以在线程上操作。
比如，最基本的Timer定时器用法：int time=1000;//定时时间1000ms
 java.util.Timer timer = new java.util.Timer();
 timer.schedule(new TimerTask() {
 public void run() { 
  try
   { 
ts();//触发、调用方法,执行任务
   }
   catch(Exception ex)
  {
ex.printStackTrace();
  }
}
}, 0, time); 

Answer 5

其实跟你开发多线程程序是类似的，结束任务要自己处理，一般也就是检测标志位，比如：    public class MyTask extends TimerTask {        private volatile boolean run = true;
        
        public void stop() {
            run = false;
        }
        
        @Override
        public void run() {
            int cnt = 0;
            while (run) {
                System.out.println(cnt++);
                try {
                    // 处理代码
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }    }

Answer 6

自己调用该函数来取消任务，比如：public class MyTask extends TimerTask {
        private volatile boolean run = true;
        public void cancel() {
            run = false;
            super.cancel();
        }
        public void run() {
            int cnt = 0;
            while (run) {
                System.out.println(cnt++);
                try {
                    // 处理代码
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
}Timer timer = new Timer();
tt = new MyTask();
timer.schedule(tt, 0, 1000*60*loginFrame.getti());
tt.cancel();
如果任务本身不是周期性的，那就会比较麻烦，要设法定期检查状态。
因为Java已经废除了 Thread.stop() 这种直接强行终止线程的做法了。

Answer 7

final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
class Task implements Runnable { ... } // class Task implements Callable {...}
final ScheduledFuture<?> future = scheduler.schedule(new Task(), 10, TimeUnit.SECONDS);
if(!future.isDone()){ future.cancel(); }

Answer 8

package timer;/**
 * 一个单任务调度器 
 */
public class SingleTask { public MyThread thread = null;
private static int threadId = 0;

/**
 * 设置一个新任务，并清除以前已存在的任务
 * @param task
 * @param delay
 * @param period
 */
public void setTask( Runnable task,long delay, long period){
if(thread != null){
try{
thread.stop(); //多线程复杂环境下，要谨慎使用Thread.stop()
}catch(Exception e){
e.printStackTrace();
}

thread = null;
}

thread = new MyThread(task);
thread.setName("MyThread-" + threadId ++ );
thread.start();
}


class MyThread extends Thread{

private Object lock = new Object();
private long delay = 1000;
private long period = 0;
private Runnable task = null;

public MyThread(Runnable runnable){
this.task = runnable;
}

@Override
public void run(){
while(true){

if(task != null){
task.run();
}

//模拟Timer的周期执行
if(period <= 0){
break;
}
synchronized (lock) {
try {
lock.wait(period);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

//模拟Timer的延时启动
public void start(){
synchronized (lock) {
try {
lock.wait(delay);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

this.start();
}
}
}package timer;/**
 * 模拟使用者
 */
public class Test {
private static Runnable task1 = new Runnable() {
//任务一，无限制输出
@Override
public void run() {
while(true){
synchronized (task1) {
System.out.println("output from task1..");
}
}

}
};

private static Runnable task2 = new Runnable() {
//任务二，每秒输出一次打印
@Override
public void run() {
while(true){
synchronized (task2) {
System.out.println("===============output from task2..");
try {
task2.wait(1000);
} catch (InterruptedException e) {
e.printStackTrace();
//break;
}
}
}
}
};

private static Object lock = new Object(); 
public static void main(String args[]){
SingleTask st = new SingleTask();
st.setTask(task1, 1000, 0); //2秒后把任务1换成任务2
synchronized (lock) {
try {
lock.wait(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
st.setTask(task2, 1000, 0);
}
}