Struct InterruptibleEvent 

pub struct InterruptibleEvent { /* private fields */ }

A blocking object that can either be notified normally or interrupted

To block using an InterruptibleEvent, first call begin_wait. At this point, the event is in the “waiting” state, and future calls to notify or interrupt will terminate the wait.

After begin_wait returns, call block_until to block the current thread until one of the following conditions occur:

1. The given deadline expires.
2. At least one of the notify or interrupt functions were called after begin_wait.

It’s safe to call notify or interrupt at any time. However, calls to begin_wait and block_until must alternate, starting with begin_wait.

InterruptibleEvent uses two-phase waiting so that clients can register for notification, perform some related work, and then start blocking. This approach ensures that clients do not miss notifications that arrive after they perform the related work but before they actually start blocking.

Implementations

impl InterruptibleEvent

pub fn new() -> Arc<Self>

pub fn get_owner(&self) -> Option<Koid>

Returns the owner of the underlying futex, if any.

pub fn begin_wait<'a>(self: &'a Arc<Self>) -> EventWaitGuard<'a>

Called to initiate a wait.

Calls to notify or interrupt after this function returns will cause the event to wake up. Calls to those functions prior to calling begin_wait will be ignored.

Once called, this function cannot be called again until block_until returns. Otherwise, this function will panic.

pub fn notify(&self)

Wake up the event normally.

If this function is called before begin_wait, this notification is ignored. Calling this function repeatedly has no effect. If both notify and interrupt are called, the state observed by block_until is a race.

pub fn interrupt(&self)

Wake up the event because of an interruption.

If this function is called before begin_wait, this notification is ignored. Calling this function repeatedly has no effect. If both notify and interrupt are called, the state observed by block_until is a race.

Trait Implementations

impl Debug for InterruptibleEvent

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

Formats the value using the given formatter.

impl Default for InterruptibleEvent

fn default() -> Self

Returns the “default value” for a type.