Struct AtomicTask

pub struct AtomicTask { /* private fields */ }

A synchronization primitive for task notification.

AtomicTask will coordinate concurrent notifications with the consumer potentially “updating” the underlying task to notify. This is useful in scenarios where a computation completes in another thread and wants to notify the consumer, but the consumer is in the process of being migrated to a new logical task.

Consumers should call register before checking the result of a computation and producers should call notify after producing the computation (this differs from the usual thread::park pattern). It is also permitted for notify to be called before register. This results in a no-op.

A single AtomicTask may be reused for any number of calls to register or notify.

AtomicTask does not provide any memory ordering guarantees, as such the user should use caution and use other synchronization primitives to guard the result of the underlying computation.

Implementations

impl AtomicTask

pub fn new() -> AtomicTask

Create an AtomicTask initialized with the given Task

pub fn register(&self)

Registers the current task to be notified on calls to notify.

This is the same as calling register_task with task::current().

pub fn register_task(&self, task: Task)

Registers the provided task to be notified on calls to notify.

The new task will take place of any previous tasks that were registered by previous calls to register. Any calls to notify that happen after a call to register (as defined by the memory ordering rules), will notify the register caller’s task.

It is safe to call register with multiple other threads concurrently calling notify. This will result in the register caller’s current task being notified once.

This function is safe to call concurrently, but this is generally a bad idea. Concurrent calls to register will attempt to register different tasks to be notified. One of the callers will win and have its task set, but there is no guarantee as to which caller will succeed.

pub fn notify(&self)

Notifies the task that last called register.

If register has not been called yet, then this does nothing.

pub fn take_task(&self) -> Option<Task>

Attempts to take the Task value out of the AtomicTask with the intention that the caller will notify the task later.

Trait Implementations

impl Debug for AtomicTask

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

Formats the value using the given formatter.

impl Default for AtomicTask

fn default() -> Self

Returns the “default value” for a type.

impl Send for AtomicTask

impl Sync for AtomicTask