我正在和Tokio一起做一些UDP工作。
我想记录我的UDP探测将来解决所花费的时间。我想出了以下函数time_future()
,用于包装未来并提供结果和持续时间。该功能似乎非常幼稚,我认为Rust可以更清晰地表达该概念。
我的工作代码(Playground):
extern crate futures; // 0.1.25
extern crate tokio; // 0.1.11
use std::time::{Duration, Instant};
use futures::future::{lazy, ok};
use futures::Future;
use tokio::runtime::current_thread::Runtime;
use tokio::timer::Delay;
struct TimedFutureResult<T, E> {
elapsed: Duration,
result: Result<T, E>,
}
impl<T, E> TimedFutureResult<T, E> {
pub fn elapsed_ms(&self) -> i64 {
return (self.elapsed.as_secs() * 1000 + (self.elapsed.subsec_nanos() / 1000000) as u64)
as i64;
}
}
fn time_future<F: Future>(f: F) -> impl Future<Item = TimedFutureResult<F::Item, F::Error>> {
lazy(|| {
let start = Instant::now();
f.then(move |result| {
ok::<TimedFutureResult<F::Item, F::Error>, ()>(TimedFutureResult {
elapsed: start.elapsed(),
result: result,
})
})
})
}
fn main() {
let when = Instant::now() + Duration::from_millis(100);
let f = time_future(Delay::new(when)).then(|r| match r {
Ok(r) => {
println!("resolved in {}ms", r.elapsed_ms());
r.result
}
_ => unreachable!(),
});
let mut runtime = Runtime::new().unwrap();
runtime.block_on(f).unwrap();
}
我该如何改善它并使它更加惯用?我可以以某种方式使该界面与inspect()
或then()
类似地工作吗?
Delay::new(when)
.timed(|res, elapsed| println!("{}ms!", elapsed))
.and_then(...);
我尝试创建一个Timed
特质并为Future
实现它,但是我对自己的工作方式完全没有信心。这些类型真的让我感到困惑。
我至少要吠叫正确的树吗?
答案 0 :(得分:1)
编写未来的行为很容易,添加可链接方法与How can I add new methods to Iterator?中所示的技术相同。
唯一真正棘手的方面是确定时间何时开始-是在创建还是在第一次投票时?
我选择在首次轮询时使用,因为这似乎更有用:
extern crate futures; // 0.1.25
extern crate tokio; // 0.1.11
use std::time::{Duration, Instant};
use futures::{try_ready, Async, Future, Poll};
use tokio::{runtime::current_thread::Runtime, timer::Delay};
struct Timed<Fut, F>
where
Fut: Future,
F: FnMut(&Fut::Item, Duration),
{
inner: Fut,
f: F,
start: Option<Instant>,
}
impl<Fut, F> Future for Timed<Fut, F>
where
Fut: Future,
F: FnMut(&Fut::Item, Duration),
{
type Item = Fut::Item;
type Error = Fut::Error;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
let start = self.start.get_or_insert_with(Instant::now);
let v = try_ready!(self.inner.poll());
let elapsed = start.elapsed();
(self.f)(&v, elapsed);
Ok(Async::Ready(v))
}
}
trait TimedExt: Sized + Future {
fn timed<F>(self, f: F) -> Timed<Self, F>
where
F: FnMut(&Self::Item, Duration),
{
Timed {
inner: self,
f,
start: None,
}
}
}
impl<F: Future> TimedExt for F {}
fn main() {
let when = Instant::now() + Duration::from_millis(100);
let f = Delay::new(when).timed(|res, elapsed| println!("{:?} elapsed, got {:?}", elapsed, res));
let mut runtime = Runtime::new().unwrap();
runtime.block_on(f).unwrap();
}
答案 1 :(得分:1)
Shepmaster的回答很好。但是,他们使用的futures
版本过时并且与stdlib期货不兼容。这是我重写为使用stdlib期货。
use pin_project::pin_project;
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
use std::time::{Duration, Instant};
use tokio::time; // 0.2
/// A wrapper around a Future which adds timing data.
#[pin_project]
struct Timed<Fut, F>
where
Fut: Future,
F: FnMut(&Fut::Output, Duration),
{
#[pin]
inner: Fut,
f: F,
start: Option<Instant>,
}
impl<Fut, F> Future for Timed<Fut, F>
where
Fut: Future,
F: FnMut(&Fut::Output, Duration),
{
type Output = Fut::Output;
fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
let this = self.project();
let start = this.start.get_or_insert_with(Instant::now);
match this.inner.poll(cx) {
// If the inner future is still pending, this wrapper is still pending.
Poll::Pending => Poll::Pending,
// If the inner future is done, measure the elapsed time and finish this wrapper future.
Poll::Ready(v) => {
let elapsed = start.elapsed();
(this.f)(&v, elapsed);
Poll::Ready(v)
}
}
}
}
trait TimedExt: Sized + Future {
fn timed<F>(self, f: F) -> Timed<Self, F>
where
F: FnMut(&Self::Output, Duration),
{
Timed {
inner: self,
f,
start: None,
}
}
}
// All futures can use the `.timed` method defined above
impl<F: Future> TimedExt for F {}
#[tokio::main]
async fn main() {
let when = Instant::now() + Duration::from_millis(100);
let fut = time::delay_until(when.into())
.timed(|res, elapsed| println!("{:?} elapsed, got {:?}", elapsed, res));
fut.await;
}