Struct BatchHandle 

pub struct BatchHandle { /* private fields */ }

批量定时器句柄，用于管理批量调度的定时器

通过共享 Wheel 引用减少内存开销，同时提供批量操作和迭代器访问能力。

注意：此类型不实现 Clone，以防止重复取消同一批定时器。 如需访问单个定时器句柄，请使用 into_iter() 或 into_handles() 进行转换。

Implementations

impl BatchHandle

pub fn cancel_all(self) -> usize

批量取消所有定时器

返回

成功取消的任务数量

示例

let timer = TimerWheel::with_defaults();
let delays: Vec<Duration> = (0..10)
    .map(|_| Duration::from_secs(1))
    .collect();
let tasks = TimerWheel::create_batch(delays);
let batch = timer.register_batch(tasks);
 
let cancelled = batch.cancel_all();
println!("取消了 {} 个定时器", cancelled);

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

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

消耗 BatchHandle，为每个任务创建独立的 TimerHandle。

示例

let timer = TimerWheel::with_defaults();
let delays: Vec<Duration> = (0..3)
    .map(|_| Duration::from_secs(1))
    .collect();
let tasks = TimerWheel::create_batch(delays);
let batch = timer.register_batch(tasks);
 
// 转换为独立的句柄
let handles = batch.into_handles();
for handle in handles {
    // 可以单独操作每个句柄
}

pub fn len(&self) -> usize

获取批量任务的数量

pub fn is_empty(&self) -> bool

检查批量任务是否为空

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

获取所有任务 ID 的引用

pub fn completion_receivers( &mut self, ) -> &mut Vec<Receiver<TaskCompletionReason>>

获取所有完成通知接收器的引用

返回

所有任务的完成通知接收器列表引用

pub fn into_completion_receivers(self) -> Vec<Receiver<TaskCompletionReason>>

消耗句柄，返回所有完成通知接收器

返回

所有任务的完成通知接收器列表

示例

let timer = TimerWheel::with_defaults();
let delays: Vec<Duration> = (0..3)
    .map(|_| Duration::from_secs(1))
    .collect();
let tasks = TimerWheel::create_batch(delays);
let batch = timer.register_batch(tasks);
 
// 获取所有完成通知接收器
let receivers = batch.into_completion_receivers();
for rx in receivers {
    tokio::spawn(async move {
        if rx.await.is_ok() {
            println!("A timer completed!");
        }
    });
}

Trait Implementations

impl IntoIterator for BatchHandle

实现 IntoIterator，允许直接迭代 BatchHandle

示例

let timer = TimerWheel::with_defaults();
let delays: Vec<Duration> = (0..3)
    .map(|_| Duration::from_secs(1))
    .collect();
let tasks = TimerWheel::create_batch(delays);
let batch = timer.register_batch(tasks);
 
// 直接迭代，每个元素都是独立的 TimerHandle
for handle in batch {
    // 可以单独操作每个句柄
}

type Item = TimerHandle

The type of the elements being iterated over.

type IntoIter = BatchHandleIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.