Struct ThreadPerTaskExecutor 

pub struct ThreadPerTaskExecutor { /* private fields */ }

Executes each task on a dedicated OS thread.

This executor does not manage lifecycle or maintain a queue. Each accepted task receives a TrackedTask that can be used to wait for the result.

Semantics

• One task, one thread — each Executor::call or Executor::execute spawns a new OS thread. There is no pool and no submission queue.
• Blocking or async wait — TrackedTask::get blocks the calling thread, while awaiting the handle uses a waker and does not block the polling thread.
• Completion probe — TrackedTask::is_done reads the terminal task state; result publication to the handle may still be racing with that observation (you still need TrackedTask::get for the value).

Examples

use std::io;

use qubit_executor::{Executor, ThreadPerTaskExecutor};

let executor = ThreadPerTaskExecutor::new();
let handle = executor
    .call(|| Ok::<i32, io::Error>(40 + 2))
    .expect("worker thread should spawn");

// Blocks the current thread until the spawned thread completes.
let value = handle.get().expect("task should succeed");
assert_eq!(value, 42);

Implementations

impl ThreadPerTaskExecutor

pub fn new() -> Self

Creates an executor using the platform default worker stack size.

Returns

A thread-per-task executor with default worker thread configuration.

pub fn builder() -> ThreadPerTaskExecutorBuilder

Creates a builder for configuring this executor.

Returns

A builder initialized with default worker thread options.

pub fn with_hook(self, hook: Arc<dyn TaskHook>) -> Self

Returns a copy of this executor using the supplied task hook.

Parameters

• hook - Hook notified about accepted task lifecycle events.

Returns

This executor configured with hook.

Trait Implementations

impl Clone for ThreadPerTaskExecutor

fn clone(&self) -> ThreadPerTaskExecutor

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for ThreadPerTaskExecutor

fn default() -> Self

Creates an executor using the platform default worker stack size and no hook.

impl Executor for ThreadPerTaskExecutor

fn call<C, R, E>(&self, task: C) -> Result<TrackedTask<R, E>, SubmissionError>

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

Spawns one OS thread for the callable and returns a handle to its result.

Parameters

• task - Callable to run on a dedicated OS thread.

Returns

A TrackedTask that can block or await the spawned task’s final result.

Errors

Returns SubmissionError::WorkerSpawnFailed if the worker thread cannot be created.

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

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

Submits a runnable task and returns a tracked task handle.