「java定时任务依赖作业」java定时任务实现的几种方式
今天给各位分享java定时任务依赖作业的知识，其中也会对java定时任务实现的几种方式进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
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 copy
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;
// schedules the task to be run in an interval
timer.scheduleAtFixedRate(task, delay, intevalPeriod);
} // end of main
}
[java] view plain copy
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时间。
*
*
* @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 !!");
}
};
ScheduledExecutorService service = Executors
.newSingleThreadScheduledExecutor();
// 第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间
service.scheduleAtFixedRate(runnable, 10, 1, TimeUnit.SECONDS);
}
}
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 schedule(new MyTaker(event getServletContext()) );///每隔多长时间检查扫描一次
event getServletContext() log( 已经加载了任务的列表 );
}
}
最后一步就是在web xml中配置监听
! Java定时器
listener
listener class sun time ContexListener/listener class
lishixinzhi/Article/program/Java/hx/201311/26450
Java 定时任务的几种实现方式
1 创建一个thread，然后让它在while循环里一直运行着，通过sleep方法来达到定时任务的效果；
2 用Timer和TimerTask与第一种方法相比有如下好处：
当启动和去取消任务时可以控制
第一次执行任务时可以指定你想要的delay时间
3 用ScheduledExecutorService是从的java.util.concurrent里，做为并发工具类被引进的，这是最理想的定时任务实现方式，相比于上两个方法，它有以下好处：
相比于Timer的单线程，它是通过线程池的方式来执行任务的
可以很灵活的去设定第一次执行任务delay时间
提供了良好的约定，以便设定执行的时间间隔
java 定时任务
这个是我在网上找的不知道是不是你要的：
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，就没有必要再写示例代码了吧
java的几种定时任务
java定时任务有三种：
- JDK自带 ：JDK自带的Timer以及JDK1.5+ 新增的ScheduledExecutorService；
- Quartz ：简单却强大的JAVA作业调度框架
- Spring3.0以后自带的task ：可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多；
代码参考：
JDK 自带的定时器实现
schedule(TimerTask task, Date time) 特定时间执行
public static void main(String[] args) {
for (int i = 0; i 10; ++i) {
new Timer("timer - " + i).schedule(new TimerTask() {
@Override
public void run() {
println(Thread.currentThread().getName() + " run ");
}
}, new Date(System.currentTimeMillis() + 2000));
}
}
Quartz 定时器实现
2.1 通过maven引入依赖（这里主要介绍2.3.0） 注意：shiro-scheduler中依赖的是1.x版本 如果同时使用会冲突
!-- --
dependency
groupIdorg.quartz-scheduler/groupId
artifactIdquartz/artifactId
version2.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, SchedulerException {
Scheduler scheduler = new StdSchedulerFactory().getScheduler();
// 开始
scheduler.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))
// 每隔一秒执行 并一直重复
.withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(1).repeatForever())
.build();
scheduler.scheduleJob(jobDetail , trigger);
Thread.sleep(5000);
// 删除job
scheduler.deleteJob(jobKey);
}
3.Spring 相关的任务调度
3.1 配置文件实现
spring-schedule.xml
task:scheduler id="myScheduler" pool-size="10" /
task:scheduled-tasks scheduler="myScheduler"
task:scheduled ref="job" method="test" cron="0 * * * * ?"/
/task:scheduled-tasks
3.2注解实现
spring-schedule.xml
task:scheduler id="myScheduler" pool-size="10" /
// 启用注解
task:annotation-driven scheduler="myScheduler"/
@Component
public class Task{
@Scheduled(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 定时任务的几种实现方式
JDK 自带的定时器实现
// schedule(TimerTask task, long delay) 延迟 delay 毫秒 执行
// schedule(TimerTask task, Date time) 特定时间执行
public static void main(String[] args) {
for (int i = 0; i 10; ++i) {
new Timer("timer - " + i).schedule(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 {
//SchedulerFactory 是一个接口，用于Scheduler的创建和管理
SchedulerFactory factory = new StdSchedulerFactory();
//从工厂里面拿到一个scheduler实例
//计划表(可能翻译的不太贴切)，现在我们有了要做的内容，
//与调度程序交互的主要API
/*
* Scheduler的生命期，从SchedulerFactory创建它时开始，
到Scheduler调用shutdown()方法时结束；Scheduler被创建后，
可以增加、删除和列举Job和Trigger，以及执行其它与调度相关的操作
（如暂停Trigger）。但是，Scheduler只有在调用start()方法后，
才会真正地触发trigger（即执行job）
*/
Scheduler scheduler = factory.getScheduler();
//具体任务.
//用于定义作业的实例
//JobBuilder - 用于定义/构建JobDetail实例，用于定义作业的实例。
JobDetail job = JobBuilder.newJob(MyJob.class).withIdentity("job1", "group1").build();
//Trigger（即触发器） - 定义执行给定作业的计划的组件
//TriggerBuilder - 用于定义/构建触发器实例
CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "group1")
.withSchedule(CronScheduleBuilder.cronSchedule("0/1 * * * * ?")).build();
scheduler.scheduleJob(job, trigger);
scheduler.start();
}
3. Spring boot 任务调度(这个非常容易实现)
/*
* 开启对定时任务的支持
* 在相应的方法上添加@Scheduled声明需要执行的定时任务。
*/
@EnableScheduling
//@EnableScheduling注解来开启对计划任务的支持
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
@Component
public class ScheduledTasks {
private Logger logger = LoggerFactory.getLogger(ScheduledTasks.class);
private int i=0;
//0 0 0 2 * ?
@Scheduled(cron="* * * 2 * ?")
//@Scheduled 注解用于标注这个方法是一个定时任务的方法
public void testFixDelay() {
logger.info("执行方法"+i++);
}
java定时任务依赖作业的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java定时任务实现的几种方式、java定时任务依赖作业的信息别忘了在本站进行查找喔。