java實現定時器的四種方式

1. 使用Thread.sleep()方法

Thread.sleep()方法可以讓當前線程暫停執(zhí)行一段時間，我們可以利用它來實現簡單的定時器。

示例代碼：

```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秒
}
}
}
```

該示例中我們使用了一個無限循環(huán)，每次循環(huán)輸出當前運行的時間，并暫停1秒鐘后再繼續(xù)。

優(yōu)點：實現簡單，易于理解。

缺點：無法在定時器運行過程中修改定時器的時間或停止定時器，不適合實現復雜的定時器邏輯。

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()方法停止定時器。

優(yōu)點：使用方便，適合實現一些簡單的定時任務。

缺點：無法在定時器運行過程中修改定時器的時間或停止定時器，不支持并發(fā)操作。

3. 使用ScheduledExecutorService類

ScheduledExecutorService類是Java提供的用于定時執(zhí)行任務的工具類，可以設定定時器的初始延遲時間、間隔時間、并發(fā)量等參數，支持更加靈活的定時器條件設定和停止。

示例代碼：

```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()方法停止定時器。

優(yōu)點：靈活且方便，支持并發(fā)操作，適合實現一些復雜的定時任務。

缺點：算法略有復雜，需要一定的背景知識。

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() // 不重復執(zhí)行
.withIntervalInSeconds(1)
.withRepeatCount(0)
)
.build()
);
Thread.sleep(5000);
scheduler.shutdown();
}
}
```

該示例中我們使用了Quartz框架實現定時器，創(chuàng)建一個自定義的任務，并調度它的執(zhí)行。我們可以通過修改Trigger實現更加復雜的時間調度設定。

優(yōu)點：可以實現各種復雜的計劃和時間設定，適用于大型項目中的復雜定時任務。

缺點：相對于其他方案來說，Quartz的學習和上手成本比較高。