java中定时器的实现方法

 

java.util.Timer 定时器的用法

2010-11-12 15:29

import java.util.Timer;
import java.util.TimerTask;

/**
* Simple demo that uses java.util.Timer to schedule a task to execute
* once 5 seconds have passed.
*/

public class DataBaseRader {
    Timer timer;//定义一个定时器

    public DataBaseReader(int seconds) {
        timer = new Timer();
        timer.schedule(new MyTask(), seconds*1000);//定义好想要执行的任务和每次执行的时间间隔
    }

    class MyTask extends TimerTask {//定义自己的任务类,一定要继承TimerTask
       public void run() {
            //查询数据库,更新数据
        }
    }

    public static void main(String args[]) {
        System.out.println("About to schedule task.");
      new DataBaseReader(5);
        System.out.println("Task scheduled.");
    }
}

1.如果想同时产生多个请求，定时器是否可以实现呢？比如模拟客户向数据库发送大量请求。还是说用多线程实现。
2.产生多个线程，是否表示每个线程是一个请求？
3.定时器定时执行一个任务，比如每隔几毫秒执行一个大任务，是否可以表示多客户端的请求？这些任务是并发执行的呢还是顺序执行的？应该是一个一个顺序执行的吧，但是如果每个任务需要很长时间，那么后面的任务是否能够在定时器间隔时间后按时执行呢？
4.定时器定时执行任务时，是新建了一个线程执行新任务，还是用原来的老线程继续执行新任务呢？

1、可以模拟的
2、每个线程代表一个请求
3、每个任务都是一个线程，有顺序的，可以并发
4、Timer是一个线程，每个TimerTask都是独立的线程

Timer的作用是每隔一定时间启动一个线程,这个线程的起点是Timer构造函数的那个监听器 new Timer(int x, xxlistner lis)
就是Timer每隔x毫秒向lis发送事件,lis启动一个程序流程,这个程序的流程是你自己定义的,但是不管怎么定义他都是运行在一个新的线程上的.

可以概括成一句话 Timer每隔一定时间启动一个线程执行相应的任务

1.如果想同时产生多个请求，定时器是否可以实现呢？比如模拟客户向数据库发送大量请求。还是说用多线程实现。
程序中for(int i=0;i {
Thread thread = new Thread();
}
这样产生多个线程的操作已经可以模拟同时发送多个请求了,因为For循环的时间基本上是忽略不计的,用定时器当然也可以,但是个人感觉没有必要了

2.产生多个线程，是否表示每个线程是一个请求？
当然每个线程是一个请求

3.定时器定时执行一个任务，比如每隔几毫秒执行一个大任务，是否可以表示多客户端的请求？这些任务是并发执行的呢还是顺序执行的？应该是一个一个顺序执行的吧，但是如果每个任务需要很长时间，那么后面的任务是否能够在定时器间隔时间后按时执行呢？
在问题1中已进行了描述,For循环开多线程的时间完全可以认为这些线程是同时执行的

4.定时器定时执行任务时，是新建了一个线程执行新任务，还是用原来的老线程继续执行新任务呢？
根据你的描述,肯定应该新建新的线程执行请求,为什么要用原来的线程呢?如果需要线程调度的话,JDK5的线程池API已经足够我们用了:
public class MyTimerTaskThread extends TimerTask
{

@Override
public void run() {
// your thread method

}

}

public static void main(String[] args) throws IOException
{
Timer timer = new Timer();
timer.schedule(new MyTimerTaskThread(),100);
}

***********************************

java的定时器使用方法

文章分类:Java编程

定时器类Timer在java.util包中。使用时，先实例化，然后使用实例的schedule(TimerTask task, long delay)方法，设定指定的任务task在指定的延迟delay后执行。定时器任务类TimerTask是抽象类，继承并重写其run()方法，可实现具体任务。
schedule(TimerTask task, Date time)设定指定任务task在指定时间time执行。

cancel()方法结束这个定时器。

schedule(TimerTask task, long delay, long period)方法设定指定任务task在指定延迟delay后进行固定延迟peroid的执行。

scheduleAtFixedRate(TimerTask task, long delay, long period)方法设定指定任务task在指定延迟delay后进行固定频率peroid的执行。

要实现一个定时任务，运用java中的Timer和TimerTask类可以非常容易实现实时调用处理函数。这两个类使用起来非常方便，可以完成我们对定时器的绝大多数需要。

看个简单的例子:

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 block
e.printStackTrace();
}
}
}

static class MyTask extends java.util.TimerTask{
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("________");
}
}
}

＝＝＝＝＝＝＝＝＝＝Java定时器在Web中的应用＝＝＝＝＝＝＝＝＝＝
在web中,定时器的启动一般随web server的启动而启动,一般有两种方法.
方法一：在web.xml里配置一个Servlet，并设置其随web server的启动而启动。然后在该Servlet的init()方法里启动定时器，在destory()方法里销毁定时器。
方法二：在web.xml里配置一个Listener,然后在该Listener的初始化方法里启动定时器，在其销毁的方法朝左销毁定时器。
在servlet中启动定时器
java 代码
import java.io.IOException;  
import java.util.Timer;  
import javax.servlet.RequestDispatcher;  
import javax.servlet.ServletContext;  
import javax.servlet.ServletException;  
import javax.servlet.http.HttpServlet;  
import javax.servlet.http.HttpServletRequest;  
import javax.servlet.http.HttpServletResponse;  

import org.apache.commons.lang.StringUtils;  

public class ConvergeDataServlet extends HttpServlet {  

    private static final long serialVersionUID = 1L;  

    private Timer timer1 = null;  
      
    private Task task1;  
      
    /**
     * Constructor of the object.
     */
    public ConvergeDataServlet() {  
        super();  
    }  

    /**
     * Destruction of the servlet.

     */
    public void destroy() {  
        super.destroy();   
        if(timer1!=null){  
            timer1.cancel();  
        }  
    }  

      
    public void doGet(HttpServletRequest request, HttpServletResponse response)  
            throws ServletException, IOException {  
          
    }  

      
    public void doPost(HttpServletRequest request, HttpServletResponse response)  
            throws ServletException, IOException {  
        doGet(request, response);         
    }  

    // init方法启动定时器  
    public void init() throws ServletException {  
          
        ServletContext context = getServletContext();  
          
        // (true为用定时间刷新缓存)  
        String startTask = getInitParameter("startTask");  
                  
        // 定时刷新时间(分钟)  
        Long delay = Long.parseLong(getInitParameter("delay"));  
          
        // 启动定时器  
        if(startTask.equals("true")){  
            timer1 = new Timer(true);  
            task1 = new Task(context);  
            timer1.schedule(task1, delay * 60 * 1000, delay * 60 * 1000);  
        }  
    }  
}  
定时执行操作
java 代码

/**
*  
* @author callan
*/
import java.util.TimerTask;  

import javax.servlet.ServletContext;  

public class Task extends TimerTask{  

    private ServletContext context;  
      
    private static boolean isRunning = true;  
      
    public Task(ServletContext context){  
        this.context = context;  
    }  
      
          
    @Override
    public void run() {  
        if(isRunning){  
            
        }  
    }  

}  

在web.xml配置这个servlet为服务启动时就调用servlet

< servlet >
     < servlet-name >taskservlet< / servlet-name >
    < servlet-class >com.task< /servlet-class >
    < init-param >
     < param-name >startTask< /param-name >
     < param-value >true< /param-value >
    < /init-param >
    < init-param >
     < param-name >intervalTime< /param-name >
     < param-value >1< /param-value >
    < /init-param >
    < load-on-startup >300< /load-on-startup >
< /servlet >