Skip to content

Commit 273ba6b

Browse files
tickbhtickbh
committed
timer
1 parent 90d3c19 commit 273ba6b

File tree

6 files changed

+161
-57
lines changed

6 files changed

+161
-57
lines changed

‎Cargo.lock

+11-11
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎src/lib.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ pub mod buf;
1313
pub use cache::{LruCache, LruKCache, LfuCache, ArcCache, Slab, Reinit};
1414
pub use tree::RBTree;
1515
pub use map::{BitMap, RoaringBitMap};
16-
pub use timer::{TimerWheel, Timer, TimerRBTree};
16+
pub use timer::{TimerWheel, Timer, TimerRBTree, StampTimer};
1717
pub use arr::{CircularBuffer, FixedVec};
1818
pub use util::*;
1919

‎src/timer/mod.rs

+2
Original file line numberDiff line numberDiff line change
@@ -36,6 +36,8 @@ impl_primitive_timer!(usize);
3636

3737
mod timer_rbtree;
3838
mod timer_wheel;
39+
mod stamp_timer;
3940

4041
pub use timer_wheel::TimerWheel;
4142
pub use timer_rbtree::TimerRBTree;
43+
pub use stamp_timer::StampTimer;

‎src/timer/stamp_timer.rs

+43
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,43 @@
1+
use std::time::{Duration, SystemTime, UNIX_EPOCH};
2+
3+
use super::Timer;
4+
5+
pub struct StampTimer<T> {
6+
duration: Duration,
7+
is_sec: bool,
8+
pub val: T,
9+
}
10+
11+
impl<T> StampTimer<T> {
12+
pub fn new(val: T, duration: Duration) -> Self {
13+
let is_sec = duration.as_secs() as u128 * 1000 == duration.as_millis();
14+
Self { val, duration, is_sec }
15+
}
16+
17+
pub fn new_second(val: T, interval: u64) -> Self {
18+
Self {
19+
val,
20+
duration: Duration::from_secs(interval),
21+
is_sec: true,
22+
}
23+
}
24+
25+
pub fn new_millis(val: T, interval: u64) -> Self {
26+
Self {
27+
val,
28+
duration: Duration::from_millis(interval),
29+
is_sec: false,
30+
}
31+
}
32+
}
33+
34+
impl<T> Timer for StampTimer<T> {
35+
fn when(&self) -> u64 {
36+
let when = SystemTime::now() + self.duration;
37+
if self.is_sec {
38+
when.duration_since(UNIX_EPOCH).unwrap().as_secs()
39+
} else {
40+
when.duration_since(UNIX_EPOCH).unwrap().as_millis() as u64
41+
}
42+
}
43+
}

‎src/timer/timer_rbtree.rs

+55-21
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@ use crate::HashMap;
22

33
use crate::RBTree;
44
use std::cmp::Ordering;
5+
use std::u64;
56
use std::vec;
67

78
use super::Timer;
@@ -52,12 +53,12 @@ impl PartialOrd for TreeKey {
5253
/// timer.add_timer(150);
5354
/// assert_eq!(timer.tick_first(), Some(1));
5455
/// let val = timer.update_deltatime(30).unwrap();
55-
/// assert_eq!(val, vec![1, 30]);
56+
/// assert_eq!(val.iter().map(|(_, v)| *v).collect::<Vec<usize>>(), vec![1, 30]);
5657
/// timer.add_timer(2);
5758
/// let val = timer.update_deltatime(119).unwrap();
58-
/// assert_eq!(val, vec![2, 149]);
59+
/// assert_eq!(val.iter().map(|(_, v)| *v).collect::<Vec<usize>>(), vec![2, 149]);
5960
/// let val = timer.update_deltatime(1).unwrap();
60-
/// assert_eq!(val, vec![150]);
61+
/// assert_eq!(val.iter().map(|(_, v)| *v).collect::<Vec<usize>>(), vec![150]);
6162
/// assert!(timer.is_empty());
6263
/// }
6364
/// ```
@@ -71,6 +72,8 @@ pub struct TimerRBTree<T: Timer> {
7172

7273
/// id记录
7374
next_timer_id: u64,
75+
/// max id
76+
max_timer_id: u64,
7477
}
7578

7679
impl<T: Timer> TimerRBTree<T> {
@@ -79,7 +82,8 @@ impl<T: Timer> TimerRBTree<T> {
7982
tree: RBTree::new(),
8083
map: HashMap::new(),
8184
cur_step: 0,
82-
next_timer_id: 0,
85+
next_timer_id: 1,
86+
max_timer_id: u64::MAX,
8387
}
8488
}
8589

@@ -126,7 +130,32 @@ impl<T: Timer> TimerRBTree<T> {
126130
self.tree.clear();
127131
self.map.clear();
128132
self.cur_step = 0;
129-
self.next_timer_id = 0;
133+
self.next_timer_id = 1;
134+
}
135+
136+
pub fn get_max_timerid(&self) -> u64 {
137+
self.max_timer_id
138+
}
139+
140+
pub fn set_max_timerid(&mut self, max: u64) {
141+
self.max_timer_id = max;
142+
}
143+
144+
fn get_next_timerid(&mut self) -> u64 {
145+
let mut timer_id;
146+
loop {
147+
timer_id = self.next_timer_id;
148+
if self.next_timer_id >= self.max_timer_id {
149+
self.next_timer_id = 1;
150+
} else {
151+
self.next_timer_id = self.next_timer_id + 1;
152+
}
153+
154+
if !self.map.contains_key(&timer_id) {
155+
break;
156+
}
157+
}
158+
timer_id
130159
}
131160

132161
/// 添加定时器元素
@@ -140,14 +169,16 @@ impl<T: Timer> TimerRBTree<T> {
140169
/// assert_eq!(timer.len(), 1);
141170
/// }
142171
pub fn add_timer(&mut self, val: T) -> u64 {
143-
let timer_id = self.next_timer_id;
144-
self.next_timer_id = self.next_timer_id.wrapping_add(1);
172+
let timer_id = self.get_next_timerid();
173+
self._add_timer(timer_id, val);
174+
timer_id
175+
}
176+
177+
fn _add_timer(&mut self, timer_id: u64, val: T) {
145178
let when = val.when();
146179
self.tree.insert(TreeKey(when, timer_id), val);
147180
self.map.insert(timer_id, when);
148-
timer_id
149181
}
150-
151182
/// 删除指定的定时器，时间复杂度为O(logn)，
152183
///
153184
/// # Examples
@@ -200,7 +231,7 @@ impl<T: Timer> TimerRBTree<T> {
200231
/// let t = timer.add_timer(30);
201232
/// *timer.get_mut_timer(&t).unwrap() = 33;
202233
/// let val = timer.update_deltatime(30).unwrap();
203-
/// assert_eq!(val, vec![33]);
234+
/// assert_eq!(val.iter().map(|(_, v)| *v).collect::<Vec<usize>>(), vec![33]);
204235
/// }
205236
pub fn get_mut_timer(&mut self, timer_id: &u64) -> Option<&mut T> {
206237
if let Some(when) = self.map.get(timer_id) {
@@ -237,17 +268,17 @@ impl<T: Timer> TimerRBTree<T> {
237268
/// let mut timer = TimerRBTree::new();
238269
/// timer.add_timer(30);
239270
/// let val = timer.update_deltatime(30).unwrap();
240-
/// assert_eq!(val, vec![30]);
271+
/// assert_eq!(val.iter().map(|(_, v)| *v).collect::<Vec<usize>>(), vec![30]);
241272
/// }
242-
pub fn update_now(&mut self, now: u64) -> Option<Vec<T>> {
273+
pub fn update_now(&mut self, now: u64) -> Option<Vec<(u64, T)>> {
243274
self.cur_step = now;
244275
let mut result = vec![];
245276
loop {
246277
if let Some(val) = self.tick_first() {
247278
if self.cur_step < val {
248279
break;
249280
}
250-
result.push(self.tree.pop_first().map(|(_, e)| e).unwrap());
281+
result.push(self.tree.pop_first().map(|(k, e)| (k.1, e)).unwrap());
251282
} else {
252283
break;
253284
}
@@ -264,9 +295,9 @@ impl<T: Timer> TimerRBTree<T> {
264295
/// let mut timer = TimerRBTree::new();
265296
/// timer.add_timer(30);
266297
/// let val = timer.update_deltatime(30).unwrap();
267-
/// assert_eq!(val, vec![30]);
298+
/// assert_eq!(val, vec![(1, 30)]);
268299
/// }
269-
pub fn update_deltatime(&mut self, delta: u64) -> Option<Vec<T>> {
300+
pub fn update_deltatime(&mut self, delta: u64) -> Option<Vec<(u64, T)>> {
270301
self.update_now(self.cur_step.wrapping_add(delta))
271302
}
272303

@@ -280,32 +311,35 @@ impl<T: Timer> TimerRBTree<T> {
280311
/// let mut timer = TimerRBTree::new();
281312
/// timer.add_timer(30);
282313
/// let mut idx = 0;
283-
/// timer.update_deltatime_with_callback(30, &mut |_, v| {
314+
/// let mut timer_id = 0;
315+
/// timer.update_deltatime_with_callback(30, &mut |_, id, v| {
316+
/// timer_id = id;
284317
/// idx = v;
285318
/// None
286319
/// });
320+
/// assert_eq!(timer_id, 1);
287321
/// assert_eq!(idx, 30);
288322
/// }
289323
pub fn update_deltatime_with_callback<F>(&mut self, delta: u64, f: &mut F)
290324
where
291-
F: FnMut(&mut Self, T) -> Option<T>,
325+
F: FnMut(&mut Self, u64, T) -> Option<(u64, T)>,
292326
{
293327
self.update_now_with_callback(self.cur_step.wrapping_add(delta), f)
294328
}
295329

296330
pub fn update_now_with_callback<F>(&mut self, now: u64, f: &mut F)
297331
where
298-
F: FnMut(&mut Self, T) -> Option<T>,
332+
F: FnMut(&mut Self, u64, T) -> Option<(u64, T)>,
299333
{
300334
if let Some(result) = self.update_now(now) {
301335
let mut collect_result = vec![];
302336
for r in result.into_iter() {
303-
if let Some(v) = (*f)(self, r) {
337+
if let Some(v) = (*f)(self, r.0, r.1) {
304338
collect_result.push(v);
305339
}
306340
}
307-
for v in collect_result.drain(..) {
308-
self.add_timer(v);
341+
for (timer_id, v) in collect_result.drain(..) {
342+
self._add_timer(timer_id, v);
309343
}
310344
}
311345
}

0 commit comments

Comments
 (0)