java定时任务可视化

Ⅰ java 定时任务的几种实现方式

1. JDK 自带的定时器实现

   // schele(TimerTask task, long delay) 延迟 delay 毫秒 执行
   // schele(TimerTask task, Date time) 特定时间执行
   public static void main(String[] args) {
   for (int i = 0; i < 10; ++i) {
   new Timer("timer - " + i).schele(new TimerTask() {
   @Override
   public void run() {
   println(Thread.currentThread().getName() + " run ");
   }
   }, 1000);
   }
   }
   2. Quartz 定时器实现

   //首先我们需要定义一个任务类，比如为MyJob02 ，
   //该类需要继承Job类，然后添加execute(JobExecutionContext context)方法，在
   //这个方法中就是我们具体的任务执行的地方。
   //由希望由调度程序执行的组件实现的接口
   public class MyJob02 implements Job {
   @Override
   public void execute(JobExecutionContext context) throws JobExecutionException {
   // TODO Auto-generated method stub
   // 执行响应的任务.
   System.out.println("HelloJob.execute,"+new Date());
   }
   }

   public class QuartzTest5 {
   
   public static void main(String[] args) throws Exception {
   //SchelerFactory 是一个接口，用于Scheler的创建和管理
   SchelerFactory factory = new StdSchelerFactory();
   //从工厂里面拿到一个scheler实例
   //计划表(可能翻译的不太贴切)，现在我们有了要做的内容，
   //与调度程序交互的主要API
   /*
   * Scheler的生命期，从SchelerFactory创建它时开始，
   到Scheler调用shutdown()方法时结束；Scheler被创建后，
   可以增加、删除和列举Job和Trigger，以及执行其它与调度相关的操作
   （如暂停Trigger）。但是，Scheler只有在调用start()方法后，
   才会真正地触发trigger（即执行job）
   */
   Scheler scheler = factory.getScheler();
   //具体任务.
   //用于定义作业的实例
   //JobBuilder - 用于定义/构建JobDetail实例，用于定义作业的实例。
   JobDetail job = JobBuilder.newJob(MyJob.class).withIdentity("job1", "group1").build();
   
   
   //Trigger（即触发器） - 定义执行给定作业的计划的组件
   //TriggerBuilder - 用于定义/构建触发器实例
   CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "group1")
   .withSchele(CronScheleBuilder.cronSchele("0/1 * * * * ?")).build();
   scheler.scheleJob(job, trigger);
   scheler.start();
   
   
   }
   3. Spring boot 任务调度(这个非常容易实现)

   /*
   * 开启对定时任务的支持
   * 在相应的方法上添加@Scheled声明需要执行的定时任务。
   */
   @EnableScheling
   //@EnableScheling注解来开启对计划任务的支持
   public class Application {
   
   public static void main(String[] args) {
   SpringApplication.run(Application.class, args);
   }
   }

   @Component
   public class ScheledTasks {
   private Logger logger = LoggerFactory.getLogger(ScheledTasks.class);
   private int i=0;
   //0 0 0 2 * ?
   @Scheled(cron="* * * 2 * ?")
   //@Scheled 注解用于标注这个方法是一个定时任务的方法
   public void testFixDelay() {
   logger.info("执行方法"+i++);
   }
   

Ⅱ java的几种定时任务

java定时任务有三种：

- JDK自带 ：JDK自带的Timer以及JDK1.5+ 新增的ScheledExecutorService；

- Quartz ：简单却强大的JAVA作业调度框架

- Spring3.0以后自带的task ：可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多；

代码参考：

1. JDK 自带的定时器实现

   schele(TimerTask task, Date time) 特定时间执行

   
   public static void main(String[] args) {

   
   for (int i = 0; i < 10; ++i) {

   
   new Timer("timer - " + i).schele(new TimerTask() {

   
   @Override
   public void run() {

   
   println(Thread.currentThread().getName() + " run ");

   
   }

   
   }, new Date(System.currentTimeMillis() + 2000));

   
   }
   }

2. Quartz 定时器实现

   2.1 通过maven引入依赖（这里主要介绍2.3.0） 注意：shiro-scheler中依赖的是1.x版本 如果同时使用会冲突

   <!-- https://mvnrepository.com/artifact/org.quartz-scheler/quartz -->

   
   <dependency>

   
   <groupId>org.quartz-scheler</groupId>

   
   <artifactId>quartz</artifactId>

   
   <version>2.3.0</version>

   
   </dependency>

   2.2创建Job类

   public class TestJob implements Job{

   
   @Override
   public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {

   
   println(Thread.currentThread().getName() + " test job begin " + DateUtil.getCurrentTimeStr());

   
   }
   }

   2.3调度任务

   public static void main(String[] args) throws InterruptedException, SchelerException {
   

   
   Scheler scheler = new StdSchelerFactory().getScheler();

   
   // 开始

   
   scheler.start();

   
   // job 唯一标识 test.test-1

   
   JobKey jobKey = new JobKey("test" , "test-1");

   
   JobDetail jobDetail = JobBuilder.newJob(TestJob.class).withIdentity(jobKey).build();

   
   Trigger trigger = TriggerBuilder.newTrigger() .withIdentity("test" , "test")

// 延迟一秒执行

.startAt(new Date(System.currentTimeMillis() + 1000))

// 每隔一秒执行 并一直重复

.withSchele(SimpleScheleBuilder.simpleSchele().withIntervalInSeconds(1).repeatForever())
.build();

scheler.scheleJob(jobDetail , trigger);

Thread.sleep(5000);
// 删除job

scheler.deleteJob(jobKey);

}

3.Spring 相关的任务调度

3.1 配置文件实现

spring-schele.xml

<task:scheler id="myScheler" pool-size="10" />

<task:scheled-tasks scheler="myScheler">

<task:scheled ref="job" method="test" cron="0 * * * * ?"/>

</task:scheled-tasks>

3.2注解实现

spring-schele.xml

<task:scheler id="myScheler" pool-size="10" />

// 启用注解

<task:annotation-driven scheler="myScheler"/>

@Component
public class Task{

@Scheled(cron="0/5 * * * * ? ") //每5秒执行一次
public void execute(){

DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

System.out.println(sdf.format(DateTime.now().toDate())+"*********B任务每5秒执行一次进入测试");

}
}

Ⅲ java消息定时推送怎么实现

定时任务实现的几种方式：
Timer：这是java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让程序按照某一个频度执行，但不能在指定时间运行。一般用的较少。
ScheledExecutorService：也jdk自带的一个类；
是基于线程池设计的定时任务类,每个调度任务都会分配到线程池中的一个线程去执行,也就是说,任务是并发执行,互不影响。Spring Task：Spring3.0以后自带的task，可以看成一个轻量级的Quartz，而且使用起来比Quartz简单许多。
Quartz：这是一个功能比较强大的的调度器，可以让程序在指定时间执行，也可以按照某一个频度执行，配置起来稍显复杂。
消息推送推荐选择极光推送软件，JPush 是经过考验的大规模 App 推送平台，每天推送消息量级为数百亿条。 开发者集成 SDK 后，可以通过调用 API 推送消息。同时，JPush 提供可视化的 web 端控制台发送通知，统计分析推送效果。 JPush 全面支持 Android, iOS, Winphone 三大手机平台。

Ⅳ JAVA实现定时任务的几种方式

Java 基本的定时任务，总结方法有三种：

1 创建一个thread，然后让它在while循环内里一直运行着，通过容sleep方法来达到定时任务的效果；

2 用Timer和TimerTask与第一种方法相比有如下好处：

• 当启动和去取消任务时可以控制

• 第一次执行任务时可以指定你想要的delay时间

3 用ScheledExecutorService是从的java.util.concurrent里，做为并发工具类被引进的，这是最理想的定时任务实现方式，相比于上两个方法，它有以下好处：

• 相比于Timer的单线程，它是通过线程池的方式来执行任务的

• 可以很灵活的去设定第一次执行任务delay时间

• 提供了良好的约定，以便设定执行的时间间隔

Ⅳ java定时任务怎么实现

/**
* 普通thread
* 这是最常见的，创建一个thread，然后让它在while循环里一直运行着，
* 通过sleep方法来达到定时任务的效果。这样可以快速简单的实现，代码如下：
* @author GT
*
*/
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 !!");
// ------- ends here
try {
Thread.sleep(timeInterval);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
Thread thread = new Thread(runnable);
thread.start();
}
}
[java] view plain
import java.util.Timer;
import java.util.TimerTask;
/**
*
* 于第一种纤核缺方式相比，优势 1>当毁辩启动和去取消任务时可以控制 2>第一次执行任务时可以指定你氏码想要的delay时间
*
* 在实现时，Timer类可以调度任务，TimerTask则是通过在run()方法里实现具体任务。 Timer实例可以调度多任务，它是线程安全的。
* 当Timer的构造器被调用时，它创建了一个线程，这个线程可以用来调度任务。 下面是代码：
*
* @author GT
*
*/
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 !!!");
}
};
Timer timer = new Timer();
long delay = 0;
long intevalPeriod = 1 * 1000;
// scheles the task to be run in an interval
timer.scheleAtFixedRate(task, delay, intevalPeriod);
} // end of main
}
[java] view plain
import java.util.concurrent.Executors;
import java.util.concurrent.ScheledExecutorService;
import java.util.concurrent.TimeUnit;
/**
*
*
* ScheledExecutorService是从Java SE5的java.util.concurrent里，做为并发工具类被引进的，这是最理想的定时任务实现方式。
* 相比于上两个方法，它有以下好处：
* 1>相比于Timer的单线程，它是通过线程池的方式来执行任务的
* 2>可以很灵活的去设定第一次执行任务delay时间
* 3>提供了良好的约定，以便设定执行的时间间隔
*
* 下面是实现代码，我们通过ScheledExecutorService#scheleAtFixedRate展示这个例子，通过代码里参数的控制，首次执行加了delay时间。
*
*
* @author GT
*
*/
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 !!");
}
};
ScheledExecutorService service = Executors
.();
// 第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间
service.scheleAtFixedRate(runnable, 10, 1, TimeUnit.SECONDS);
}
}

Ⅵ 关于java定时任务

第一种方抄法是写一个线程,每秒运行一袭次,检测当前系统时间,如果是0时0分0秒,那么就把count设为1
第二种方法是用quartz框架,进行调度,调度规则是每天0点整运行一次,运行的内容就是把count设为1

Ⅶ java中怎么实现定时功能

我们可以使用Timer和TimerTask类在java中实现定时任务，详细说明如下：

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

2、示例代码
该示例实现这样一个功能，在系统运行期间，每30分钟，系统自动检查连接池中的可用连接数，并输出到日志中。
首先创建一个需要定时执行的任务类，这个任务类需要继承TimerTask，然后重写run()方法，run()方法体中的代码就是定时需要执行的操作，在本demo中，就是获取连接池中当前可用连接数，并输出到日志中，具体实现代码如下：
public class TaskAvailableConnectNumber extends TimerTask {
private Logger log = Logger.getLogger(TaskAvailableConnectNumber.class);
private ConnectionPool pool=ConnectionPool.getInstance();
@Override
publicvoid run() {
log.debug("当前连接池中可用连接数"+pool.getAvailableConnectNumber());
}
}
下面定义一个监听器，负责在应用服务器启动时打开定时器，监听器需要实现ServletContextListener接口，并重写其中的contextInitialized()和contextDestroyed()方法，代码如下：
public class OnLineListener implements ServletContextListener{
private Logger log = Logger.getLogger(OnLineListener.class);
Timer timer = null;
//在应用服务器启动时，会执行该方法
publicvoid contextInitialized(ServletContextEvent arg0) {
//创建一个定时器，用于安排需要定时执行的任务。
timer = new Timer();
//为定时器安排需要定时执行的任务，该任务就是前面创建的任务类TaskAvailableConnectNumber，并指定该任务每30分钟执行一次。
timer.schele(new TaskAvailableConnectNumber(), 0, 30*60*1000);
log.debug("启动定时器");
}
//应用服务器关闭时，会执行该方法，完成关闭定时器的操作。
public void contextDestroyed(ServletContextEvent arg0) {
if(timer!=null){
timer.cancel();//关闭定时器
log.debug("-----定时器销毁--------");
}
}
}
监听器要想正常运行，需要在web.xml文件中进行配置，配置信息如下：
<!-- 监听器配置开始 -->
<listener>
<listener-class>
cn.sdfi.listen.OnLineListener
</listener-class>
</listener>
<!-- 监听器配置结束 -->
以上步骤完成后，一个简单的定时器就算开发完成了。

Ⅷ JAVA中定时自动完成任务的实现

JAVA中定时自动完成任务的实现要用到JAVA中的定时器TimerTask和监听器 听起来貌似有点困难但是实现起来还是比较容易的！纸老虎~~！

下面的列子很详细 是关于定时向服务器上传（也可以是其他的动作这是看需要关于上传我博客有写过可以参考）文件的列子简单的 步就可以实现

首先创建动作bean

package sun time ;

public class UploadFile{

/**

*实现上传的代码s省略 可以看下我下面的 篇日志

__haiming/blog/static/ / 使用 *** arupload 实现上传下载[有例子]

__haiming/blog/static/ / 使用Struts 多文件上传

*/

public void upload()

{

System out println( 系统自动的上传文件了 );

}

}

创建定时器MyTaker并完成相应的功能

package sun time ;

import java util Calendar;

import java util TimerTask;

import javax servlet ServletContext;

public class MyTaker extends TimerTask {

private static boolean isRun = false;

private ServletContext context ;

private Calendar ca = Calendar getInstance();

public MyTaker(ServletContext context)

{

ntext = context;

}

@Override

public void run() {

if(!isRun){

if( ==ca get(Calendar MINUTE)){

isRun = true;

context log( 正在执行所加载的任务 );

UploadFile uf= new UploadFile();

uf upload();

isRun =false;

context log( 任务顺利完成 );

}

}

else

{

System out println( 任务还没有执行完毕 );

}

}

}

创建监听器ContextListener

package sun time ;

import javax servlet ServletContextEvent;

import javax servlet ServletContextListener;

import sun time MyTaker;

import java util *;

public class ContexListener implements ServletContextListener{

private Timer timer = null;

@Override

public void contextDestroyed(ServletContextEvent event) {

timer cancel();

event getServletContext() log( 任务列表已经销毁了 );

}

@Override

public void contextInitialized(ServletContextEvent event) {

timer = new Timer(true);

event getServletContext() log( 服务器已经启动了 );

timer schele(new MyTaker(event getServletContext()) );///每隔多长时间检查扫描一次

event getServletContext() log( 已经加载了任务的列表 );

}

}

最后一步就是在web xml中配置监听

<! Java定时器 >

<listener>

<listener class> sun time ContexListener</listener class>

lishixin/Article/program/Java/hx/201311/26450