java定时任务处理，帮忙看下程序问题，先谢谢了

Question

timer.schedule(new TimeManageMessage.myrun(), time); 不就是已经启动线程了吗
为什么还要放在while里
另外，我记得timer定时器，一旦出现异常之后就会停止了，到了第二天也不执行了
建议用quartz

Answer 1

timer.schedule(new TimeManageMessage.myrun(), time); 
建议不要把
new TimeManageMessage放到while循环里面

Answer 2

之前是没有放在while的，但是执行一次后就一直挂着，第二天并没有执行

Answer 3

java定时任务处理方法Java2的开发包中提供了一种很使用的线程功能：提前安排将来某段时间执行某任务Timer ，TimerTask。你可以使用这些类创建后台进程，让其在等待一段规定的时间后执行，或者让其没隔一段时间执行。你也可以用Thread来完成，但利用Timer与TimerTask显然省事不少。
TimerTask实现了Runnable接口，待执行的任务置于run()中。Timer是一个安排TimerTask的类此此两者一般一起工作。所应用时首先硬创建一个TimerTask的对象，然后用一个Timer的类对象安排执行它
Timer类包含的方法有：
1.Timer()
以常规方式运行task
2.Timer(boolean)
true时使用后台进程线程。只要剩下的程序记叙运行，后台进程线程就会执行。
3.public void cancel()
终止Timer的功能执行，但不会对正在执行的任务有影响。当执行cancel方法后将不能再用其分配任务。
4.public void schedule(TimerTask task,Date time)
task被安排在time指定的时间执行，如果时间为过去时则任务立刻执行。
5.public void schedule(TimerTask task, Date firstTime, long period)
task被安排在time指定的时间执行，执行后将每隔period(毫秒)反复执行。由于规定的时间间隔并不能保证与时钟精准的同不步，所以该方
法最适合从短期看保持频率准确是更重要的的地方
6.public void schedule(TimerTask task, long delay)
task被安排在delay（毫秒）指定的时间后执行。
7.public void schedule(TimerTask task,long delay, long period)
task被安排在delay（毫秒）指定的时间后执行。执行后将每隔period(毫秒)反复执行。
8.public void scheduleAtFixedRate(TimerTask task,Date firstTime, long period)
task被安排在firstTime指定的时间执行。执行后将每隔period(毫秒)反复执行。每一次重复的时间时盒第一次执行而不是和前一次执行有关
。因此执行的总速度是固定的。
9.public void scheduleAtFixedRate(TimerTask task,long delay,long period)
task被安排在delay（毫秒）指定的时间后执行。执行后将每隔period(毫秒)反复执行。每一次重复的时间时盒第一次执行而不是和前一次执
行有关。因此执行的总速度是固定的。
TimerTask的主要方法：
1.public boolean cancel()
终止任务的执行运行。如果Timer时要求循环执行的，则如果正在执行，则执行完了就再步会循环。如果还未执行或处于停歇期，则不会执行
了
2.public abstract void run()
3.public long scheduledExecutionTime()
返回被安排最后执行任务的时间。一般确定任务的当今的实行是否足够及时 ，证明进行被计划的活动为正当：
public void run() {
if (System.currentTimeMillis() - scheduledExecutionTime() >=
MAX_TARDINESS)
return; // Too late; skip this execution.
// Perform the task
}4.protected TimerTask() 

Answer 4

java定时任务处理方法Java2的开发包中提供了一种很使用的线程功能：提前安排将来某段时间执行某任务Timer ，TimerTask。你可以使用这些类创建后台进程，让其在等待一段规定的时间后执行，或者让其没隔一段时间执行。你也可以用Thread来完成，但利用Timer与TimerTask显然省事不少。
TimerTask实现了Runnable接口，待执行的任务置于run()中。Timer是一个安排TimerTask的类此此两者一般一起工作。所应用时首先硬创建一个TimerTask的对象，然后用一个Timer的类对象安排执行它
Timer类包含的方法有：
1.Timer()
以常规方式运行task
2.Timer(boolean)
true时使用后台进程线程。只要剩下的程序记叙运行，后台进程线程就会执行。
3.public void cancel()
终止Timer的功能执行，但不会对正在执行的任务有影响。当执行cancel方法后将不能再用其分配任务。
4.public void schedule(TimerTask task,Date time)
task被安排在time指定的时间执行，如果时间为过去时则任务立刻执行。
5.public void schedule(TimerTask task, Date firstTime, long period)
task被安排在time指定的时间执行，执行后将每隔period(毫秒)反复执行。由于规定的时间间隔并不能保证与时钟精准的同不步，所以该方
法最适合从短期看保持频率准确是更重要的的地方
6.public void schedule(TimerTask task, long delay)
task被安排在delay（毫秒）指定的时间后执行。
7.public void schedule(TimerTask task,long delay, long period)
task被安排在delay（毫秒）指定的时间后执行。执行后将每隔period(毫秒)反复执行。
8.public void scheduleAtFixedRate(TimerTask task,Date firstTime, long period)
task被安排在firstTime指定的时间执行。执行后将每隔period(毫秒)反复执行。每一次重复的时间时盒第一次执行而不是和前一次执行有关
。因此执行的总速度是固定的。
9.public void scheduleAtFixedRate(TimerTask task,long delay,long period)
task被安排在delay（毫秒）指定的时间后执行。执行后将每隔period(毫秒)反复执行。每一次重复的时间时盒第一次执行而不是和前一次执
行有关。因此执行的总速度是固定的。
TimerTask的主要方法：
1.public boolean cancel()
终止任务的执行运行。如果Timer时要求循环执行的，则如果正在执行，则执行完了就再步会循环。如果还未执行或处于停歇期，则不会执行
了
2.public abstract void run()
3.public long scheduledExecutionTime()
返回被安排最后执行任务的时间。一般确定任务的当今的实行是否足够及时 ，证明进行被计划的活动为正当：
public void run() {
if (System.currentTimeMillis() - scheduledExecutionTime() >=
MAX_TARDINESS)
return; // Too late; skip this execution.
// Perform the task
}4.protected TimerTask() 

Answer 5

例：import java.util.*;
import java.io.*;
public class doTask extends TimerTask {
String index;
Timer myTimer = new Timer();
public doTask(String index) {
this.index = index;
}
public void run() {
System.out.println(index);
}
public static void main(String args[]) {
doTask myTask1 = new doTask("First task");
myTask1.start(0,3);
doTask myTask2 = new doTask("Second task");
myTask2.start(0,1);
try{
Thread.sleep(6000);
}
catch(InterruptedException e){ 
} myTask1.end();
myTask2.end();//程序结束时用cancel()结束Timer}
public void start(int delay, int internal) {
myTimer.schedule(this, delay * 1000, internal * 1000); //利用timer.schedule方法
}
public void end(){
myTimer.cancel();
}
}输出：
First task
Second task
Second task
Second task
First task
Second task
Second task
Second task===================================================

Answer 6

timer及timertask的用法使用TimerTask
import java.util.Timer;
import java.util.TimerTask;
import java.util.Date;/**
* @author vincent
*/
public class TimerTest {public static void main(String[] args) {
Timer t = new Timer();//在5秒之后执行TimerTask的任务
t.schedule(new TimerTask(){
public void run()
{System.out.println("this is task you do1");}
},5*1000);
//在Date指定的特定时刻之后执行TimerTask的任务
Date d1 = new Date(System.currentTimeMillis()+1000);
t.schedule(new TimerTask(){
public void run()
{System.out.println("this is task you do2");}
},d1);
//在Date指定的特定时刻之后,每隔1秒执行TimerTask的任务一次
Date d2 = new Date(System.currentTimeMillis()+1000);
t.schedule(new TimerTask(){
public void run()
{System.out.println("this is task you do3");}
},d2,1*1000);
//在3秒之后,每隔1秒执行TimerTask的任务一次
t.schedule(new TimerTask(){
public void run()
{System.out.println("this is task you do4");}
},3*1000,1*1000);//在3秒之后,绝对每隔2秒执行TimerTask的任务一次t.scheduleAtFixedRate(new TimerTask(){
public void run()
{System.out.println("this is task you do6");}
},3*1000,2*1000);
}schedule和scheduleAtFixedRate的区别在于，如果指定开始执行的时间在当前系统运行时间之前，scheduleAtFixedRate会把已经过去的时间也作为周期执行，而schedule不会把过去的时间算上。比如SimpleDateFormat fTime = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
Date d1 = fTime.parse("2005/12/30 14:10:00");t.scheduleAtFixedRate(new TimerTask(){
public void run()
{
System.out.println("this is task you do6");
}
},d1,3*60*1000);间隔时间是3分钟，指定开始时间是2005/12/30 14:10:00，如果我在14:17:00分执行这个程序，那么会立刻打印3次this is task you do6 //14:10
this is task you do6 //14:13
this is task you do6 //14:16并且注意，下一次执行是在14:19 而不是 14:20。就是说是从指定的开始时间开始计时，而不是从执行时间开始计时。但是上面如果用schedule方法，间隔时间是3分钟，指定开始时间是2005/12/30 14:10:00，那么在14:17:00分执行这个程序，则立即执行程序一次。并且下一次的执行时间是 14:20，而不是从14:10开始算的周期(14:19)。
}上面有个帖子发重了，不好意思

Answer 7

帮忙看下程序原因,只执行了一次,没有在循环执行,mian里的time是否会随着时间的变动而循环?

Answer 8

没有用过quartz，目前想先解决用timer所出的问题
package tf.dt.credit.view;/**定时处理报文
 *每天凌晨5点自动处理生成报文
 * @author dingting
 * @date 2008-10-20
 */import java.util.Calendar;
import java.util.Date;
import java.util.TimerTask;
import java.util.Timer;
import tf.dt.credit.view.CreditMessageView;
import tf.dt.credit.database.odbcConnection;
import java.text.SimpleDateFormat;public class TimeManageMessage {
  public static void main(String[] args) throws InterruptedException {
    // Get the Date corresponding to 11:01:00 pm today.
    Calendar calendar = Calendar.getInstance();
    calendar.set(Calendar.HOUR_OF_DAY, 11); //控制时
    calendar.set(Calendar.MINUTE, 0); //控制分
    calendar.set(Calendar.SECOND, 0); //控制秒
    Date time = calendar.getTime();     Timer timer = new Timer();
     timer.schedule(new TimeManageMessage.myrun(), time,1000 * 60 * 60 * 24);
   }  static class myrun extends TimerTask {
      public void run() {
      System.out.println("aaaaaaaaaa");
    }
  }
}
================
这样写有什么问题？为什么只执行了一次？

Answer 9

我打印了一下time值，得到的Mon Nov 17 11:00:00 CST 2008日期，是不是日已经制定了，所以第二天没有运行？

Answer 10

我似乎发现了点问题，api上说
scheduleAtFixedRate(TimerTask task, Date firstTime, long period) 
          安排指定的任务在指定的时间开始进行重复的固定速率执行。
schedule(TimerTask task, Date firstTime, long period) 
          安排指定的任务在指定的时间开始进行重复的固定延迟执行。我现在用的scheduleAtFixedRate方法
timer.scheduleAtFixedRate(new TimeManageMessage.ManageMessageRun(), time,1000 * 60 * 60 * 24); //time=05：00：00
我每次测试的时候都是在晚上了，昨晚我做测试也是在22：00左右开始执行，这个方法的第一次执行可能不是按照我指定的早晨5：00开始执行程序，
而是从22:00点开始，循环后面的周期一天（1000 * 60 * 60 * 24），那岂不是到第二天的22：00才能执行程序？我的理解是否正确？
如果我就是要在我制定的固定时间执行，不要按照我的执行时间开始算，应该用哪种方法？

Answer 11

能否提供一个quartz的例子，目前为止还没有接触过quartz，如果你有例子，希望提供一个有效例子，谢谢。timer方法我在研究了，已经有眉目了，大概知道原因所在了

Answer 12

对于timer我大概整理下思路，需要的朋友可以去看下
http://blog.csdn.net/zhangenming20080324另外，希望朋友们提供quartz的做法

Answer 13

quartz的例子？
到http://www.opensymphony.com/quartz/download.action下载quartz.zip
解压缩后，里面有一个examples文件夹，里面全是例子，自己看吧，呵呵