【多线程学习】深入探究定时器的重点和应用场景

import java.util.Timer;
import java.util.TimerTask;
 
public class TimerExample {
    public static void main(String[] args) {
        Timer timer = new Timer();
        // 任务类
        TimerTask task = new TimerTask() {
            @Override
            public void run() {
                System.out.println("任务执行了");
            }
        };
        
        // 安排任务在1秒后执行，然后每隔1秒执行一次
        timer.scheduleAtFixedRate(task, 1000, 1000);
        
        // 记得在程序结束时取消定时器，以避免潜在的内存泄漏
        // timer.cancel();
    }
}

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
 
public class ScheduledExecutorExample {
    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
        
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println("Scheduled任务执行了");
            }
        };
        
        // 安排任务在1秒后执行，然后每隔1秒执行一次
        executor.scheduleAtFixedRate(task, 1, 1, TimeUnit.SECONDS);
        
        // 记得在程序结束时关闭executor，以释放资源
        // executor.shutdown();
    }
}

// 定义一个实现了Comparable接口的定时任务类，用于存储Runnable任务及其执行时间
class MyTimerTask implements Comparable<MyTimerTask> {
    private Runnable runnable; // Runnable对象，代表具体要执行的任务
    private long time; // 记录该任务应该被执行的具体时间（系统当前时间+延迟时间）
 
    // 构造方法，传入一个Runnable任务和延迟执行的时间
    public MyTimerTask(Runnable runnable, long delay) {
        this.runnable = runnable;
        this.time = System.currentTimeMillis() + delay;
    }
 
    // 获取任务的执行时间
    public long getTime() {
        return time;
    }
 
    // 执行任务
    public void run() {
        runnable.run();
    }
 
    // 重写compareTo方法，用于比较两个任务的执行时间，以便放入PriorityQueue按时间顺序排序
    @Override
    public int compareTo(MyTimerTask o) {
        return (int) (this.getTime() - o.getTime());
    }
}
 
// 定时器类，负责调度任务
class MyTimer {
    private PriorityQueue<MyTimerTask> q = new PriorityQueue<>(); // 存储定时任务的优先级队列
    private Object locker = new Object(); // 同步锁对象，用于线程同步
 
    // 定时器构造方法，启动一个后台线程执行定时任务
    public MyTimer() {
        Thread t = new Thread(() -> {
            try {
                // 无限循环，直到程序结束
                while (true) {
                    synchronized (locker) {
                        // 如果队列为空，则等待新的任务加入
                        if (q.size() == 0) {
                            locker.wait();
                        }
 
                        // 获取队列中下一个即将执行的任务
                        MyTimerTask myTimerTask = q.peek();
                        long nowTime = System.currentTimeMillis();
 
                        // 检查当前时间是否大于等于任务执行时间
                        if (nowTime >= myTimerTask.getTime()) {
                            // 执行任务并从队列中移除已完成的任务
                            myTimerTask.run();
                            q.poll();
                        } else {
                            // 如果任务未到执行时间，线程等待剩余时间
                            locker.wait(myTimerTask.getTime() - nowTime);
                        }
                    }
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        t.start();
    }
 
    // 调度方法，将一个任务及其延迟执行时间添加到定时器中
    public void schedule(Runnable runnable, long delay) {
        synchronized (locker) {
            MyTimerTask task = new MyTimerTask(runnable, delay); // 创建一个新的定时任务
            q.offer(task); // 将任务添加到优先级队列中
            locker.notify(); // 唤醒等待的任务调度线程
        }
    }
}
 
// 主函数，演示如何使用MyTimer类调度任务
public class Demo18 {
    public static void main(String[] args) {
        MyTimer myTimer = new MyTimer();
 
        // 调度三个任务，分别延迟1000ms、2000ms和3000ms执行
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello 1000");
            }
        }, 1000);
 
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello 2000");
            }
        }, 2000);
 
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello 3000");
            }
        }, 3000);
    }
}