Struct signal_hook::low_level::channel::Channel

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

A restricted async-signal-safe channel

This is a bit like the usual channel used for inter-thread communication, but with several restrictions:

• There’s a limited number of slots (currently 5).
• There’s no way to wait for a place in it or for a value. If value is not available, None is returned. If there’s no space for a value, the value is silently dropped.

In exchange for that, all the operations on that channel are async-signal-safe. That means it is possible to use it to communicate between a signal handler and the rest of the world with it (specifically, it’s designed to send information from the handler to the rest of the application). The throwing out of values when full is in line with collating of the same type in kernel (you should not use the same channel for multiple different signals).

Technically, this is a MPMC queue which preserves order, but it is expected to be used in MPSC mode mostly (in theory, multiple threads can be executing a signal handler for the same signal at the same time). The channel is not responsible for wakeups.

While the channel is async-signal-safe, you still need to make sure creating of the values is too (it should not contain anything that allocates, for example ‒ so no Strings inside, etc).

The code was not tuned for performance (signals are not expected to happen often).

Implementations

impl<T> Channel<T>

pub fn new() -> Self

Creates a new channel with nothing in it.

pub fn send(&self, val: T)

Inserts a value into the channel.

If the value doesn’t fit, it is silently dropped. Never blocks.

pub fn recv(&self) -> Option<T>

Takes a value from the channel.

Or returns None if the channel is empty. Never blocks.

Trait Implementations

impl<T> Default for Channel<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Send> Send for Channel<T>

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