Struct ore::sync::Lottery

pub struct Lottery<T, F> where
    F: Fn() -> T,  { /* fields omitted */ }

A synchronized resource lottery.

Controls access to a non-Sync resource by allowing only one thread to win the resource “lottery.” A dummy resource is constructed for threads that lose the lottery.

Examples

struct Discarder;

impl io::Write for Discarder {
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        Ok(buf.len())
    }
    fn flush(&mut self) -> io::Result<()> {
        Ok(())
    }
}

let stderr: Box<dyn io::Write + Send> = Box::new(io::stderr());
let lottery = Lottery::new(stderr, || Box::new(Discarder));
crossbeam_utils::thread::scope(|thread_scope| {
    (0..5)
        .into_iter()
        .map(|_| {
            thread_scope.spawn(|_| {
                write!(lottery.draw(), "Can you hear me?");
            })
        })
        .for_each(|handle| handle.join().unwrap());
})
.unwrap()

Implementations

impl<T, F> Lottery<T, F> where
    F: Fn() -> T, 

pub fn new(winner: T, losers: F) -> Lottery<T, F>

Creates a new Lottery from the specified winner object and a function to construct loser objects.

pub fn draw(&self) -> T

Attempts to win the lottery. It returns the winner resource if this is the first thread to call draw. If another thread has already claimed the winner resource, it instead constructs and returns a loser resource.

Trait Implementations

impl<T: Debug, F: Debug> Debug for Lottery<T, F> where
    F: Fn() -> T, 

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

Formats the value using the given formatter.