Struct crossbeam_deque::Stealer

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

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.

Implementations

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> Clone for Stealer<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Stealer<T>

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

Formats the value using the given formatter.

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

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