Struct crossbeam_deque::Stealer[][src]

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

A stealer handle of a worker queue.

Stealers can be shared among threads.

Task schedulers typically have a single worker queue per worker thread.

Examples

use crossbeam_deque::{Steal, Worker};

let w = Worker::new_lifo();
w.push(1);
w.push(2);

let s = w.stealer();
assert_eq!(s.steal(), Steal::Success(1));
assert_eq!(s.steal(), Steal::Success(2));
assert_eq!(s.steal(), Steal::Empty);

Implementations

impl<T> Stealer<T>[src]

pub fn is_empty(&self) -> bool[src]

Returns true if the queue is empty.

use crossbeam_deque::Worker;

let w = Worker::new_lifo();
let s = w.stealer();

assert!(s.is_empty());
w.push(1);
assert!(!s.is_empty());

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

Steals a task from the queue.

Examples

use crossbeam_deque::{Steal, Worker};

let w = Worker::new_lifo();
w.push(1);
w.push(2);

let s = w.stealer();
assert_eq!(s.steal(), Steal::Success(1));
assert_eq!(s.steal(), Steal::Success(2));

pub fn steal_batch(&self, dest: &Worker<T>) -> Steal<()>[src]

Steals a batch of tasks and pushes them into another worker.

How many tasks exactly will be stolen is not specified. That said, this method will try to steal around half of the tasks in the queue, but also not more than some constant limit.

Examples

use crossbeam_deque::Worker;

let w1 = Worker::new_fifo();
w1.push(1);
w1.push(2);
w1.push(3);
w1.push(4);

let s = w1.stealer();
let w2 = Worker::new_fifo();

let _ = s.steal_batch(&w2);
assert_eq!(w2.pop(), Some(1));
assert_eq!(w2.pop(), Some(2));

pub fn steal_batch_and_pop(&self, dest: &Worker<T>) -> Steal<T>[src]

Steals a batch of tasks, pushes them into another worker, and pops a task from that worker.

How many tasks exactly will be stolen is not specified. That said, this method will try to steal around half of the tasks in the queue, but also not more than some constant limit.

Examples

use crossbeam_deque::{Steal, Worker};

let w1 = Worker::new_fifo();
w1.push(1);
w1.push(2);
w1.push(3);
w1.push(4);

let s = w1.stealer();
let w2 = Worker::new_fifo();

assert_eq!(s.steal_batch_and_pop(&w2), Steal::Success(1));
assert_eq!(w2.pop(), Some(2));

Trait Implementations

impl<T> Clone for Stealer<T>[src]

impl<T> Debug for Stealer<T>[src]

impl<T: Send> Send for Stealer<T>[src]

impl<T: Send> Sync for Stealer<T>[src]

Auto Trait Implementations

impl<T> RefUnwindSafe for Stealer<T> where
    T: RefUnwindSafe

impl<T> Unpin for Stealer<T>

impl<T> UnwindSafe for Stealer<T> where
    T: RefUnwindSafe

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> Pointable for T[src]

type Init = T

The type for initializers.

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.