定时任务

来源：互联网发布：linux 内核参数编辑：程序博客网时间：2024/05/22 16:21

一、java定时任务三种

第一种：

        /**
         * 普通thread
         * 这是最常见的，创建一个thread，然后让它在while循环里一直运行着，
         * 通过sleep方法来达到定时任务的效果。这样可以快速简单的实现，代码如下：
          */
         public class Task1 {
             public static void main(String[] args) {
                 // run in a second
                 final long timeInterval = 1000;
                 Runnable runnable = new Runnable() {
                     public void run() {
                         while (true) {
                             // ------- code for task to run
                             System.out.println("Hello Lnint !!");
                             // ------- ends here
                             try {
                                 Thread.sleep(timeInterval);
                             } catch (InterruptedException e) {
                                 e.printStackTrace();
                             }
                         }
                     }
                 };
                 Thread thread = new Thread(runnable);
                 thread.start();
             }
         }

第二种

      import java.util.Timer;
         import java.util.TimerTask;
         /**
         *
         * 于第一种方式相比，优势 1>当启动和去取消任务时可以控制 2>第一次执行任务时可以指定你想要的delay时间
         *
         * 在实现时，Timer类可以调度任务，TimerTask则是通过在run()方法里实现具体任务。 Timer实例可以调度多任务，它是线程安全的。
         * 当Timer的构造器被调用时，它创建了一个线程，这个线程可以用来调度任务。下面是代码：
          */
         public class Task2 {
             public static void main(String[] args) {
                 TimerTask task = new TimerTask() {
                     @Override
                     public void run() {
                         // task to run goes here
                         System.out.println("Hello Lnint !!");
                     }
                 };
                 Timer timer = new Timer();
                 long delay = 0;
                 long intevalPeriod = 1 * 1000;
                 // schedules the task to be run in an interval
                 timer.scheduleAtFixedRate(task, delay, intevalPeriod);
             } // end of main
         }

第三种

         import java.util.concurrent.Executors;
         import java.util.concurrent.ScheduledExecutorService;
         import java.util.concurrent.TimeUnit;
         /**
          * ScheduledExecutorService是从Java SE5的java.util.concurrent里，做为并发工具类被引进的，这是最理想的定时任务实现方式。
         * 相比于上两个方法，它有以下好处：
         * 1>相比于Timer的单线程，它是通过线程池的方式来执行任务的
         * 2>可以很灵活的去设定第一次执行任务delay时间
         * 3>提供了良好的约定，以便设定执行的时间间隔
          * 下面是实现代码，我们通过ScheduledExecutorService#scheduleAtFixedRate展示这个例子，通过代码里参数的控制，首次执行加了delay时间。
          */
         public class Task3 {
             public static void main(String[] args) {
                 Runnable runnable = new Runnable() {
                     public void run() {
                         // task to run goes here
                         System.out.println("Hello Lnint !!");
                     }
                 };
                 ScheduledExecutorService service = Executors
                         .newSingleThreadScheduledExecutor();
                 // 第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间
                 service.scheduleAtFixedRate(runnable, 10, 1, TimeUnit.SECONDS);
             }
         }

二、java web 定时

第一步：

   public class TimerManager {
              //时间间隔
               private static final long PERIOD_DAY = 24 * 60 * 60 * 1000;
               public TimerManager() {
                    Calendar calendar = Calendar.getInstance();
                    /*** 定制每日2:00执行方法 ***/
                    calendar.set(Calendar.HOUR_OF_DAY, 16);
                    calendar.set(Calendar.MINUTE, 10);
                    calendar.set(Calendar.SECOND, 0);
                    Date date=calendar.getTime(); //第一次执行定时任务的时间
                    System.out.println(date);
                    System.out.println("before 方法比较："+date.before(new Date()));
                    //如果第一次执行定时任务的时间小于当前的时间
                    //此时要在第一次执行定时任务的时间加一天，以便此任务在下个时间点执行。如果不加一天，任务会立即执行。循环执行的周期则以当前时间为准
                    if (date.before(new Date())) {
                        date = this.addDay(date, 1);
                        System.out.println(date);
                    }
                    Timer timer = new Timer();
                    NFDFlightDataTimerTask task = new NFDFlightDataTimerTask();
                    //安排指定的任务在指定的时间开始进行重复的固定延迟执行。
                    timer.schedule(task,date,PERIOD_DAY);
                   }
                   // 增加或减少天数
                   public Date addDay(Date date, int num) {
                    Calendar startDT = Calendar.getInstance();
                    startDT.setTime(date);
                    startDT.add(Calendar.DAY_OF_MONTH, num);
                    return startDT.getTime();
                   }
         }

第二步：

/**
         * 在 TimerManager 这个类里面，大家一定要注意时间点的问题。如果你设定在凌晨2点执行任务。但你是在2点以后
         *发布的程序或是重启过服务，那这样的情况下，任务会立即执行，而不是等到第二天的凌晨2点执行。为了，避免这种情况
         *发生，只能判断一下，如果发布或重启服务的时间晚于定时执行任务的时间，就在此基础上加一天。
          */
         public class NFDFlightDataTimerTask extends TimerTask {
             private static SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
             @Override
             public void run() {
                 try {
                      //在这里写你要执行的内容
                     System.out.println("执行当前时间"+formatter.format(Calendar.getInstance().getTime()));
                 } catch (Exception e) {
                     System.out.println("-------------解析信息发生异常--------------");
                 }
             }
         }

第三步：

public class NFDFlightDataTaskListener implements  ServletContextListener {
              public void contextInitialized(ServletContextEvent sce) {
                   new TimerManager();
              }
              public void contextDestroyed(ServletContextEvent sce) {
                  // TODO Auto-generated method stub
              }
          }

第四步：

配置web.xml文件
         
         <listener>
             <listener-class>com.eh.util.NFDFlightDataTaskListener</listener-class>
         </listener>

三、spring定时三种

第一种：

ScheduledTimerTask: Spring的ScheduledTimerTask定义了一个定时器任务的运行周期，遗憾的是，你可以指定任务执行的频度，但你无法精确指定它何时运行，这就需要用到第二种Quartz进行任务调度；

创建一个业务任务，在Spring配置文件中声明；
在Spring 配置文件中，配置ScheduledTimerTask ，并且关联上自定义的任务实例；
启动定时器，Spring的TimerFactoryBean负责启动定时任务

第二种

使用 Quartz：还是老样子定义业务逻辑任务：

在Spring中声明并且配置作业调度的触发方式：

这里 Quartz的作业触发器有两种，分别是

org.springframework.scheduling.quartz.SimpleTriggerBean

org.springframework.scheduling.quartz.CronTriggerBean

1.SimpleTriggerBean，只支持按照一定频度调用任务，如每隔一段时间运行一次。

<bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">

<property name="jobDetail" ref="myJob" />

<property name="startDelay" value="0" />

<property name="repeatInterval" value="2000" />

</bean>

2.CronTriggerBean，支持到指定时间运行一次，如每天12:00运行一次,如上配置；

配置调度工厂

org.springframework.scheduling.quartz.SchedulerFactoryBean，代码如上；

启动你的应用即可

第三种：

使用 Spring-Task

Spring自带的定时任务工具，spring task，可以将它比作一个轻量级的Quartz，而且使用起来很简单，除spring相关的包外不需要额外的包，而且支持注解和配置文件两种：

第一步：编写任务类；TaskJob,method job1 --代码省略

第二步：在spring配置文件头中添加命名空间及描述

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:task="http://www.springframework.org/schema/task"

xsi:schemaLocation="http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd">

第三步：spring配置文件中设置具体的任务

<task:scheduled-tasks>

<task:scheduled ref="taskJob" method="job1" cron="0 * * * * ?"/>

</task:scheduled-tasks>

<context:component-scan base-package="com.alibaba.mytask" />

说明：ref参数指定的即任务类，method指定的即需要运行的方法，cron及cronExpression表达式，具体写法这里不介绍了，<context:component-scan base-package="com.alibaba.mytask" />spring扫描注解用的。

四、js定时

1.循环执行：每隔一段时间执行

不带参数：

</script>

带参数：

</script>

2.定时执行：延时固定时间后去执行一段函数

不带参数：

//定时执行，5秒后执行show()
window.setTimeout(show,5000);
function show()
{
alert(“bbb”);
}
</script>

带参数：

//定时执行，5秒后执行showalert()
window.setTimeout(function(){
showalert(“bbbbbb”);
},5000);
</script>

阅读全文

0 0