pub struct Stealer<T> { /* private fields */ }
Expand description
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§
source§impl<T> Stealer<T>
impl<T> Stealer<T>
sourcepub fn is_empty(&self) -> bool
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());
sourcepub fn steal(&self) -> Steal<T>
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);
sourcepub fn steal_many(&self, dest: &Worker<T>) -> Steal<T>
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));