PunctualTimer

一个高精度通用定时器，支持浏览器、Node.js、小程序等多环境运行。提供基础定时器功能，以及高级任务编排、批量管理和高并发定时器池等扩展能力。

特性

核心特性

• 🎯 高精度计时：基于 requestAnimationFrame（浏览器）和高性能定时器（Node.js）实现
• 🌍 多环境兼容：自动检测运行环境并选择最优计时方案
  • ✅ 浏览器（Chrome、Firefox、Safari、Edge）
  • ✅ Node.js 14+
  • ✅ 小程序（微信、支付宝、百度、字节、QQ）
  • ✅ uni-app（App 端、H5、小程序）
• 🔄 丰富的生命周期：支持启动、暂停、恢复、停止、销毁等完整生命周期管理
• ⚡ 性能优化：智能降频、空闲休眠机制，降低功耗
• 📦 零依赖：纯 TypeScript 实现，无任何外部依赖
• 🔒 类型安全：完整的 TypeScript 类型定义

高级扩展功能

• 📋 任务编排能力（TaskScheduler）

  • 延迟执行：支持任务延迟启动
  • 失败重试：自定义重试策略和间隔
  • 循环限制：控制任务最大执行次数
  • 任务组合：支持任务链式调用和并行组
  • 依赖关系：串行/并行执行模式，自动依赖解析

• 🎛️ 批量管理能力（TimerManager）

  • 批量启停：一次性操作多个定时器
  • 分组管理：按组和标签组织定时器
  • 状态查询：批量获取定时器运行状态
  • 灵活过滤：支持多种过滤条件组合

• 🚀 高并发支持（TimerPool）

  • 定时器池：池化管理大量定时器实例
  • 数量限制：防止资源耗尽的容量控制
  • 自动清理：智能回收空闲和已销毁定时器
  • 统计监控：实时跟踪使用情况和性能指标
  • 内存优化：避免内存泄漏，支持数千至上万实例

安装

npm install punctual-timer
# 或
yarn add punctual-timer
# 或
pnpm add punctual-timer

使用高级扩展

高级扩展模块随主包一同安装，通过子路径导入即可使用：

// 使用基础定时器功能
import { PunctualTimer } from 'punctual-timer';

// 使用高级扩展功能（任务编排、批量管理、定时器池）
import { TaskScheduler, TimerManager, TimerPool } from 'punctual-timer/advanced';

快速开始

import { PunctualTimer } from 'punctual-timer';

// 创建定时器
const timer = new PunctualTimer({
  fn: () => {
    console.log('执行回调');
  },
  interval: 1000, // 1 秒
  autoVisibility: true, // 页面隐藏时自动降频
});

// 启动定时器
timer.start();

// 暂停
timer.pause();

// 恢复
timer.resume();

// 停止并清理
timer.clear();

API 文档

核心类

PunctualTimer

基础定时器类，提供高精度计时功能。构造函数支持两种调用方式。

方式一：使用配置对象（推荐）

const timer = new PunctualTimer({
  fn: () => console.log('tick'),
  interval: 1000,
  onError: (err) => console.error(err),
  autoVisibility: true,
  maxCompensation: 10,
});

方式二：使用参数列表（兼容旧版本）

const timer = new PunctualTimer(
  () => console.log('tick'),  // 回调函数
  1000,                       // 间隔时间（毫秒）
  (err) => console.error(err) // 错误处理（可选）
);

配置选项

| 参数 | 类型 | 默认值 | 描述 | |------|------|--------|------| | fn | () => void | — | 定时回调函数 | | interval | number | — | 执行间隔（毫秒），必须为大于 0 的有限数字 | | onError? | (err: Error) => void | — | 错误处理回调 | | autoVisibility? | boolean | true | 页面隐藏时自动暂停，显示时自动恢复。是否支持取决于当前适配器的实现：浏览器适配器支持，Node.js 和小程序适配器不支持 | | maxCompensation? | number | 10 | 最大补偿执行次数。用于处理长时间阻塞后的补偿执行，防止定时器雪崩效应。例如间隔 100ms 且阻塞 500ms，最多补偿执行 5 次 | | adapter? | TimerEnvironmentAdapter | — | 自定义环境适配器，覆盖自动检测的计时策略。适用于 uni-app App 端、React Native 等特殊运行环境 |

主要方法

| 方法 | 参数 | 返回值 | 说明 | |------|------|--------|------| | start() | — | void | 启动定时器。已销毁时抛出错误，运行中时显示警告，暂停中时提示使用 resume() | | pause(manual?) | manual?: boolean | void | 暂停定时器。manual 参数用于区分用户手动暂停（默认 true）与可见性自动暂停 | | resume(fromVisibility?) | fromVisibility?: boolean | void | 恢复定时器。fromVisibility 参数用于区分可见性自动恢复（默认 false）。用户手动暂停的定时器不会响应自动恢复 | | stop() | — | void | 停止定时器，重置所有状态，可再次调用 start() 重新启动 | | clear() | — | void | 销毁定时器，完全释放所有资源并移除页面可见性事件监听，实例不可再使用 | | setInterval(interval) | interval: number | void | 动态修改执行间隔，修改后自动保持之前的运行状态。参数无效时抛出错误 | | getStatus() | — | TimerStatus | 获取运行状态。返回 { isRunning, isPaused, isDestroyed, hasStarted } | | getEnvironment()（静态） | — | RuntimeEnv | 获取当前运行环境。返回 'browser' \| 'node' \| 'miniprogram' \| 'unknown' | | getAdapterName() | — | string | 获取当前实例使用的适配器名称 |

getStatus() 返回值

| 字段 | 类型 | 说明 | |------|------|------| | isRunning | boolean | 是否正在运行 | | isPaused | boolean | 是否已暂停 | | isDestroyed | boolean | 是否已销毁 | | hasStarted | boolean | 是否曾经启动过（用于区分未启动和已停止） |

环境适配器

PunctualTimer 使用适配器模式支持多环境运行。内置了三套适配器，分别对应浏览器、Node.js 和小程序环境。用户可通过 TimerEnvironmentAdapter 接口为任意运行环境提供自定义适配器。

适配器接口定义

interface TimerEnvironmentAdapter {
  /** 适配器名称标识 */
  readonly name: string;
  /** 获取高精度时间戳（毫秒） */
  now(): number;
  /** 调度下一帧回调 */
  scheduleTick(callback: () => void): TimerId;
  /** 取消已调度的帧 */
  cancelTick(id: TimerId): void;
  /** 是否支持页面可见性检测 */
  supportsVisibility(): boolean;
  /** 注册页面可见性变化监听（可选），返回取消监听函数 */
  onVisibilityChange?(handler: (hidden: boolean) => void): () => void;
}

内置适配器对照

| 适配器 | 名称 | 计时方案 | 调度方式 | 可见性支持 | |--------|------|----------|----------|------------| | 浏览器 | browser | performance.now() | requestAnimationFrame | ✅ visibilitychange 事件 | | Node.js | node | process.hrtime.bigint() | setImmediate | ❌ 不支持 | | 小程序/uni-app | miniprogram | Date.now() | setTimeout | ❌ 不支持 |

⚠️ 精度说明：小程序/uni-app 环境默认使用 Date.now() 进行计时，精度为毫秒级。如需更高精度的时间控制，可使用自定义适配器（见下方示例）。

全局注册自定义适配器

通过 PunctualTimer.registerAdapter() 注册全局适配器，适用于 uni-app App 端、React Native 等需要自定义计时和可见性行为的场景。

import { PunctualTimer } from 'punctual-timer';

// 为 uni-app App 端注册自定义适配器
PunctualTimer.registerAdapter('uni-app-app', {
  name: 'uni-app-app',
  now: () => performance.now(),
  scheduleTick: (cb) => setTimeout(cb, 0),
  cancelTick: (id) => clearTimeout(id),
  supportsVisibility: () => true,
  onVisibilityChange: (handler) => {
    // 使用 uni-app 的应用生命周期管理可见性
    const onHide = () => handler(true);
    const onShow = () => handler(false);
    // #ifdef APP-PLUS
    uni.onAppHide?.(onHide);
    uni.onAppShow?.(onShow);
    // #endif
    return () => {
      uni.offAppHide?.(onHide);
      uni.offAppShow?.(onShow);
    };
  },
});

// 在创建定时器时通过名称使用自定义适配器
const timer = new PunctualTimer({
  fn: () => { /* ... */ },
  interval: 1000,
  adapter: PunctualTimer.getRegisteredAdapter('uni-app-app'),
});

实例级别传入适配器

也可在创建定时器时直接传入适配器对象，仅影响当前实例：

const timer = new PunctualTimer({
  fn: () => { /* ... */ },
  interval: 1000,
  adapter: {
    name: 'custom',
    now: () => performance.now(),
    scheduleTick: (cb) => setTimeout(cb, 0),
    cancelTick: (id) => clearTimeout(id),
    supportsVisibility: () => false,
  },
});

高级扩展模块

高级扩展模块通过 punctual-timer/advanced 导入。

TaskScheduler

任务编排器，支持延迟执行、失败重试、循环限制、任务组合和依赖管理等复杂调度逻辑。

配置选项

| 参数 | 类型 | 默认值 | 描述 | |------|------|--------|------| | defaultMode | 'serial' \| 'parallel' | 'serial' | 默认执行模式 | | maxConcurrency | number | 10 | 最大并行任务数 | | onError | (taskId: string, error: Error) => void | — | 全局错误处理回调 | | onTaskComplete | (taskId: string) => void | — | 单个任务完成回调 | | onAllComplete | () => void | — | 所有任务完成回调 |

任务配置

| 参数 | 类型 | 默认值 | 描述 | |------|------|--------|------| | id | string | — | 任务唯一标识 | | execute | () => void \| Promise<void> | — | 任务执行函数，支持同步或异步 | | delay? | number | — | 延迟执行时间（毫秒） | | interval? | number | — | 执行间隔（毫秒），设置后将循环执行 | | maxIterations? | number | 1 | 最大循环次数，0 表示无限循环 | | retry? | RetryStrategy | — | 重试策略 | | timeout? | number | — | 任务超时时间（毫秒） | | dependencies? | string[] | — | 依赖的任务 ID 列表 | | priority? | number | 0 | 任务优先级，数值越大优先级越高 | | onComplete? | () => void | — | 任务完成回调 | | onError? | (error: Error) => void | — | 任务失败回调 | | onProgress? | (iteration: number, maxIterations: number) => void | — | 任务进度回调 |

重试策略（RetryStrategy）

| 参数 | 类型 | 描述 | |------|------|------| | maxRetries | number | 最大重试次数 | | retryInterval | number \| ((attempt: number) => number) | 重试间隔，支持固定值或递增函数 | | continueOnMaxRetry? | boolean | 达到最大重试次数后是否继续执行后续迭代（仅循环任务有效） |

主要方法

| 方法 | 参数 | 返回值 | 说明 | |------|------|--------|------| | addTask(config) | config: TaskConfig | this | 添加单个任务。ID 重复时抛出错误，返回 this 支持链式调用 | | addTasks(configs) | configs: TaskConfig[] | void | 批量添加任务 | | chain(...configs) | ...configs: TaskConfig[] | void | 创建任务链，后续任务自动依赖前一个任务 | | parallel(...configs) | ...configs: TaskConfig[] | void | 创建并行任务组，各任务无依赖关系 | | start(mode?) | mode?: ExecutionMode | Promise<void> | 启动调度，所有任务完成后 resolve。mode 可覆盖默认执行模式 | | pause() | — | void | 暂停所有正在运行的任务 | | resume() | — | void | 恢复所有已暂停的任务 | | stop() | — | void | 停止调度器，取消所有进行中的任务 | | cancelTask(taskId) | taskId: string | boolean | 取消特定任务，返回是否成功取消 | | getTaskStatus(taskId) | taskId: string | TaskStatus \| null | 获取指定任务的状态。状态值：'pending' \| 'running' \| 'paused' \| 'completed' \| 'failed' \| 'cancelled' | | getAllStatus() | — | Map<string, TaskStatus> | 获取所有任务的状态映射 | | getSchedulerStatus() | — | SchedulerStatus | 获取调度器运行状态。返回 { isRunning, isPaused, taskCount } | | cleanup() | — | void | 清理已完成、已取消和已失败的任务 | | destroy() | — | void | 销毁调度器，释放所有资源 |

TimerManager

定时器批量管理器，支持分组管理、标签过滤和批量操作。

主要方法

| 方法 | 参数 | 返回值 | 说明 | |------|------|--------|------| | register(id, timer, options?) | id: string, timer: PunctualTimer, options?: ManageOptions | this | 注册已有的定时器实例。ID 重复时抛出错误，返回 this 支持链式调用 | | create(id, options, manageOptions?) | id: string, options: TimerOptions, manageOptions?: ManageOptions | PunctualTimer | 创建并注册新定时器，返回创建的实例 | | get(id) | id: string | PunctualTimer \| undefined | 获取指定 ID 的定时器实例 | | has(id) | id: string | boolean | 检查定时器是否已注册 | | size（属性） | — | number | 获取注册的定时器总数（只读） | | startAll(filter?) | filter?: TimerFilter | void | 批量启动定时器 | | stopAll(filter?) | filter?: TimerFilter | void | 批量停止定时器 | | pauseAll(filter?) | filter?: TimerFilter | void | 批量暂停定时器 | | resumeAll(filter?) | filter?: TimerFilter | void | 批量恢复定时器 | | clearAll(filter?) | filter?: TimerFilter | void | 批量销毁定时器并从管理器中移除 | | setIntervalAll(interval, filter?) | interval: number, filter?: TimerFilter | void | 批量修改定时器执行间隔 | | getStatusAll(filter?) | filter?: TimerFilter | Map<string, TimerStatus> | 批量获取定时器状态 | | getRunningCount(filter?) | filter?: TimerFilter | number | 获取正在运行的定时器数量 | | getAllIds(filter?) | filter?: TimerFilter | string[] | 获取符合条件的定时器 ID 列表 | | getGroupIds(group) | group: string | string[] | 获取指定分组的所有定时器 ID | | getGroupNames() | — | string[] | 获取所有分组名称 | | unregister(id) | id: string | PunctualTimer \| undefined | 从管理器中移除定时器（不销毁实例）。返回被移除的实例，不存在时返回 undefined | | getStats() | — | ManagerStats | 获取管理器统计信息 | | destroy() | — | void | 销毁管理器，清除并释放所有定时器 |

注册选项（ManageOptions）

| 参数 | 类型 | 描述 | |------|------|------| | group? | string | 分组名称 | | tags? | string[] | 标签列表 | | metadata? | Record<string, unknown> | 自定义元数据 |

过滤条件（TimerFilter）

| 参数 | 类型 | 描述 | |------|------|------| | ids? | string[] | 定时器 ID 列表 | | group? | string | 分组名称 | | tags? | string[] | 标签列表 | | status? | 'running' \| 'paused' \| 'stopped' | 运行状态 |

getStats() 返回值

| 字段 | 类型 | 说明 | |------|------|------| | total | number | 总定时器数量 | | running | number | 运行中的数量 | | paused | number | 已暂停的数量 | | stopped | number | 已停止的数量 | | groups | Record<string, number> | 各分组的定时器数量 |

TimerPool

定时器池，支持池化管理大量定时器实例，具备容量控制、自动清理和统计监控能力。

配置选项

| 参数 | 类型 | 默认值 | 描述 | |------|------|--------|------| | maxSize | number | 10000 | 最大定时器数量 | | idleTimeout | number | 60000 | 空闲超时时间（毫秒） | | cleanupInterval | number | 30000 | 清理检查间隔（毫秒） | | defaultTimerOptions | Partial<Omit<TimerOptions, 'fn' \| 'interval'>> | — | 定时器默认选项（fn 和 interval 需在 acquire 时提供） |

主要方法

| 方法 | 参数 | 返回值 | 说明 | |------|------|--------|------| | acquire(options) | options: TimerOptions | { id: string; timer: PunctualTimer } \| null | 从池中获取一个新定时器。池已满时返回 null，已销毁时抛出错误 | | release(id) | id: string | boolean | 释放定时器回池（销毁实例），返回是否释放成功 | | acquireBatch(count, factory) | count: number, factory: (index) => TimerOptions | Array<{ id; timer }> | 批量获取定时器，返回成功获取的列表（可能少于请求数量） | | releaseBatch(ids) | ids: string[] | number | 批量释放定时器，返回成功释放的数量 | | has(id) | id: string | boolean | 检查定时器是否在池中 | | getTimer(id) | id: string | PunctualTimer \| undefined | 获取池中的定时器实例 | | getStats() | — | PoolStats | 获取池统计信息（只读） | | getStatus() | — | PoolStatus | 获取池当前状态 | | destroy() | — | void | 销毁定时器池，释放所有资源 |

getStats() 返回值

| 字段 | 类型 | 说明 | |------|------|------| | totalCreated | number | 累计创建的定时器数量 | | activeTimers | number | 当前活跃定时器数量 | | peakUsage | number | 峰值使用量 | | totalAcquired | number | 累计获取次数 | | totalReleased | number | 累计释放次数 |

getStatus() 返回值

| 字段 | 类型 | 说明 | |------|------|------| | size | number | 当前池大小 | | available | number | 可用容量 | | maxSize | number | 最大容量 | | utilizationRate | number | 使用率（0-1） |

类型导出

// 核心类型
import type { TimerOptions, TimerStatus } from 'punctual-timer';

// 高级类型
import type {
  TaskStatus,
  ExecutionMode,
  RetryStrategy,
  TaskConfig,
  SchedulerConfig,
  BatchResult,
  PoolConfig,
  PoolStats,
  ManagedTimer,
  TimerFilter,
} from 'punctual-timer/advanced';

使用示例

基础定时器

import { PunctualTimer } from 'punctual-timer';

// 创建定时器
const timer = new PunctualTimer({
  fn: () => console.log('tick'),
  interval: 1000,
  autoVisibility: true,
});

timer.start();

// 动态修改间隔
timer.setInterval(2000);

// 获取状态
console.log(timer.getStatus());
// { isRunning: true, isPaused: false, isDestroyed: false, hasStarted: true }

任务编排（TaskScheduler）

import { TaskScheduler, createDelayedTask, createRetryableTask, createLoopTask } from 'punctual-timer/advanced';

const scheduler = new TaskScheduler({
  defaultMode: 'serial',
  maxConcurrency: 5,
  onError: (id, err) => console.error(`任务 ${id} 失败:`, err),
});

// 添加延迟任务
scheduler.addTask({
  id: 'delayed-task',
  execute: () => console.log('延迟执行'),
  delay: 2000,
});

// 添加重试任务
scheduler.addTask({
  id: 'retry-task',
  execute: async () => {
    const response = await fetch('/api/data');
    return response.json();
  },
  retry: {
    maxRetries: 3,
    retryInterval: (attempt) => attempt * 1000,
  },
  timeout: 5000,
});

// 创建任务链（自动建立依赖）
scheduler.chain(
  { id: 'init', execute: () => console.log('初始化') },
  { id: 'load', execute: () => fetch('/api/load') },
  { id: 'process', execute: (data) => console.log('处理:', data) },
  { id: 'cleanup', execute: () => console.log('清理') }
);

// 创建并行任务组
scheduler.parallel(
  { id: 'task1', execute: () => console.log('并行任务 1') },
  { id: 'task2', execute: () => console.log('并行任务 2') }
);

// 启动调度器
await scheduler.start();

// 便捷工厂函数
const delayed = createDelayedTask(() => console.log('延迟'), 5000, { id: 'delayed' });
const retryable = createRetryableTask(async () => { /* ... */ }, 3, 1000, { id: 'retry' });
const loop = createLoopTask(() => console.log('循环'), 1000, 10, { id: 'loop' });

批量管理（TimerManager）

import { TimerManager } from 'punctual-timer/advanced';

const manager = new TimerManager();

// 创建并注册定时器
manager.create('timer1', {
  fn: () => console.log('Timer 1'),
  interval: 1000,
}, { group: 'group-a', tags: ['important'] });

manager.create('timer2', {
  fn: () => console.log('Timer 2'),
  interval: 2000,
}, { group: 'group-a', tags: ['background'] });

// 批量操作
manager.startAll({ group: 'group-a' });
manager.pauseAll();
manager.resumeAll({ group: 'group-a' });
manager.setIntervalAll(500, { group: 'group-a' });
manager.clearAll({ group: 'group-a' });

// 获取统计信息
console.log(manager.getStats());
// { total: 2, running: 1, paused: 1, stopped: 0, groups: { 'group-a': 2 } }

定时器池（TimerPool）

import { TimerPool } from 'punctual-timer/advanced';

const pool = new TimerPool({
  maxSize: 10000,
  idleTimeout: 60000,
});

// 获取定时器
const { id, timer } = pool.acquire({
  fn: () => processItem(),
  interval: 100,
})!;
timer.start();

// 批量获取
const timers = pool.acquireBatch(100, (index) => ({
  fn: () => processItem(index),
  interval: 100 + (index % 10) * 10,
}));
timers.forEach(({ timer }) => timer.start());

// 释放定时器
pool.release(id);
pool.releaseBatch(timers.map(t => t.id));

// 获取统计信息
console.log(pool.getStats());
// { totalCreated: 101, activeTimers: 0, peakUsage: 100, totalAcquired: 101, totalReleased: 101 }

实战场景

uni-app 中使用

import { PunctualTimer } from 'punctual-timer';

export default {
  data() {
    return {
      timer: null as PunctualTimer | null,
      count: 0
    };
  },
  mounted() {
    this.timer = new PunctualTimer({
      fn: () => {
        this.count++;
        console.log('定时器执行次数:', this.count);
        if (this.count % 10 === 0) {
          uni.showToast({ title: `已执行${this.count}次`, icon: 'none' });
        }
      },
      interval: 1000,
      autoVisibility: false, // uni-app App 端不支持页面可见性 API
    });
    this.timer.start();
  },
  beforeDestroy() {
    this.timer?.clear();
  }
};

数据同步任务

import { TaskScheduler } from 'punctual-timer/advanced';

const scheduler = new TaskScheduler({
  defaultMode: 'serial',
  onError: (id, err) => console.error(`${id} 失败:`, err),
});

scheduler.chain(
  { id: 'prepare', execute: () => console.log('准备同步数据...') },
  { id: 'fetch-local', execute: async () => { /* ... */ }, retry: { maxRetries: 3, retryInterval: 2000 } },
  { id: 'fetch-remote', execute: async () => { /* ... */ }, retry: { maxRetries: 5, retryInterval: 3000 } },
  { id: 'merge-data', execute: () => console.log('合并数据...') },
  { id: 'upload', execute: async () => { /* ... */ }, timeout: 10000 },
  { id: 'cleanup', execute: () => console.log('清理临时数据') }
);

await scheduler.start();

监控系统定时器管理

import { TimerManager } from 'punctual-timer/advanced';

const manager = new TimerManager();

manager.create('cpu-monitor', { fn: () => monitorCPU(), interval: 5000 }, { group: 'monitors', tags: ['system', 'critical'] });
manager.create('memory-monitor', { fn: () => monitorMemory(), interval: 5000 }, { group: 'monitors', tags: ['system'] });
manager.create('network-monitor', { fn: () => monitorNetwork(), interval: 10000 }, { group: 'monitors', tags: ['network'] });

manager.startAll({ group: 'monitors' });

// 系统维护时暂停
manager.pauseAll();
// ... 执行维护操作 ...
manager.resumeAll();

高并发数据处理

import { TimerPool } from 'punctual-timer/advanced';

const pool = new TimerPool({ maxSize: 5000, idleTimeout: 120000 });

const BATCH_SIZE = 500;
const TOTAL_ITEMS = 10000;

for (let i = 0; i < TOTAL_ITEMS; i += BATCH_SIZE) {
  const timers = pool.acquireBatch(BATCH_SIZE, (idx) => ({
    fn: () => processData(items[i + idx]),
    interval: 100 + (idx % 20) * 5,
  }));
  timers.forEach(({ timer }) => timer.start());
  setTimeout(() => pool.releaseBatch(timers.map(t => t.id)), 5000);
}

uni-app 提升时间精度

import { PunctualTimer } from 'punctual-timer';

// 创建高精度适配器
PunctualTimer.registerAdapter('high-precision', {
  name: 'high-precision',
  now: () => performance.now(),
  scheduleTick: (cb) => setTimeout(cb, 0),
  cancelTick: (id) => clearTimeout(id),
  supportsVisibility: () => false,
});

const timer = new PunctualTimer({
  fn: () => console.log('高精度执行'),
  interval: 100,
  adapter: PunctualTimer.getRegisteredAdapter('high-precision'),
});

timer.start();

最佳实践

1. 任务编排

• 合理设置超时：为异步任务设置合适的 timeout，避免任务卡死
• 使用重试策略：对网络请求等可能失败的任务配置 retry
• 任务链 vs 并行：有依赖关系的任务使用 chain()，独立任务使用 parallel()
• 优先级控制：通过 priority 字段控制任务执行顺序

2. 批量管理

• 分组管理：使用 group 将相关定时器归类，便于批量操作
• 标签标记：使用 tags 标记定时器特性（如 critical、background）
• 定期清理：不再使用的定时器及时调用 clearAll() 释放

3. 定时器池

• 合理设置上限：根据系统资源设置合适的 maxSize
• 监控使用率：定期调用 getStats() 监控池使用情况
• 及时释放：使用完毕的定时器立即调用 release() 或 releaseBatch()
• 利用自动清理：配置合适的 idleTimeout 让池自动回收空闲定时器

4. 性能优化

• 避免过多定时器：单个页面建议不超过 1000 个活跃定时器
• 使用定时器池：需要大量定时器时优先使用 TimerPool
• 合理设置间隔：避免过短的 interval（如 < 10ms）造成性能压力
• 及时清理：组件卸载时调用 destroy() 彻底释放资源

注意事项

环境兼容性

| 环境 | 支持情况 | |------|----------| | 浏览器 | Chrome、Firefox、Safari、Edge 等现代浏览器 | | Node.js | 14+ | | 小程序 | 微信、支付宝、百度、字节、QQ | | uni-app App 端 | iOS/Android（需要使用自定义适配器以支持应用生命周期可见性） | | uni-app H5 端 | ✅ 完整支持 | | uni-app 小程序端 | ✅ 完整支持 |

内存管理

• 使用完毕后务必调用 clear() 或 destroy() 释放资源
• 长时间运行的应用建议定期检查定时器状态
• 避免在循环中无限制创建定时器而不释放

异步任务处理

• execute 函数可以是异步的（返回 Promise）
• 异步任务失败会触发 onError 回调
• 配置 timeout 可以防止异步任务无限期挂起