[−][src]Struct async_executor::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.
Examples
use async_executor::{Executor, Task}; let ex = Executor::new(); ex.run(async { let task = Task::spawn(async { println!("Hello from a task!"); 1 + 2 }); assert_eq!(task.await, 3); });
Implementations
impl<T> Task<T>
[src]
pub fn spawn(future: impl Future<Output = T> + Send + 'static) -> Task<T>ⓘ where
T: Send + 'static,
[src]
T: Send + 'static,
Spawns a task onto the current multi-threaded or single-threaded executor.
If called from an Executor
(preferred) or from a LocalExecutor
, the task is spawned
on it.
Otherwise, this method panics.
Examples
use async_executor::{Executor, Task}; let ex = Executor::new(); ex.run(async { let task = Task::spawn(async { 1 + 2 }); assert_eq!(task.await, 3); });
use async_executor::{LocalExecutor, Task}; let local_ex = LocalExecutor::new(); local_ex.run(async { let task = Task::spawn(async { 1 + 2 }); assert_eq!(task.await, 3); });
pub fn local(future: impl Future<Output = T> + 'static) -> Task<T>ⓘ where
T: 'static,
[src]
T: 'static,
Spawns a task onto the current single-threaded executor.
If called from a LocalExecutor
, the task is spawned on it.
Otherwise, this method panics.
Examples
use async_executor::{LocalExecutor, Task}; let local_ex = LocalExecutor::new(); local_ex.run(async { let task = Task::local(async { 1 + 2 }); assert_eq!(task.await, 3); });
pub fn detach(self)
[src]
Detaches the task to let it keep running in the background.
Examples
use async_executor::{Executor, Task}; use futures_lite::future; let ex = Executor::new(); ex.spawn(async { loop { println!("I'm a background task looping forever."); future::yield_now().await; } }) .detach(); ex.run(future::yield_now());
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_executor::{Executor, Task}; use futures_lite::future; let ex = Executor::new(); let task = ex.spawn(async { loop { println!("Even though I'm in an infinite loop, you can still cancel me!"); future::yield_now().await; } }); ex.run(async { 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> FutureExt for T where
T: Future + ?Sized,
[src]
T: Future + ?Sized,
fn boxed(self) -> Pin<Box<dyn Future<Output = Self::Output> + 'static + Send>> where
Self: Send + 'static,
[src]
Self: Send + 'static,
fn boxed_local(self) -> Pin<Box<dyn Future<Output = Self::Output> + 'static>> where
Self: 'static,
[src]
Self: 'static,
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
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<F, T, E> TryFuture for F where
F: Future<Output = Result<T, E>> + ?Sized,
[src]
F: Future<Output = Result<T, E>> + ?Sized,
type Ok = T
The type of successful values yielded by this future
type Error = E
The type of failures yielded by this future
fn try_poll(self: Pin<&mut F>, cx: &mut Context) -> Poll<<F as Future>::Output>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,