public class Timer {
    // 任務(wù)隊(duì)列（基于小頂堆實(shí)現(xiàn)）
    private final TaskQueue queue = new TaskQueue();
    // 調(diào)度線程（負(fù)責(zé)執(zhí)行任務(wù)）
    private final TimerThread thread = new TimerThread(queue);
    
    // 構(gòu)造方法：啟動調(diào)度線程
    public Timer() {
        this("Timer-" + serialNumber());
    }
    
    public Timer(String name) {
        thread.setName(name);
        thread.start(); // 啟動TimerThread
    }
    
    // 提交任務(wù)的核心方法（以schedule為例）
    public void schedule(TimerTask task, Date time) {
        // 計(jì)算延遲時(shí)間（相對于當(dāng)前時(shí)間）
        long delay = time.getTime() - System.currentTimeMillis();
        if (delay < 0) delay = 0;
        // 調(diào)用內(nèi)部方法添加任務(wù)
        sched(task, System.currentTimeMillis() + delay, 0);
    }
    
    // 實(shí)際添加任務(wù)到隊(duì)列的方法
    private void sched(TimerTask task, long time, long period) {
        if (time < 0) throw new IllegalArgumentException("Illegal execution time.");
        
        // 同步鎖：保證任務(wù)隊(duì)列操作的線程安全
        synchronized(queue) {
            if (thread.isInterrupted())
                throw new IllegalStateException("Timer already cancelled.");
            
            // 設(shè)置任務(wù)的執(zhí)行時(shí)間和周期
            task.nextExecutionTime = time;
            task.period = period;
            task.state = TimerTask.SCHEDULED;
            
            // 將任務(wù)添加到隊(duì)列（小頂堆）
            queue.add(task);
            // 如果添加的是堆頂任務(wù)，喚醒調(diào)度線程（可能在等待中）
            if (queue.getMin() == task)
                queue.notify();
        }
    }
}

class TaskQueue {
    // 用數(shù)組存儲堆元素（小頂堆）
    private TimerTask[] queue = new TimerTask[128];
    private int size = 0; // 當(dāng)前任務(wù)數(shù)量
    
    // 添加任務(wù)（入隊(duì)）
    void add(TimerTask task) {
        // 擴(kuò)容邏輯（當(dāng)數(shù)組滿時(shí)）
        if (size + 1 == queue.length)
            queue = Arrays.copyOf(queue, 2 * queue.length);
        
        queue[size++] = task;
        // 上浮調(diào)整：維持小頂堆特性
        fixUp(size - 1);
    }
    
    // 獲取堆頂任務(wù)（最早執(zhí)行的任務(wù)）
    TimerTask getMin() {
        return queue[0];
    }
    
    // 移除堆頂任務(wù)（出隊(duì)）
    void removeMin() {
        queue[0] = queue[--size];
        // 下沉調(diào)整：維持小頂堆特性
        fixDown(0);
    }
    
    // 上浮操作：新元素插入后，向上調(diào)整堆
    private void fixUp(int k) {
        while (k > 0) {
            int j = (k - 1) >>> 1; // 父節(jié)點(diǎn)下標(biāo)
            if (queue[j].nextExecutionTime <= queue[k].nextExecutionTime)
                break; // 父節(jié)點(diǎn)更小，無需調(diào)整
            // 交換父節(jié)點(diǎn)和當(dāng)前節(jié)點(diǎn)
            TimerTask tmp = queue[j];
            queue[j] = queue[k];
            queue[k] = tmp;
            k = j;
        }
    }
    
    // 下沉操作：移除堆頂后，向下調(diào)整堆
    private void fixDown(int k) {
        int j;
        while ((j = (k << 1) + 1) < size) { // 左子節(jié)點(diǎn)下標(biāo)
            // 找到左右子節(jié)點(diǎn)中較小的那個(gè)
            if (j + 1 < size && queue[j + 1].nextExecutionTime < queue[j].nextExecutionTime)
                j++;
            if (queue[k].nextExecutionTime <= queue[j].nextExecutionTime)
                break; // 當(dāng)前節(jié)點(diǎn)更小，無需調(diào)整
            // 交換當(dāng)前節(jié)點(diǎn)和子節(jié)點(diǎn)
            TimerTask tmp = queue[k];
            queue[k] = queue[j];
            queue[j] = tmp;
            k = j;
        }
    }
}

class TimerThread extends Thread {
    private final TaskQueue queue;
    
    TimerThread(TaskQueue queue) {
        this.queue = queue;
    }
    
    public void run() {
        try {
            mainLoop(); // 核心循環(huán)：不斷執(zhí)行任務(wù)
        } finally {
            // 線程退出時(shí)，標(biāo)記所有任務(wù)為取消狀態(tài)
            synchronized(queue) {
                queue.isDisposed = true;
                queue.queue = null;
            }
        }
    }
    
    // 核心循環(huán)：調(diào)度任務(wù)的主邏輯
    private void mainLoop() {
        while (true) {
            try {
                TimerTask task;
                boolean taskFired;
                
                // 同步獲取任務(wù)
                synchronized(queue) {
                    // 等待隊(duì)列中有任務(wù)
                    while (queue.size() == 0 && !queue.isDisposed)
                        queue.wait();
                    if (queue.isDisposed)
                        break; // 隊(duì)列已銷毀，退出循環(huán)
                    
                    // 獲取堆頂任務(wù)（最早執(zhí)行的任務(wù)）
                    long currentTime, executionTime;
                    task = queue.getMin();
                    synchronized(task.lock) {
                        if (task.state != TimerTask.SCHEDULED) {
                            queue.removeMin(); // 任務(wù)已取消，移除
                            continue;
                        }
                        currentTime = System.currentTimeMillis();
                        executionTime = task.nextExecutionTime;
                        // 檢查是否到達(dá)執(zhí)行時(shí)間
                        if (executionTime > currentTime) {
                            // 未到時(shí)間：等待差值時(shí)間
                            queue.wait(executionTime - currentTime);
                            taskFired = false;
                        } else {
                            // 已到時(shí)間：移除堆頂任務(wù)
                            queue.removeMin();
                            taskFired = true;
                        }
                    }
                }
                
                // 執(zhí)行任務(wù)（如果已到時(shí)間）
                if (taskFired) {
                    task.run(); // 調(diào)用TimerTask的run()方法
                    // 處理周期性任務(wù)：重新計(jì)算下次執(zhí)行時(shí)間并加入隊(duì)列
                    if (task.period != 0) {
                        synchronized(task.lock) {
                            task.nextExecutionTime = 
                                task.period < 0 ? currentTime - task.period 
                                                : executionTime + task.period;
                            queue.add(task); // 重新入隊(duì)
                        }
                    }
                }
            } catch (InterruptedException e) {
                // 忽略中斷，繼續(xù)循環(huán)
            }
        }
    }
}

package com.ape.test;

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class Test {
    public static void main(String[] args) {
        Timer timer = new Timer();
        final int totalTasks = 3; // 總?cè)蝿?wù)數(shù)

        for(int i = 0; i < totalTasks; i++){
            TimerTask task = new FooTimerTask("task" + i, timer, totalTasks);
            timer.schedule(task, new Date());
        }
    }
}

class FooTimerTask extends TimerTask{
    private String name;
    private Timer timer;
    private int totalTasks;
    private static int completedCount = 0; // 已完成任務(wù)計(jì)數(shù)（靜態(tài)變量共享）

    public FooTimerTask(String name, Timer timer, int totalTasks) {
        this.name = name;
        this.timer = timer;
        this.totalTasks = totalTasks;
    }

    @Override
    public void run() {
        try {
            System.out.println("name:" + name + " startTime=" + new Date());
            Thread.sleep(3000);
            System.out.println("end:" + name + " endTime=" + new Date());
            System.out.println("----------------------------------------");

            // 任務(wù)完成后計(jì)數(shù)，最后一個(gè)任務(wù)完成時(shí)取消Timer，如果不取消Timer，進(jìn)程不會結(jié)束
            synchronized (FooTimerTask.class) {
                completedCount++;
                if (completedCount == totalTasks) {
                    timer.cancel();
                    System.out.println("所有任務(wù)執(zhí)行完畢，Timer已終止");
                }
            }
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}