Trait AsyncRuntime 

pub trait AsyncRuntime<O: Default + 'static = ()>:
    Clone
    + Send
    + Sync
    + 'static {
    type Pool: AsyncTaskPoolExt<O> + AsyncTaskPool<O, Pool = Self::Pool>;

    // Required methods
    fn shared_pool(&self) -> Arc<Self::Pool>;
    fn get_id(&self) -> usize;
    fn wait_len(&self) -> usize;
    fn len(&self) -> usize;
    fn alloc<R: 'static>(&self) -> TaskId;
    fn spawn<F>(&self, future: F) -> Result<TaskId>
       where F: Future<Output = O> + Send + 'static;
    fn spawn_local<F>(&self, future: F) -> Result<TaskId>
       where F: Future<Output = O> + Send + 'static;
    fn spawn_priority<F>(&self, priority: usize, future: F) -> Result<TaskId>
       where F: Future<Output = O> + Send + 'static;
    fn spawn_yield<F>(&self, future: F) -> Result<TaskId>
       where F: Future<Output = O> + Send + 'static;
    fn spawn_timing<F>(&self, future: F, time: usize) -> Result<TaskId>
       where F: Future<Output = O> + Send + 'static;
    fn spawn_by_id<F>(&self, task_id: TaskId, future: F) -> Result<()>
       where F: Future<Output = O> + Send + 'static;
    fn spawn_local_by_id<F>(&self, task_id: TaskId, future: F) -> Result<()>
       where F: Future<Output = O> + Send + 'static;
    fn spawn_priority_by_id<F>(
        &self,
        task_id: TaskId,
        priority: usize,
        future: F,
    ) -> Result<()>
       where F: Future<Output = O> + Send + 'static;
    fn spawn_yield_by_id<F>(&self, task_id: TaskId, future: F) -> Result<()>
       where F: Future<Output = O> + Send + 'static;
    fn spawn_timing_by_id<F>(
        &self,
        task_id: TaskId,
        future: F,
        time: usize,
    ) -> Result<()>
       where F: Future<Output = O> + Send + 'static;
    fn pending<Output: 'static>(
        &self,
        task_id: &TaskId,
        waker: Waker,
    ) -> Poll<Output>;
    fn wakeup<Output: 'static>(&self, task_id: &TaskId);
    fn wait<V: Send + 'static>(&self) -> AsyncWait<V>;
    fn wait_any<V: Send + 'static>(&self, capacity: usize) -> AsyncWaitAny<V>;
    fn wait_any_callback<V: Send + 'static>(
        &self,
        capacity: usize,
    ) -> AsyncWaitAnyCallback<V>;
    fn map_reduce<V: Send + 'static>(
        &self,
        capacity: usize,
    ) -> AsyncMapReduce<V>;
    fn timeout(&self, timeout: usize) -> BoxFuture<'static, ()>;
    fn yield_now(&self) -> BoxFuture<'static, ()>;
    fn pipeline<S, SO, F, FO>(
        &self,
        input: S,
        filter: F,
    ) -> BoxStream<'static, FO>
       where S: Stream<Item = SO> + Send + 'static,
             SO: Send + 'static,
             F: FnMut(SO) -> AsyncPipelineResult<FO> + Send + 'static,
             FO: Send + 'static;
    fn close(&self) -> bool;
}

异步运行时

Required Associated Types

type Pool: AsyncTaskPoolExt<O> + AsyncTaskPool<O, Pool = Self::Pool>

Required Methods

fn shared_pool(&self) -> Arc<Self::Pool>

共享运行时内部任务池

fn get_id(&self) -> usize

获取当前异步运行时的唯一id

fn wait_len(&self) -> usize

获取当前异步运行时待处理任务数量

fn len(&self) -> usize

获取当前异步运行时任务数量

fn alloc<R: 'static>(&self) -> TaskId

分配异步任务的唯一id

fn spawn<F>(&self, future: F) -> Result<TaskId>

where F: Future<Output = O> + Send + 'static,

派发一个指定的异步任务到异步运行时

fn spawn_local<F>(&self, future: F) -> Result<TaskId>

where F: Future<Output = O> + Send + 'static,

派发一个异步任务到本地异步运行时，如果本地没有本异步运行时，则会派发到当前运行时中

fn spawn_priority<F>(&self, priority: usize, future: F) -> Result<TaskId>

where F: Future<Output = O> + Send + 'static,

派发一个指定优先级的异步任务到异步运行时

fn spawn_yield<F>(&self, future: F) -> Result<TaskId>

where F: Future<Output = O> + Send + 'static,

派发一个异步任务到异步运行时，并立即让出任务的当前运行

fn spawn_timing<F>(&self, future: F, time: usize) -> Result<TaskId>

where F: Future<Output = O> + Send + 'static,

派发一个在指定时间后执行的异步任务到异步运行时，时间单位ms

fn spawn_by_id<F>(&self, task_id: TaskId, future: F) -> Result<()>

where F: Future<Output = O> + Send + 'static,

派发一个指定任务唯一id的异步任务到异步运行时

fn spawn_local_by_id<F>(&self, task_id: TaskId, future: F) -> Result<()>

where F: Future<Output = O> + Send + 'static,

派发一个指定任务唯一id的异步任务到本地异步运行时，如果本地没有本异步运行时，则会派发到当前运行时中

fn spawn_priority_by_id<F>( &self, task_id: TaskId, priority: usize, future: F, ) -> Result<()>

where F: Future<Output = O> + Send + 'static,

派发一个指定任务唯一id和任务优先级的异步任务到异步运行时

fn spawn_yield_by_id<F>(&self, task_id: TaskId, future: F) -> Result<()>

where F: Future<Output = O> + Send + 'static,

派发一个指定任务唯一id的异步任务到异步运行时，并立即让出任务的当前运行

fn spawn_timing_by_id<F>( &self, task_id: TaskId, future: F, time: usize, ) -> Result<()>

where F: Future<Output = O> + Send + 'static,

派发一个指定任务唯一id和在指定时间后执行的异步任务到异步运行时，时间单位ms

fn pending<Output: 'static>( &self, task_id: &TaskId, waker: Waker, ) -> Poll<Output>

挂起指定唯一id的异步任务

fn wakeup<Output: 'static>(&self, task_id: &TaskId)

唤醒指定唯一id的异步任务

fn wait<V: Send + 'static>(&self) -> AsyncWait<V>

挂起当前异步运行时的当前任务，并在指定的其它运行时上派发一个指定的异步任务，等待其它运行时上的异步任务完成后，唤醒当前运行时的当前任务，并返回其它运行时上的异步任务的值

fn wait_any<V: Send + 'static>(&self, capacity: usize) -> AsyncWaitAny<V>

挂起当前异步运行时的当前任务，并在多个其它运行时上执行多个其它任务，其中任意一个任务完成，则唤醒当前运行时的当前任务，并返回这个已完成任务的值，而其它未完成的任务的值将被忽略

fn wait_any_callback<V: Send + 'static>( &self, capacity: usize, ) -> AsyncWaitAnyCallback<V>

挂起当前异步运行时的当前任务，并在多个其它运行时上执行多个其它任务，任务返回后需要通过用户指定的检查回调进行检查，其中任意一个任务检查通过，则唤醒当前运行时的当前任务，并返回这个已完成任务的值，而其它未完成或未检查通过的任务的值将被忽略，如果所有任务都未检查通过，则强制唤醒当前运行时的当前任务

fn map_reduce<V: Send + 'static>(&self, capacity: usize) -> AsyncMapReduce<V>

构建用于派发多个异步任务到指定运行时的映射归并，需要指定映射归并的容量

fn timeout(&self, timeout: usize) -> BoxFuture<'static, ()>

挂起当前异步运行时的当前任务，等待指定的时间后唤醒当前任务

fn yield_now(&self) -> BoxFuture<'static, ()>

立即让出当前任务的执行

fn pipeline<S, SO, F, FO>(&self, input: S, filter: F) -> BoxStream<'static, FO>

where S: Stream<Item = SO> + Send + 'static, SO: Send + 'static, F: FnMut(SO) -> AsyncPipelineResult<FO> + Send + 'static, FO: Send + 'static,

生成一个异步管道，输入指定流，输入流的每个值通过过滤器生成输出流的值

fn close(&self) -> bool

关闭异步运行时，返回请求关闭是否成功

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<O: Default + 'static, P: AsyncTaskPoolExt<O> + AsyncTaskPool<O, Pool = P>> AsyncRuntime<O> for MultiTaskRuntime<O, P>

type Pool = P

impl<O: Default + 'static, P: AsyncTaskPoolExt<O> + AsyncTaskPool<O, Pool = P>> AsyncRuntime<O> for SingleTaskRuntime<O, P>

type Pool = P

impl<O: Default + 'static, P: AsyncTaskPoolExt<O> + AsyncTaskPool<O, Pool = P>> AsyncRuntime<O> for WorkerRuntime<O, P>

type Pool = P