① 怎样直接调用定时任务 java
java中设置定时任务用Timer类可以实现。 一、延时执行 首先，我们定义一个类，给它取个名字叫TimeTask，我们的定时任务，就在这个类的main函数里执行。代码如下： package test; import java.util.Timer; public class TimeTask { public static
② JAVA 怎么自动定时运行一个方法
spring 的定时器。
<!-- 影票系统定时任务 -->
<bean name="quartzFactoryBean"
class="org.springframework.scheling.quartz.SchelerFactoryBean">
<property name="triggers">
<list>
<!--
<ref bean="filmtrigger" />
<ref bean="filmtrigger2" />
<ref bean="filmtrigger3" />
<ref bean="filmtrigger4" />
<ref bean="filmtrigger5" />
<ref bean="filmtrigger6" />
这里随便配置
-->
</list>
</property>
</bean>
<bean name="filmtrigger" class="org.springframework.scheling.quartz.CronTriggerBean">
<property name="jobDetail" ref="filmjob" />
<property name="cronExpression" value="0 1 0 * * ?" /> 0时 1分 0秒启动
<!-- <property name="startDelay" value="3"/> -->
</bean>
<bean id="filmjob"
class="org.springframework.scheling.quartz.">
//下面配置在那个类的那个方法使用定时
<property name="targetObject" ref="类" />
<property name="targetMethod" value="方法" />
<property name="concurrent" value="false" />
</bean>
③ java 定时任务的几种实现方式
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代码启动一个定时任务
在应用里经常都有用到在后台跑定时任务的需求。举个例子，比如需要在服务后台跑一个定时任务来进行非实时计算，清除临时数据、文件等。在本文里，3种不同的实现方法：
普通thread实现
TimerTask实现
ScheledExecutorService实现
1.普通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 !!");
// ------- ends here
try {
Thread.sleep(timeInterval);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
Thread thread = new Thread(runnable);
thread.start();
}
}
2.用Timer和TimerTask
上面的实现是非常快速简便的，但它也缺少一些功能。
用Timer和TimerTask的话与上述方法相比有如下好处：
当启动和去取消任务时可以控制
第一次执行任务时可以指定你想要的delay时间
在实现时，Timer类可以调度任务，TimerTask则是通过在run()方法里实现具体任务。
Timer实例可以调度多任务。
当Timer的构造器被调用时，创建了一个线程，这个线程可以用来调度任务：
import java.util.Timer;
import java.util.TimerTask;
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
}
3.ScheledExecutorService
ScheledExecutorService是从Java SE 5的java.util.concurrent里，做为并发工具类被引进的，这是最理想的定时任务实现方式。
相比于上两个方法，它有以下好处：
相比于Timer的单线程，它是通过线程池的方式来执行任务的
可以很灵活的去设定第一次执行任务delay时间
提供了良好的约定，以便设定执行的时间间隔
通过ScheledExecutorService#scheleAtFixedRate展示这个例子，通过代码里参数的控制，首次执行加了delay时间：
import java.util.concurrent.Executors;
import java.util.concurrent.ScheledExecutorService;
import java.util.concurrent.TimeUnit;
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, 0, 1, TimeUnit.SECONDS);
}
}
⑤ java：如何使用 quartz定时执行任务，例如定时执行System.out.pintln("aa")；看清楚用quartz
}
importstaticorg.quartz.CronScheleBuilder.cronSchele;
importstaticorg.quartz.JobBuilder.newJob;
importstaticorg.quartz.TriggerBuilder.newTrigger;
importjava.text.SimpleDateFormat;
importjava.util.Date;
importorg.quartz.CronTrigger;
importorg.quartz.JobDetail;
importorg.quartz.Scheler;
importorg.quartz.SchelerFactory;
importorg.quartz.impl.StdSchelerFactory;
publicclassTest{
publicvoidgo()throwsException{
//首先，必需要取得一个Scheler的引用
SchelerFactorysf=newStdSchelerFactory();
Schelersched=sf.getScheler();
//jobs可以在scheled的sched.start()方法前被调用
//job1将每隔30分钟执行一次
JobDetailjob=newJob(myJob.class).withIdentity("job1","group1").build();
CronTriggertrigger=newTrigger().withIdentity("trigger1","group1").withSchele(cronSchele("00/30***?")).build();
Dateft=sched.scheleJob(job,trigger);
SimpleDateFormatsdf=newSimpleDateFormat("yyyy-MM-ddHH:mm:ssSSS");
System.out.pintln("aa")；
//开始执行，start()方法被调用后，计时器就开始工作，计时调度中允许放入N个Job
sched.start();
try{
//主线程等待一分钟
Thread.sleep(60L*1000L);
}catch(Exceptione){}
//关闭定时调度，定时器不再工作
sched.shutdown(true);
}
publicstaticvoidmain(String[]args)throwsException{
Testtest=newTest();
test.go();
}
}
⑥ JAVA怎么定时启动服务进程(满意答案给高分)
1、while(true) {
if (当前时间到了11点) {
做你的Task();
}
Thread.sleep(30*1000); //sleep 30 seconds
}
2、写一个.bat文件(里面调用你的Java类)，用Windows的计划任务，每天11点执行这个.bat文件。
3、用开源的Quartz框架，专门做定时任务的。可能需要下载，看看文档，写几个配置文件。
推荐第三种，最专业的。
⑦ 在Java中如何设置一个定时任务的代码应该怎么写
指定定时任务的代来码如下自：
public void schele(TimerTask task,Date time)
比如,我们希望定时任务2006年7月2日0时0分执行,只要给第二个参数传一个时间设置为2006年7月2日0时0分的Date对象就可以了.
有一种情况是,可能我们的程序启动的时候,已经是2006年7月3日了,这样的话,程序一启动,定时任务就开始执行了.
schele最后一个重载的方法是
public void schele(TimerTask task,Date firstTime,long period)