Struct crossbeam::deque::Stealer

pub struct Stealer<T> { /* fields omitted */ }

The stealer side of a deque.

Stealers can only steal elements from the front of the deque.

Stealers are cloneable so that they can be easily shared among multiple threads.

Methods

impl<T> Stealer<T>

pub fn is_empty(&self) -> bool

Returns true if the deque is empty.

use crossbeam_deque as deque;

let (w, s) = deque::lifo();
assert!(s.is_empty());
w.push(1);
assert!(!s.is_empty());

pub fn steal(&self) -> Steal<T>

Steals an element from the front of the deque.

Examples

use crossbeam_deque::{self as deque, Steal};

let (w, s) = deque::lifo();
w.push(1);
w.push(2);

assert_eq!(s.steal(), Steal::Data(1));
assert_eq!(s.steal(), Steal::Data(2));
assert_eq!(s.steal(), Steal::Empty);

pub fn steal_many(&self, dest: &Worker<T>) -> Steal<T>

Steals elements from the front of the deque.

If at least one element can be stolen, it will be returned. Additionally, some of the remaining elements will be stolen and pushed into the back of worker dest in order to balance the work among deques. There is no hard guarantee on exactly how many elements will be stolen, but it should be around half of the deque.

Examples

use crossbeam_deque::{self as deque, Steal};

let (w1, s1) = deque::fifo();
let (w2, s2) = deque::fifo();

w1.push(1);
w1.push(2);
w1.push(3);
w1.push(4);

assert_eq!(s1.steal_many(&w2), Steal::Data(1));
assert_eq!(s2.steal(), Steal::Data(2));

Trait Implementations

impl<T> Debug for Stealer<T>

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

Formats the value using the given formatter.

impl<T> Clone for Stealer<T>

fn clone(&self) -> Stealer<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Sync for Stealer<T> where
    T: Send, 

impl<T> Send for Stealer<T> where
    T: Send,