Struct tokio::runtime::scheduler::inject::shared::Shared

pub(crate) struct Shared<T: 'static> {
    pub(super) len: AtomicUsize,
    _p: PhantomData<T>,
}

Fields

len: AtomicUsize

Number of pending tasks in the queue. This helps prevent unnecessary locking in the hot path.

_p: PhantomData<T>

Implementations

impl<T: 'static> Shared<T>

pub(crate) fn new() -> (Shared<T>, Synced)

pub(crate) fn is_empty(&self) -> bool

pub(crate) fn is_closed(&self, synced: &Synced) -> bool

pub(crate) fn close(&self, synced: &mut Synced) -> bool

Closes the injection queue, returns true if the queue is open when the transition is made.

pub(crate) fn len(&self) -> usize

pub(crate) unsafe fn push(&self, synced: &mut Synced, task: Notified<T>)

Pushes a value into the queue.

This does nothing if the queue is closed.

Safety

Must be called with the same Synced instance returned by Inject::new

pub(crate) unsafe fn pop(&self, synced: &mut Synced) -> Option<Notified<T>>

Pop a value from the queue.

Safety

Must be called with the same Synced instance returned by Inject::new

pub(crate) unsafe fn pop_n<'a>( &'a self, synced: &'a mut Synced, n: usize, ) -> Pop<'a, T>

Pop n values from the queue

Safety

Must be called with the same Synced instance returned by Inject::new

impl<T: 'static> Shared<T>

pub(crate) unsafe fn push_batch<L, I>(&self, shared: L, iter: I)

where L: Lock<Synced>, I: Iterator<Item = Notified<T>>,

Pushes several values into the queue.

Safety

Must be called with the same Synced instance returned by Inject::new

unsafe fn push_batch_inner<L>( &self, shared: L, batch_head: RawTask, batch_tail: RawTask, num: usize, )

where L: Lock<Synced>,

Inserts several tasks that have been linked together into the queue.

The provided head and tail may be be the same task. In this case, a single task is inserted.

Trait Implementations

impl<T> Send for Shared<T>

impl<T> Sync for Shared<T>