java中每个月第一天执行一次任务的定时器如何实现？

1、首先在java创建一个thread文档。2、其次使用thread文档在while循环里一直运行着。3、最后通过sleep方法来达到定时器加锁效果即可。

定时器不会提前执行。基础知识java.util.Timer一种线程设施，用于安排以后在后台线程中执行的任务。可安排任务执行一次，或者定期重复执行。此类是线程安全的：多个线程可以共享单个Timer对象而无需进行外部同步。java.util.TimerTask由Timer安排为一次执行或重复执行的任务。

具体的做法：Timer timer = new Timer();timer.schedule(new MyTask(), 1000)。Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。

private void closeTimer() {x0dx0aif (timerTask != null) {x0dx0atimerTask.cancel();x0dx0atimerTask = null;x0dx0a}x0dx0aif (mTimer != null) {x0dx0amTimer.cancel();x0dx0amTimer = null;x0dx0a}x0dx0a}x0dx0a/**x0dx0a* 计时操作 改变界面的倒计时信息x0dx0a*/x0dx0aprivate void timerOperation() {x0dx0arecLen = RECENT_SECOND;x0dx0amTimer = new Timer();x0dx0atimerTask = new TimerTask() {x0dx0ax0dx0a@Overridex0dx0apublic void run() {x0dx0a// TODO Auto-generated method stubx0dx0arecLen--;x0dx0aif (recLen >= 0) {x0dx0aMessage msg = new Message();x0dx0amsg.what = SECOND_UPDATE;x0dx0amsg.arg1 = recLen;x0dx0ahandler.sendMessage(msg);x0dx0a}x0dx0a}x0dx0a};x0dx0amTimer.schedule(timerTask, PROGRESS_DELAY, PROGRESS_PERIOD);x0dx0a}

不会。1、可以采用睡眠，sleep（），比较low。2、在java类库中已经写好了定时器，java.util.Timer。可以拿来用，用的少，很多高级框架都是支持定时任务的。

大部分人在遇到需要使用定时任务的时候首先会想到Timer类，不过在JDK5.0之后就不建议使用这个Timer了，因为它有很多的缺陷。 在新的java.util.concurrent包中的ScheduledExecutorService可以替代这个Timer： 使用方法举例： Java代码 ScheduledThreadPoolExecutor exec = new ScheduledThreadPoolExecutor(1); exec.scheduleAtFixedRate(new Runnable() { public void run() { try{ throw new RuntimeException(); }catch (Exception e){ System.out.println("RuntimeException catched"); } } }, 1000, 5000, TimeUnit.MILLISECONDS);

这个是我在网上找的不知道是不是你要的： java定时任务Timer 关于定时任务，似乎跟时间操作的联系并不是很大，但是前面既然提到了定时任务，索性在这里一起解决了。设置定时任务很简单，用Timer类就搞定了。一、延时执行首先，我们定义一个类，给它取个名字叫TimeTask，我们的定时任务，就在这个类的main函数里执行。代码如下： package test; import java.util.Timer; public class TimeTaskTest { public static void main(String[] args){ Timer timer = new Timer(); timer.schedule(new Task(), 60 * 1000); } } 解释一下上面的代码。上面的代码实现了这样一个功能，当TimeTask程序启动以后，过一分钟后执行某项任务。很简单吧：先new一个Timer对象，然后调用它的schedule方法，这个方法有四个重载的方法，这里我们用其中一个， public void schedule(TimerTask task,long delay) 首先，第一个参数第一个参数就是我们要执行的任务。这是一个TimerTask对象，确切点说是一个实现TimerTask的类的对象，因为TimerTask是个抽象类。上面的代码里 面，Task就是我们自己定义的实现了TimerTask的类，因为是在同一个包里面，所以没有显性的import进来。Task类的代码如下 package test; import java.util.TimerTask; public class Task extends TimerTask { public void run() { System.out.println("定时任务执行"); } } 我们的Task必须实现TimerTask的方法run，要执行的任务就在这个run方法里面，这里，我们只让它往控制台打一行字。第二个参数第二个参数是一个long型的值。这是延迟的时间，就是从程序开始以后，再过多少时间来执行定时任务。这个long型的值是毫秒数，所以前面我们的程序里面，过一分钟后执行用的参数值就是 60 * 1000。二、循环执行设置定时任务的时候，往往我们需要重复的执行这样任务，每隔一段时间执行一次，而上面的方法是只执行一次的，这样就用到了schedule方法的是另一个重载函数public void schedule(TimerTask task,long delay,long period) 前两个参数就不用说什么了，最后一个参数就是间隔的时间，又是个long型的毫秒数（看来java里涉及到时间的，跟这个long是脱不了干系了），比如我们希望上面的任务从第一次执行后，每个一分钟执行一次，第三个参数值赋60 * 1000就ok了。三、指定执行时间既然号称是定时任务，我们肯定希望由我们来指定任务指定的时间，显然上面的方法就不中用了，因为我们不知道程序什么时间开始运行，就没办法确定需要延时多少。没关系，schedule四个重载的方法还没用完呢。用下面这个就OK了： public void schedule(TimerTask task,Date time) 比如，我们希望定时任务2006年7月2日0时0分执行，只要给第二个参数传一个时间设置为2006年7月2日0时0分的Date对象就可以了。有一种情况是，可能我们的程序启动的时候，已经是2006年7月3日了，这样的话，程序一启动，定时任务就开始执行了。schedule最后一个重载的方法是public void schedule(TimerTask task,Date firstTime,long period) 没必要说什么了吧:)四、j2ee中的定时任务在实际的项目中，往往定时任务需要对web工程中的资源进行操作，这样一来，用上面的单个程序的方式可能就有点力不从心了，因为很多web工程的资源它操作不到。解决的办法是，使用Servlet，把执行定时任务的那些代码放到Servlet的init()函数里就可以了，这个easy，就没有必要再写示例代码了吧

import java.util.*;class MyTime{ int hour; int minute; MyTime(int hour,int minute){ this.hour=hour; this.minute=minute; }}public class AboutTime{ public static void main(String args[]){ final MyTime mt=new MyTime(11,24); //这里，假设程序运行时，是在早上8点半之前的。其他情况，你自行分析 Calendar cal=Calendar.getInstance(); //此方法获得当前地域的时间，注意，getInstance是静态方法 cal.set(cal.HOUR, mt.hour);//设置你所要等待的时刻 cal.set(cal.MINUTE, mt.minute); Calendar cal2=Calendar.getInstance();// long time1=cal.get(cal.HOUR_OF_DAY)*3600+cal.get(cal.MINUTE)*60;//将两个时刻都转换成秒数，以便进行相减 long time2=cal2.get(cal2.HOUR_OF_DAY)*3600+cal2.get(cal2.MINUTE)*60+cal2.get(cal2.SECOND); final long waitTime=time1-time2;//此时获得当前时刻与要等待时刻的时间差，单位是秒 //这里说明一下，现在所指的当前时刻是“Calendar cal2=Calendar.getInstance()”这句执行时所获得的时刻 //获得后，它的各值（秒，分，时）等信息都不会改变。当然，运行几行代码，花不了几毫秒。所以 //虽然之前的cal2的时间信息与运行三行代码以后的时间信息是差不多的 System.out.println(waitTime);//此行用于测试 new Thread(new Runnable(){ public void run(){ try{ for(long l=0;l<waitTime;l++){ Thread.sleep(1000); System.out.println("###");//一秒打一个，当然，告诉你正在计时 //这里用多线程，因为运行后，可以继续运行主线程。不影响你干其他事儿。 } } catch(InterruptedException e){} System.out.println(mt.hour+":"+mt.minute+"到了"); } }).start(); //不过，你说一天要三次计算。这很容易，如何实现，由你自己决定。 }}

private void goTimer() { Timer timmerTask = new Timer(); Calendar calEnviron = Calendar.getInstance(); // 每天的02:00.am开始执行 calEnviron.set(Calendar.HOUR_OF_DAY, 2); calEnviron.set(Calendar.MINUTE, 00); // date为制定时间 Date dateSetter = new Date(); dateSetter = calEnviron.getTime(); // nowDate为当前时间 Date nowDateSetter = new Date(); // 所得时间差为，距现在待触发时间的间隔 long intervalEnviron = dateSetter.getTime() - nowDateSetter.getTime(); if (intervalEnviron < 0) { calEnviron.add(Calendar.DAY_OF_MONTH, 1); dateSetter = calEnviron.getTime(); intervalEnviron = dateSetter.getTime() - nowDateSetter.getTime(); } // 每24小时执行一次,启动启动启动启动启动 timmerTask.schedule(new UseTimer(timmerTask), intervalEnviron, 1 * 1000 * 60 * 60 * 24);}

private void closeTimer() {if (timerTask != null) {timerTask.cancel();timerTask = null;}if (mTimer != null) {mTimer.cancel();mTimer = null;}}/*** 计时操作 改变界面的倒计时信息*/private void timerOperation() {recLen = RECENT_SECOND;mTimer = new Timer();timerTask = new TimerTask() {@Overridepublic void run() {// TODO Auto-generated method stubrecLen--;if (recLen >= 0) {Message msg = new Message();msg.what = SECOND_UPDATE;msg.arg1 = recLen;handler.sendMessage(msg);}}};mTimer.schedule(timerTask, PROGRESS_DELAY, PROGRESS_PERIOD);}

如果想用框架的话推荐“Spring Schedule定时任务”。如果想自己简单的实现的话可以使用java的Timer类和TimerTask类，它们配合可以每隔指定时间执行一次对应的Task，比较简单，参考这篇博客，run函数中放你的发送短信的代码就行了。

二、如果是需要Tomcat启动就能执行，不需要main方法的定时器的话：web.xml里面需要这么配置： <listener> <listener-class> com.InitListener </listener-class> </listener>第一个类：InitListenerpackage com.listener;import java.util.Calendar;import java.util.Date;import java.util.Timer;import javax.servlet.ServletContextEvent;import javax.servlet.ServletContextListener;/** * 系统启动时的监听类 初始化系统数据 * * @author jhoneder * */public class InitListener implements ServletContextListener { public void contextDestroyed(ServletContextEvent arg0) { // TODO Auto-generated method stub // context销毁时，销毁初始化数据 } public void contextInitialized(ServletContextEvent event) { // TODO Auto-generated method stub try { goTimmer(); } catch (Exception e) { System.out.println("失败:" + e.getMessage()); } } private void goTimer() { Timer timmerTask = new Timer(); Calendar calEnviron = Calendar.getInstance(); // 每天的02:00.am开始执行 calEnviron.set(Calendar.HOUR_OF_DAY, 2); calEnviron.set(Calendar.MINUTE, 00); // date为制定时间 Date dateSetter = new Date(); dateSetter = calEnviron.getTime(); // nowDate为当前时间 Date nowDateSetter = new Date(); // 所得时间差为，距现在待触发时间的间隔 long intervalEnviron = dateSetter.getTime() - nowDateSetter.getTime(); if (intervalEnviron < 0) { calEnviron.add(Calendar.DAY_OF_MONTH, 1); dateSetter = calEnviron.getTime(); intervalEnviron = dateSetter.getTime() - nowDateSetter.getTime(); } // 每24小时执行一次 timmerTask.schedule(new UseTimer(timmerTask), intervalEnviron, 1 * 1000 * 60 * 60 * 24); }}第二个类：package com.listener;import java.util.Timer;import java.util.TimerTask;/** * 被调用执行类 * * @author Administrator * */public class UseTimer extends TimerTask { Timer timer = new Timer(); public UseTimer(Timer timer) { this.timer = timer; } /* * 被调用具体的方法 */ public void run() { System.out.println("开始具体执行！"); }}不懂得话可以追问！

可以使用timer的schedule方法实现定时任务，例如：把下面的new Date()参数换为你要定时的时间，创建一个线程执行你的任务public class 定时 { public static void main(String[] args) { Timer timer = new Timer(); timer.schedule(new myTest(), new Date()); }}class myTest extends TimerTask { @Override public void run() {//你要执行的任务 } System.out.println(hour + ":" + fen + ":" + sec + ":" + i);}修改一下就可以了

首先你写一个类去实现 implements ServletContextListener 即Servlet监听器当Servlet容器创建的时候会执行,也就是说你的tomcat一启动就会执行一次contextInitialized(ServletContextEvent event);写好这个类以后,要web.xml里做一下配置<listener> <listener-class>这里用你的这个类的包名加类名</listener-class> </listener>

　　好多朋友用过Windows的任务计划 也有不少程序迷自己曾写过时钟报警 系统自动关机等趣味程序 可却很少有朋友在Web工程中实现过类似功能 　　当Web工程启动时 定时器能自动开始计时 在整个Web工程的生命期里 定时器能在每晚深夜触发一次任务 因此定时器的存放位置也值得考查 不能简单的存在于单个Servlet或JavaBean中 必须能让定时器宿主的存活期为整个Web工程生命期 在工程启动时能自动加载运行 结合这两点 跟 Servlet上下文有关的侦听器就最合适不过了 通过在工程的配置文件中加以合理配置 会在工程启动时自动运行 并在整个工程生命期中处于监听状态 　　下面就Servlet侦听器结合Java定时器来讲述整个实现过程 要运用Servlet侦听器需要实现 javax servlet ServletContextListener接口 同时实现它的contextInitialized (ServletContextEvent event)和contextDestroyed(ServletContextEvent event)两个接口函数 考虑定时器有个建立和销毁的过程 看了前面两个接口函数 就不容置疑的把建立的过程置入 contextInitialized 把销毁的过程置入contextDestroyed了 　　我把ServletContextListener的实现类取名为ContextListener 在其内添加一个定时器 示例代码如下所示 　　import java util Timer; 　　import javax servlet ServletContextEvent; 　　import javax servlet ServletContextListener; 　　import javax servlet ServletException; 　　import javax servlet ServletRequest; 　　import javax servlet ServletResponse; 　　import javax servlet HttpServlet; 　　public class ContextListener 　　extends HttpServlet 　　implements ServletContextListener { 　　public ContextListener() { 　　} 　　private java util Timer timer = null; 　　public void contextInitialized(ServletContextEvent event) { 　　timer = new java util Timer(true); 　　event getServletContext() log( 定时器已启动 ); 　　timer schedule(new MyTask(event getServletContext()) * * ); 　　event getServletContext() log( 已经添加任务调度表 ); 　　} 　　public void contextDestroyed(ServletContextEvent event) { 　　timer cancel(); 　　event getServletContext() log( 定时器销毁 ); 　　} 　　} 　　以上代码中 timer schedule(new MyTask(event getServletContext()) * * )这一行为定时器调度语句 其中MyTask是自定义需要被调度的执行任务（在我的财政数据中心项目中就是报表计算引擎入口） 从 java util TimerTask继承 下面会重点讲述 第三个参数表示每小时(即 * * 毫秒)被触发一次 中间参数 表示无延迟 其它代码相当简单 不再详细说明 　　下面介绍MyTask的实现 上面的代码中看到了在构造MyTask时 传入了javax servlet ServletContext类型参数 是为记录Servlet日志方便而传入 因此需要重载MyTask的构造函数（其父类java util TimerTask原构造函数是没有参数的） 在timer schedule()的调度中 设置了每小时调度一次 因此如果想实现调度任务每 小时被执行一次 还需要判断一下时钟点 以常量C_SCHEDULE_HOUR表示(晚上 点 也即 点) 同时为防止 小时执行下来 任务还未执行完（当然 一般任务是没有这么长的） 避免第二次又被调度以引起执行冲突 设置了当前是否正在执行的状态标志isRunning 示例代码如下所示 　　import java util *; 　　import javax servlet ServletContextEvent; 　　import javax servlet ServletContextListener; 　　import javax servlet ServletException; 　　import javax servlet ServletRequest; 　　import javax servlet ServletResponse; 　　import javax servlet HttpServlet; 　　import javax servlet *; 　　public class MyTask extends TimerTask { 　　private static final int C_SCHEDULE_HOUR = ; 　　private static boolean isRunning = false; 　　private ServletContext context = null; 　　public MyTask() { 　　} 　　public MyTask(ServletContext context) { 　　ntext = context; 　　} 　　public void run() { 　　Calendar cal = Calendar getInstance(); 　　if (!isRunning) { 　　if (C_SCHEDULE_HOUR == cal get(Calendar HOUR_OF_DAY)) { 　　isRunning = true; 　　context log( 开始执行指定任务 ); 　　//TODO 添加自定义的详细任务 以下只是示例 　　//系统定时接收邮件 　　Email email=new Email(); 　　email recieve(); 　　isRunning = false; 　　context log( 指定任务执行结束 ); 　　} 　　} 　　else { 　　context log( 上一次任务执行还未结束 ); 　　} 　　} 　　} 　　到这儿 ServletContextListener和MyTask的代码都已完整了 最后一步就是把ServletContextListener部署到您的Web工程中去 在您工程的web xml配置文件中加入如下三行 　　<listener> 　　<listener class> test ContextListener</listener class> 　　</listener> lishixinzhi/Article/program/Java/hx/201311/26421

问题一：定时器一般是以线程的方式运行的，如果能得到该线程的引用，就可以像查看Thread一样查看定时器的运行状态。如果可以修改源代码的话最好给他提供一个方法返回线程引用问题二：TimerTask实现了接口Runnable，如果是以new Thread(TimerTask).start()方式启动的话就是做为一个单独的线程运行的，如果是timeTask.run()那就是方法调用，虽然占据一个线程，但这个线程就是主线程，并没有启动新的线程；既然实现线程，自然可以通过Thread的isAlive方法获取其live状态；一般情况下（不发生异常），定时器会一直运行，如果JVM停止，那么线程必然已经终止，如果JVM中只有这一个线程在运行，那么JVM不停，这个定时器就是一定在运行中，如果JVM中还有其他线程在运行，那么JVM不停，这个定时器有可能已经终止PS:无论用不用线程池，线程启动方式只有两种（不包含main Thread）：一种是继承Thread类，然后直接同构引用调用start方法，第二种就是继承Runnable接口，通过new Thread(new MyRunnableClass()).start()方式启动。无论如何，都会有一个Thread类的引用补充：一个tomcat只启动一个进程，而JVM的垃圾处理器也只有一个，所以在一个工程里运行System.gc也会影响到其他工程。

java中有个定时任务java.util.TimerTask用法很简单class MyTask extends java.util.TimerTask{@Overridepublic void run() {// 这个任何所执行的代码}}java.util.Timer timer = new Timer(true);//treu就是守护线程MyTask task = new MyTask();//开始执行任务,第一个参数是任务,第二个是延迟时间,第三个是每隔多长时间执行一次timer.schedule(task, 0 , 1000 * 60 * 60 * 24);

比较复杂点的需要Quartz,引入jar包，然后再需要配置一些东西，详细参考如下。http://zhidao.baidu.com/question/382322468.html简单点的直接可以这样写while(true){ xxx//作时间间隔判断，或者当前时间与上一执行时间间隔。 i=j;//i 是你变量，j是动态的值}

调用线程的sleep（）方法即可实现定时Thread.sleep(xx);xx 表示毫秒

看看下面代码，使用的是java.util.Timer类import java.util.Date;import java.util.Timer;import java.util.TimerTask;public class T { public static void main(String []args){ Timer timer=new Timer(); timer.schedule(new TimerTask(){ @Override public void run() { System.out.println(new Date()); } }, 0,1000); }}

第一、三种方式只能校验不含负号“-”的数字，即输入一个负数-199，输出结果将是false；而第二方式则可以通过修改正则表达式实现校验负数，将正则表达式修改为“^-?[0-9]+”即可，修改为“-?[0-9]+.?[0-9]+”即可匹配所有数字。

1、scheduleUpdate加入当前节点后，程序会每帧都会自动执行一次默认的Update函数。（注：一定是Update函数哦，若想调用其他自己命名的函数则使用schedule）看例子，走起。首先在HelloWord类的头文件中声明Update函数：[cpp] view plain copy print?void update(float dt); //注意参数类型 然后在HelloWorld类源文件中实现函数Update：[cpp] view plain copy print?void HelloWorld::update(float dt) { CCLOG("baibai"); } 现在我们可以调用了，在需要他不断执行的地方加入调用的代码就ok：[cpp] view plain copy print?this->scheduleUpdate(); //this是当前节点，如layer，所以可以省略啦。 运行之后你将会看到不断有baibai被打印出来2、scheduleUpdate可以没隔几秒执行某个自定义的函数，来看代码：首先还是在HelloWorld中声明所要执行的函数：

java中quartz框架设置定时任务时，是可以设置各种时间启动的每天什么时候执行:<value>0 59 23 * * ?</value>: 如下为每天23:59:00开始执行<value>0 1,2,3 11,12 * * ? </value>: 每天11:01,11:02,11:03; 12:01,12:02,12:03分执行任务至于你说的别人可以改时间，你可以把这个时间参数提取处理，放到一个页面或者数据库存起来，然后别人通过页面或者链接数据库修改就行了。

javax.swing.Timer尽管所有 Timer 都使用一个共享线程（由第一个执行操作的 Timer 对象创建）执行等待，但是 Timer 的动作事件处理程序还会在其他线程（事件指派线程上）执行。这意味着 Timer 的操作处理程序可以安全地在 Swing 组件上执行操作。但是，它也意味着处理程序必须快速执行以保证 GUI 作出响应。java.util.Timer一种工具，线程用其安排以后在后台线程中执行的任务。可安排任务执行一次，或者定期重复执行。 简单理解，javax.swing.Timer没有增加线程，利用事件线程的间隙运行，java.util.Timer增加线程了。

import java.io.IOException;import java.util.Timer;public class TimerTest {public static void main(String[] args){Timer timer = new Timer();timer.schedule(new MyTask(), 1000, 2000);//在1秒后执行此任务,每次间隔2秒,如果传递一个Data参数,就可以在某个固定的时间执行这个任务.while(true){//这个是用来停止此任务的,否则就一直循环执行此任务了try {int ch = System.in.read();if(ch-"c"==0){timer.cancel();//使用这个方法退出任务}} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}

这个比较容易啊，你想控制每周六凌晨02：00自动执行，你可以在web工程中建立一个servlet定时执行这段程序，用quartz这个定时控制。不要用jdk自带的timer，因为这个不太好控制时间。还有疑问，可以继续提问 补充一下，如果你要用quartz来实现，在网上搜索一个quartz1。8。6版本的jar包，然后可以百度一下quartz怎么使用。如果觉得麻烦，我可以传一个jar包给你，然后给你写个简单例子。

你可以这么来理解：定时任务是由定时器依照一定的执行频率来调用任务执行。也就是说任务本身只是一段代码，由定时器定时调用此代码。

为每个TimerTask创建不同的Timer对象，想停止某个Timer直接调用其cancel（）方法 ，写个小例子import java.util.Date;import java.util.Timer;import java.util.TimerTask;public class Test{ public static void main(String args[]) throws InterruptedException { TimerTask task1=new TimerTask(){ public void run() { // TODO Auto-generated method stub System.out.println("task1"); } }; TimerTask task2=new TimerTask(){ public void run() { // TODO Auto-generated method stub System.out.println("task2"); } }; Timer t1=new Timer(); Timer t2=new Timer(); t1.schedule(task1, new Date(), 1000);//每隔一秒输出 t2.schedule(task2, new Date(), 1000);//每隔一秒输出 Thread.sleep(5000);//等待5秒 t1.cancel();//停止定时器t1 Thread.sleep(5000);//等待5秒 t2.cancel();//停止定时器t2 }}

quartz工作调度

主类：package tiwen4; import java.util.Calendar; import java.util.Timer; public class quartz { public static void main(String[] args) { try{ Calendar cal = Calendar.getInstance();//设置定时时间 cal.add(Calendar.DATE, 0);//表示从今天的12点开始跑起来，如果当前时间超过12点会马上跑一次，否则等12点再跑第一次 cal.set(Calendar.HOUR_OF_DAY, 12);//24小时制的，12就是中午12点 cal.set(Calendar.MINUTE, 0);//分 cal.set(Calendar.SECOND, 0);//秒 Timer processTimer = new Timer(); processTimer.scheduleAtFixedRate(new ProcessClass(), cal.getTime(), 86400000);//86400000是24小时，即24小时跑一次 }catch(Exception e){ e.printStackTrace(); }finally{ } } }定时器调用的类--我在这里只是输出了一下~你也可以自己加函数：package tiwen4; import java.util.TimerTask; public class ProcessClass extends TimerTask { @Override public void run() { // TODO Auto-generated method stub System.out.println("输出了哈哈");// } } 我上面用的只是一种方式，其实定时方式有很多的linux和window都有自带的定时器，可以直接调用，也可以用上面所说的quartz包带的框架等等

public void start(final String str) { timer.schedule(new TimerTask() { public void run() { playSound(); timer.cancel(); } private void playSound() { System.out.println(str);//想把参数传到这来 // Start a new thread to play a sound... } }, minutes* 1000); } public static void main(String[] args) { EggTimer eggTimer = new EggTimer(2); eggTimer.start("123"); }

那么可能的原因是你的工程里面存在类冲突，所以它load了另外一个类。你可以把classpath loader打出来看一下，或者新建一个工程单独把那个jar放进去调试一下或者用一下jarfind工具

定义一个全局的计数器counter，每次timer执行时+1，根据counter知道timer是第几次调用了

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> <!-- 调度工厂 --> <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean" autowire="no"> <property name="triggers"> <list> <ref bean="simpletriggerbean" /> <ref bean="cronTriggerBean" /> </list> </property> </bean> <bean id="jmsQueueService" class="com.lehecai.push.service.JMSQueueService"> <property name="jmsTemplate" ref="jmsTemplate" /> </bean> <!-- 方式一 --> <bean id="quantzjobBean" class="org.springframework.scheduling.quartz.JobDetailBean"> <property name="jobClass"> <value>com.lehecai.push.timer.PushTaskJobBean</value> </property> <property name="jobDataAsMap"> <map> <entry key="jmsQueueService" value-ref="jmsQueueService" /> <entry key="pushTaskDao" value-ref="pushTaskService" /> <entry key="pushTaskDeviceDao" value-ref="pushTaskDeviceService" /> </map> </property> </bean> <bean id="simpletriggerbean" class="org.springframework.scheduling.quartz.SimpleTriggerBean"> <property name="jobDetail" ref="quantzjobBean" /> <property name="startDelay" value="3000" /> <property name="repeatInterval" value="10000" /> <!-- <property name="repeatCount" value="-1" /> --> </bean> <bean id="springQtzJobMethod" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"> <property name="targetObject"> <bean class="com.lehecai.push.service.EtlToolService" /> </property> <property name="targetMethod"> <value>executeTask</value> </property> </bean> <bean id="cronTriggerBean" class="org.springframework.scheduling.quartz.CronTriggerBean"> <property name="jobDetail" ref="springQtzJobMethod"></property> <property name="cronExpression" value="0 0 4,17 * * ?"></property> </bean></beans>两种办法哪种都行，关键字都在上边了。

那就是所有打开的页面共享数据咯方案有二：一、1.每个页面都添加定时器，2.然后两秒钟或者5秒钟用ajax访问以下session， 如果session中的值比较小，就写值进去，如果session中的值比较大，就读值出来；这样就保证了每个页面上的计时器共享资源二、与方案一唯一不同的一点就是，存值进cookie；他们各有优缺点，方案一的话：因为要计算请求时间，如果网速不好的话，就会有比较大的误差。方案二的话：必须的保证用户的cookie没有禁用，而实际上很多用户的cookie都是禁用的。个人比较喜欢第一种，如果真是没人操作的话，那时间差一些也无关紧要，又没人看见。而且差的时间是多的，而不是少的，，多给用户一些时间，说不定还能多拉一些用户。或者直接就不给给网速不好的用户这项功能再或者判断网速不好的话就存cookie，如果cookie没有开的话，就不管了个人想法仅供参考

你可以在程序运行前获取一个时间long timeStart=System.currentTimeMillis() 在程序里加一个判断,long timeEnd=System.currentTimeMillis() if(timeEnd-timeStart>你想执行的时间){ //TODO 添加一个跳出此程序的代码就可以了,或者你直接在这里 throw new Exception(); }

具体的做法：Timer timer = new Timer();timer.schedule(new MyTask(), 1000)。Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。

如果是简单的烂代码，写个死循环，获取当前时间，如果时间到了你想要的时候就执行你想要执行的方法。如果要写的好点。起一个线程，线程里给个死循环，获取当前时间，如果为你想要的时间，就另外起一个线程跑你要的程序，如果不是则当前线程睡30秒或者1分钟什么的。代码如下：public class Task1{public static void main(String[] args) {// run in a secondfinal long timeInterval = 1000;Runnable runnable = new Runnable() {public void run() {while (true) {// ------- code for task to runSystem.out.println("Hello !!");// ------- ends heretry {Thread.sleep(timeInterval);} catch (InterruptedException e) {e.printStackTrace();}}}};Thread thread = new Thread(runnable);thread.start();}}

用cancel()方法 停止定时器

这个是要看写的复杂的好点，还是简单的烂代码。如果是简单的烂代码，写个死循环，获取当前时间，如果时间到了你想要的时候就执行你想要执行的方法。如果要写的好点。起一个线程，线程里给个死循环，获取当前时间，如果为你想要的时间，就另外起一个线程跑你要的程序，如果不是则当前线程睡30秒或者1分钟什么的。

是什么session, 是httpSession 还是 ORM session。如果是前者， 此session是随着一次 http request 请求出现的， 定时器里面怎么得到呢？可以每次请求去维护一个session pool， 过期的remove，新的就加入， 然后定时器里面 从pool里面取。如果是后者 直接取DB connection 获取

手动关闭，异常退出。全局计数，达到临界值退出。timer.cancel();

http://jingyan.baidu.com/album/0eb457e50b95d003f0a90553.html?stepindex=2&wap_detail_test=T1&st=2&os=0&bd_page_type=1&net_type=1&ssid=&from=

一般都是通过日志打印譬如run方法里面加入以下log.info("定时器启动，时间："+new Date())try{}catch(){ log.error("出现异常") return;}log.info("定时器结束，时间："+new Date())当日志打印有结束语句就证明跑完了

定时器启动以后就不能去更改它的时间设定了的，task.cancel(); 用这个方法先停止定时器，然后用新的时间参数开启新的定时器这样就能解决你的问题了

你 看看java.sql.*;吧private static class MyTask extends TimerTask {private String url="依照你数据库类别不同而不同";private String sql="sql语句";private String driver="数据库jdbc驱动类";private Connection conn=null;private PreparedStatement sta=null;Class.forName(driver);public void run() { conn=getConnection(url); sta=conn.prepareStatement(sql); sta.execute(); //执行 sta.close(); conn.close(); } }

写方法，去请求 ，在定时器中调用可以使用 HttpURLConnect 去请求 、并获取返回 。。。。。。。

按照你的要求用定时器写的，加油！package baidu;import java.util.Timer;import java.util.TimerTask;public class Test04{ public static void main(String[] args) { Timer timer=new Timer(); timer.schedule(new TimerTask(){ @Override public void run() { System.out.println("你好！"); } },1000,1000); }}

最常用的做法是使用UNIX的cron直接执行Java程序。并不需要在Java做的那么复杂。Windows服务器也有类似于cron的任务管理功能，同理 --------------------------->Tomcat不是用来管理定时任务的，如果没有HTTP请求，Servlet是不会被执行的。建议lz把定期执行的处理做成一个独立的Java程序，用cron执行。如果不想写独立的Java程序，也可以用cron定期向Tomcat发送Http请求，但是，这样做的话注意程序处理时间不能太长，因为HTTP通信有timeout的制约。

众所周知spring 的Quartz定时器的功能非常强大，可以在特定的年月日小时分秒的时间点触发时间，完成事件的调度，就像windows中得计划任务一样。下面看一个典型的Quartz定时器的实现： 1、首先实现一个用于被执行的类，这个类用于被定时器调度，这个类不需要继承任何类或者接口，代码如下： publicTestQuartz{ public void doSomething(){ //TODO } } 2、spring配置文件，具体配置 <!-- 被执行类 --> <beanid="testQuarzt"class="test.testQuarzt"/> <!-- 将testQuarzt注入到job中 --> <beanid="testQuartzJob"class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"> <property name="targetObject" ref="testQuarzt" /> <property name="targetMethod" value="doSomething" /> <property name="concurrent" value="false" /> </bean> <!-- 将job注入到定时触发器 --> <beanid="testTrigger"class="org.springframework.scheduling.quartz.CronTriggerBean"> <property name="jobDetail" ref="testQuartzJob" /> <property name="cronExpression"> <value>0 0 6 * * ?<value> <property> <bean> <!-- 将定时触发器注入任务工程 --> <beanclass="org.springframework.scheduling.quartz.SchedulerFactoryBean"> <property name="triggers"> <list>