Struct ThreadExecutor

pub struct ThreadExecutor<'task> { /* private fields */ }

An executor that can only be ticked on the thread it was instantiated on. But can spawn Send tasks from other threads.

Example

use bevy_tasks::ThreadExecutor;

let thread_executor = ThreadExecutor::new();
let count = Arc::new(AtomicI32::new(0));

// create some owned values that can be moved into another thread
let count_clone = count.clone();

std::thread::scope(|scope| {
    scope.spawn(|| {
        // we cannot get the ticker from another thread
        let not_thread_ticker = thread_executor.ticker();
        assert!(not_thread_ticker.is_none());
         
        // but we can spawn tasks from another thread
        thread_executor.spawn(async move {
            count_clone.fetch_add(1, Ordering::Relaxed);
        }).detach();
    });
});

// the tasks do not make progress unless the executor is manually ticked
assert_eq!(count.load(Ordering::Relaxed), 0);

// tick the ticker until task finishes
let thread_ticker = thread_executor.ticker().unwrap();
thread_ticker.try_tick();
assert_eq!(count.load(Ordering::Relaxed), 1);

Implementations

impl<'task> ThreadExecutor<'task>

pub fn new() -> ThreadExecutor<'task>

create a new ThreadExecutor

pub fn spawn<T>( &self, future: impl Future<Output = T> + Send + 'task, ) -> Task<T>

where T: Send + 'task,

Spawn a task on the thread executor

pub fn ticker<'ticker>( &'ticker self, ) -> Option<ThreadExecutorTicker<'task, 'ticker>>

Gets the ThreadExecutorTicker for this executor. Use this to tick the executor. It only returns the ticker if it’s on the thread the executor was created on and returns None otherwise.

pub fn is_same(&self, other: &ThreadExecutor<'task>) -> bool

Returns true if self and other’s executor is same

Trait Implementations

impl<'task> Debug for ThreadExecutor<'task>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'task> Default for ThreadExecutor<'task>

fn default() -> ThreadExecutor<'task>

Returns the “default value” for a type.