# 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]

#### `pub fn new() -> AtomicTask`
[src]

Create an `AtomicTask` initialized with the given `Task`

#### `pub fn register(&self)`
[src]

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)`
[src]

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)`
[src]

Notifies the task that last called `register`.

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

## Trait Implementations

### `impl Default for AtomicTask`
[src]

#### `fn default() -> Self`
[src]

Returns the "default value" for a type. Read more

### `impl Debug for AtomicTask`
[src]

#### `fn fmt(&self, fmt: &mut Formatter) -> Result`
[src]

Formats the value using the given formatter. Read more

### `impl Send for AtomicTask`
[src]

### `impl Sync for AtomicTask`
[src]

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)