Struct futures::task::AtomicTask
[−]
[src]
pub struct AtomicTask { /* fields omitted */ }
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.
Methods
impl AtomicTask
[src]
fn new() -> AtomicTask
[src]
Create an AtomicTask
initialized with the given Task
fn register(&self)
[src]
Registers the current 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.
fn notify(&self)
[src]
Notifies the task that last called register
.
If register
has not been called yet, then this does nothing.