Struct BatchHandle 

pub struct BatchHandle { /* private fields */ }

Batch timer handle for managing batch-scheduled timers (without completion receivers)

Note: This type does not implement Clone to prevent duplicate cancellation of the same batch of timers. Use into_iter() or into_handles() to access individual timer handles.

批量定时器句柄，用于管理批量调度的定时器（不含完成通知接收器）

注意：此类型未实现 Clone 以防止重复取消同一批定时器。使用 into_iter() 或 into_handles() 访问单个定时器句柄。

Implementations

impl BatchHandle

pub fn cancel_all(self) -> usize

Cancel all timers in batch

Returns

Number of successfully cancelled tasks

批量取消所有定时器

返回值

成功取消的任务数量

Examples (示例)

let timer = TimerWheel::with_defaults();
let tasks: Vec<TimerTask> = (0..10)
    .map(|_| TimerTask::new_oneshot(Duration::from_secs(1), None))
    .collect();
let batch = timer.register_batch(tasks);
 
let cancelled = batch.cancel_all();
println!("Canceled {} timers", cancelled);

pub fn into_handles(self) -> Vec<TimerHandle>

Convert batch handle to Vec of individual timer handles

Consumes BatchHandle and creates independent TimerHandle for each task

将批量句柄转换为单个定时器句柄的 Vec

消费 BatchHandle 并为每个任务创建独立的 TimerHandle

Examples (示例)

let timer = TimerWheel::with_defaults();
let tasks: Vec<TimerTask> = (0..3)
    .map(|_| TimerTask::new_oneshot(Duration::from_secs(1), None))
    .collect();
let batch = timer.register_batch(tasks);
 
// Convert to individual handles
// 转换为单个句柄
let handles = batch.into_handles();
for handle in handles {
    // Can operate each handle individually
    // 可以单独操作每个句柄
}

pub fn len(&self) -> usize

Get the number of batch tasks

获取批量任务数量

pub fn is_empty(&self) -> bool

Check if batch tasks are empty

检查批量任务是否为空

pub fn task_ids(&self) -> &[TaskId]

Get reference to all task IDs

获取所有任务 ID 的引用

pub fn postpone_all(self, new_delay: Duration) -> usize

Batch postpone timers (keep original callbacks)

Parameters

• new_delay: New delay duration applied to all timers

Returns

Number of successfully postponed tasks

批量推迟定时器 (保持原始回调)

参数

• new_delay: 应用于所有定时器的新延迟时间

返回值

成功推迟的任务数量

Examples (示例)

let timer = TimerWheel::with_defaults();
let tasks: Vec<_> = (0..10)
    .map(|_| TimerTask::new_oneshot(Duration::from_secs(1), None))
    .collect();
let batch_with_completion = timer.register_batch(tasks);
let (rxs, batch) = batch_with_completion.into_parts();
 
// Postpone all timers to 5 seconds
let postponed = batch.postpone_all(Duration::from_secs(5));
println!("Postponed {} timers", postponed);

pub fn postpone_each(self, delays: Vec<Duration>) -> usize

Batch postpone timers with individual delays (keep original callbacks)

Parameters

• delays: List of new delay durations for each timer (must match the number of tasks)

Returns

Number of successfully postponed tasks

批量推迟定时器，每个定时器使用不同延迟 (保持原始回调)

参数

• delays: 每个定时器的新延迟时间列表（必须与任务数量匹配）

返回值

成功推迟的任务数量

Examples (示例)

let timer = TimerWheel::with_defaults();
let delays: Vec<Duration> = (0..3)
    .map(|_| Duration::from_secs(1))
    .collect();
let tasks: Vec<_> = delays.into_iter().map(|d| TimerTask::new_oneshot(d, None)).collect();
let batch_with_completion = timer.register_batch(tasks);
let (rxs, batch) = batch_with_completion.into_parts();
 
// Postpone each timer with different delays
let new_delays = vec![
    Duration::from_secs(2),
    Duration::from_secs(3),
    Duration::from_secs(4),
];
let postponed = batch.postpone_each(new_delays);
println!("Postponed {} timers", postponed);

pub fn postpone_each_with_callbacks( self, updates: Vec<(Duration, Option<CallbackWrapper>)>, ) -> usize

Batch postpone timers with individual delays and callbacks

Parameters

• updates: List of tuples of (new delay, new callback) for each timer

Returns

Number of successfully postponed tasks

批量推迟定时器，每个定时器使用不同延迟和回调

参数

• updates: 每个定时器的 (新延迟, 新回调) 元组列表

返回值

成功推迟的任务数量

Examples (示例)

let timer = TimerWheel::with_defaults();
let delays: Vec<Duration> = (0..3)
    .map(|_| Duration::from_secs(1))
    .collect();
let tasks: Vec<_> = delays.into_iter().map(|d| TimerTask::new_oneshot(d, None)).collect();
let batch_with_completion = timer.register_batch(tasks);
let (rxs, batch) = batch_with_completion.into_parts();
 
// Postpone each timer with different delays and callbacks
let updates = vec![
    (Duration::from_secs(2), Some(CallbackWrapper::new(|| async {}))),
    (Duration::from_secs(3), None),
    (Duration::from_secs(4), Some(CallbackWrapper::new(|| async {}))),
];
let postponed = batch.postpone_each_with_callbacks(updates);
println!("Postponed {} timers", postponed);