Struct SyncStopper 

pub struct SyncStopper { /* private fields */ }

A cancellation primitive with Release/Acquire memory ordering.

Unlike Stopper which uses Relaxed ordering, SyncStopper guarantees that all writes before cancel() are visible to any clone that subsequently observes should_stop() == true.

Example

use almost_enough::{SyncStopper, Stop};

let stop = SyncStopper::new();
let stop2 = stop.clone();

// In producer thread:
// ... write shared data ...
stop.cancel();  // Release barrier

// In consumer thread:
if stop2.should_stop() {  // Acquire barrier
    // Safe to read shared data written before cancel()
}

Performance

On x86/x64, Release/Acquire has negligible overhead (strong memory model). On ARM and other weakly-ordered architectures, there’s a small cost for the memory barriers. Use Stopper if you don’t need the synchronization guarantees.

Implementations

impl SyncStopper

pub fn new() -> Self

Create a new synchronized stopper.

pub fn cancelled() -> Self

Create a stopper that is already cancelled.

pub fn cancel(&self)

Cancel with Release ordering.

All memory writes before this call are guaranteed to be visible to any clone that subsequently observes should_stop() == true.

pub fn is_cancelled(&self) -> bool

Check if cancelled with Acquire ordering.

If this returns true, all memory writes that happened before the corresponding cancel() call are guaranteed to be visible.

Trait Implementations

impl Clone for SyncStopper

fn clone(&self) -> SyncStopper

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SyncStopper

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

Formats the value using the given formatter.

impl Default for SyncStopper

fn default() -> Self

Returns the “default value” for a type.

impl Stop for SyncStopper

fn check(&self) -> Result<(), StopReason>

Check if the operation should stop.

fn should_stop(&self) -> bool

Returns true if the operation should stop.