[−][src]Struct multitask::Task
A spawned future.
Tasks are also futures themselves and yield the output of the spawned future.
When a task is dropped, its gets canceled and won't be polled again. To cancel a task a bit
more gracefully and wait until it stops running, use the cancel()
method.
Tasks that panic get immediately canceled. Awaiting a canceled task also causes a panic.
If a task panics, the panic will be thrown by the Ticker::tick()
invocation that polled it.
Examples
use blocking::block_on; use multitask::Executor; use std::thread; let ex = Executor::new(); // Spawn a future onto the executor. let task = ex.spawn(async { println!("Hello from a task!"); 1 + 2 }); // Run an executor thread. thread::spawn(move || { let (p, u) = parking::pair(); let ticker = ex.ticker(move || u.unpark()); loop { if !ticker.tick() { p.park(); } } }); // Wait for the result. assert_eq!(block_on(task), 3);
Implementations
impl<T> Task<T>
[src]
pub fn detach(self)
[src]
Detaches the task to let it keep running in the background.
Examples
use async_io::Timer; use multitask::Executor; use std::time::Duration; let ex = Executor::new(); // Spawn a deamon future. ex.spawn(async { loop { println!("I'm a daemon task looping forever."); Timer::new(Duration::from_secs(1)).await; } }) .detach();
pub async fn cancel(self) -> Option<T>
[src]
Cancels the task and waits for it to stop running.
Returns the task's output if it was completed just before it got canceled, or None
if
it didn't complete.
While it's possible to simply drop the Task
to cancel it, this is a cleaner way of
canceling because it also waits for the task to stop running.
Examples
use async_io::Timer; use blocking::block_on; use multitask::Executor; use std::thread; use std::time::Duration; let ex = Executor::new(); // Spawn a deamon future. let task = ex.spawn(async { loop { println!("Even though I'm in an infinite loop, you can still cancel me!"); Timer::new(Duration::from_secs(1)).await; } }); // Run an executor thread. thread::spawn(move || { let (p, u) = parking::pair(); let ticker = ex.ticker(move || u.unpark()); loop { if !ticker.tick() { p.park(); } } }); block_on(async { Timer::new(Duration::from_secs(3)).await; task.cancel().await; });
Trait Implementations
Auto Trait Implementations
impl<T> RefUnwindSafe for Task<T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
impl<T> Send for Task<T> where
T: Send,
T: Send,
impl<T> Sync for Task<T>
impl<T> Unpin for Task<T>
impl<T> UnwindSafe for Task<T> where
T: UnwindSafe,
T: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<F> IntoFuture for F where
F: Future,
[src]
F: Future,
type Output = <F as Future>::Output
into_future
)The output that the future will produce on completion.
type Future = F
into_future
)Which kind of future are we turning this into?
fn into_future(self) -> <F as IntoFuture>::Future
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,