java实现定时器的四种方式

java实现定时器的四种方式

1. 使用Thread.sleep()方法

Thread.sleep()方法可以让当前线程暂停执行一段时间，我们可以利用它来实现简单的定时器。

示例代码：

```java
public class TimerDemo1 {
public static void main(String[] args) throws InterruptedException {
int count = 0;
while (true) {
System.out.println("定时器已经运行了 " + (++count) + " 秒");
Thread.sleep(1000); // 暂停1000毫秒，即1秒
}
}
}
```

该示例中我们使用了一个无限循环，每次循环输出当前运行的时间，并暂停1秒钟后再继续。

优点：实现简单，易于理解。

缺点：无法在定时器运行过程中修改定时器的时间或停止定时器，不适合实现复杂的定时器逻辑。

2. 使用Timer类

Timer类是Java提供的一个简单的定时器工具，可以轻松实现定时器的开启、停止、暂停等操作。

示例代码：

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

public class TimerDemo2 {
public static void main(String[] args) throws InterruptedException {
Timer timer = new Timer();
int count = 0;
timer.schedule(new TimerTask() {
public void run() {
System.out.println("定时器已经运行了 " + (++count) + " 秒");
}
}, 1000, 1000);
Thread.sleep(5000);
timer.cancel();
}
}
```

该示例中我们使用了Timer类实现定时器的功能，使用timer.schedule()方法开启定时器，可以设定初始延迟时间、定时器间隔时间，并通过timer.cancel()方法停止定时器。

优点：使用方便，适合实现一些简单的定时任务。

缺点：无法在定时器运行过程中修改定时器的时间或停止定时器，不支持并发操作。

3. 使用ScheduledExecutorService类

ScheduledExecutorService类是Java提供的用于定时执行任务的工具类，可以设定定时器的初始延迟时间、间隔时间、并发量等参数，支持更加灵活的定时器条件设定和停止。

示例代码：

```java
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class TimerDemo3 {
public static void main(String[] args) throws InterruptedException {
ScheduledExecutorService executor = Executors.newScheduledThreadPool(1); // 开启一个线程池
int count = 0;
executor.scheduleAtFixedRate(() -> System.out.println("定时器已经运行了 " + (++count) + " 秒"), 1, 1, TimeUnit.SECONDS);
Thread.sleep(5000);
executor.shutdownNow();
}
}
```

该示例中我们使用了ScheduledExecutorService类实现定时器的功能，在executor.scheduleAtFixedRate()方法中设定了初始延迟时间、定时器间隔时间，并通过executor.shutdownNow()方法停止定时器。

优点：灵活且方便，支持并发操作，适合实现一些复杂的定时任务。

缺点：算法略有复杂，需要一定的背景知识。

4. 使用Quartz类

Quartz是Java中一个强大的定时器框架，支持各种复杂的计划和时间设定，适用于大型项目中的复杂定时任务。

示例代码：

```java
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.impl.StdSchedulerFactory;

import static org.quartz.JobBuilder.newJob;
import static org.quartz.TriggerBuilder.newTrigger;
import static org.quartz.SimpleScheduleBuilder.simpleSchedule;
import static org.quartz.CronScheduleBuilder.cronSchedule;

public class TimerDemo4 {
public static void main(String[] args) throws SchedulerException, InterruptedException {
Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler(); // 获取调度器
scheduler.start();
Job myJob = new Job() { // 自定义任务
public void execute(JobExecutionContext arg0) throws JobExecutionException {
System.out.println("调度器运行中...");
}
};
scheduler.scheduleJob(
newJob(myJob.getClass()) // 设置任务
.withIdentity("myJob", "group1")
.build(),
newTrigger()
.withIdentity("myJobTrigger", "group1")
.withSchedule(
simpleSchedule() // 不重复执行
.withIntervalInSeconds(1)
.withRepeatCount(0)
)
.build()
);
Thread.sleep(5000);
scheduler.shutdown();
}
}
```

该示例中我们使用了Quartz框架实现定时器，创建一个自定义的任务，并调度它的执行。我们可以通过修改Trigger实现更加复杂的时间调度设定。

优点：可以实现各种复杂的计划和时间设定，适用于大型项目中的复杂定时任务。

缺点：相对于其他方案来说，Quartz的学习和上手成本比较高。