Struct SingleThreadScheduledExecutorService 

pub struct SingleThreadScheduledExecutorService { /* private fields */ }

Single-threaded scheduled executor service.

The service owns one scheduler OS thread. It accepts tasks into a deadline heap, waits until the earliest task is due, and then runs that task directly on the scheduler thread. Scheduled tasks should therefore stay short; submit heavier work to another executor service from the scheduled task body.

Implementations

impl SingleThreadScheduledExecutorService

pub fn new(thread_name: &str) -> Result<Self, ExecutorServiceBuilderError>

Starts a new single-thread scheduled executor service.

Parameters

• thread_name - Name for the scheduler thread.

Returns

A started scheduled executor service.

Errors

Returns ExecutorServiceBuilderError::SpawnWorker if the scheduler thread cannot be created.

pub fn with_stack_size( thread_name: &str, stack_size: Option<usize>, ) -> Result<Self, ExecutorServiceBuilderError>

Starts a new scheduled service with an optional scheduler thread stack size.

Parameters

• thread_name - Name for the scheduler thread.
• stack_size - Optional stack size for the scheduler thread.

Returns

A started scheduled executor service.

Errors

Returns ExecutorServiceBuilderError::SpawnWorker if the scheduler thread cannot be created.

pub fn queued_count(&self) -> usize

Returns the number of queued scheduled tasks.

Returns

Number of accepted scheduled tasks that have not started or been cancelled.

pub fn running_count(&self) -> usize

Returns the number of currently running tasks.

Returns

1 when the scheduler thread is running a task, otherwise 0.

Trait Implementations

impl Drop for SingleThreadScheduledExecutorService

fn drop(&mut self)

Requests graceful shutdown when the service handle is dropped.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl ExecutorService for SingleThreadScheduledExecutorService

fn submit<T, E>(&self, task: T) -> Result<(), SubmissionError>

where T: Runnable<E> + Send + 'static, E: Send + 'static,

Accepts a runnable for immediate execution on the scheduler thread.

fn submit_callable<C, R, E>( &self, task: C, ) -> Result<Self::ResultHandle<R, E>, SubmissionError>

where C: Callable<R, E> + Send + 'static, R: Send + 'static, E: Send + 'static,

Accepts a callable for immediate execution on the scheduler thread.

fn submit_tracked_callable<C, R, E>( &self, task: C, ) -> Result<Self::TrackedHandle<R, E>, SubmissionError>

where C: Callable<R, E> + Send + 'static, R: Send + 'static, E: Send + 'static,

Accepts a callable for immediate execution with a scheduled task handle.

fn shutdown(&self)

Requests graceful shutdown and drains accepted scheduled work.

fn stop(&self) -> StopReport

Requests immediate shutdown and cancels tasks that have not started.

fn lifecycle(&self) -> ExecutorServiceLifecycle

Returns the current lifecycle state.

fn is_not_running(&self) -> bool

Returns whether shutdown has started.

fn is_terminated(&self) -> bool

Returns whether the scheduler thread has exited.

fn wait_termination(&self)

Blocks until this scheduled service has terminated.

type ResultHandle<R, E> = TaskHandle<R, E> where R: Send + 'static, E: Send + 'static

Result handle returned for an accepted callable task.

type TrackedHandle<R, E> = ScheduledTaskHandle<R, E> where R: Send + 'static, E: Send + 'static

Tracked handle returned for accepted tasks that expose status.

fn submit_tracked<T, E>( &self, task: T, ) -> Result<Self::TrackedHandle<(), E>, SubmissionError>

where T: Runnable<E> + Send + 'static, E: Send + 'static,

Submits a runnable task and returns a tracked handle.

fn is_running(&self) -> bool

Returns whether the service accepts new tasks.

fn is_shutting_down(&self) -> bool

Returns whether graceful shutdown is in progress.

fn is_stopping(&self) -> bool

Returns whether abrupt stop is in progress.

impl ScheduledExecutorService for SingleThreadScheduledExecutorService

fn schedule_callable_at<C, R, E>( &self, instant: Instant, task: C, ) -> Result<Self::TrackedHandle<R, E>, SubmissionError>

where C: Callable<R, E> + Send + 'static, R: Send + 'static, E: Send + 'static,

Schedules a callable task to start at a monotonic instant.

fn schedule<T, E>( &self, delay: Duration, task: T, ) -> Result<Self::TrackedHandle<(), E>, SubmissionError>

where T: Runnable<E> + Send + 'static, E: Send + 'static,

Schedules a runnable task to start after the supplied delay.

fn schedule_callable<C, R, E>( &self, delay: Duration, task: C, ) -> Result<Self::TrackedHandle<R, E>, SubmissionError>

where C: Callable<R, E> + Send + 'static, R: Send + 'static, E: Send + 'static,

Schedules a callable task to start after the supplied delay.

fn schedule_at<T, E>( &self, instant: Instant, task: T, ) -> Result<Self::TrackedHandle<(), E>, SubmissionError>

where T: Runnable<E> + Send + 'static, E: Send + 'static,

Schedules a runnable task to start at a monotonic instant.