| Home | Libraries | People | FAQ | More

### signal_set

Provides signal functionality.

    class signal_set

##### Types

Name | Description
--- | ---
executor_type | The type of the executor associated with the object.

##### Member Functions

Name | Description
--- | ---
add | Add a signal to a signal_set.
async_wait | Start an asynchronous operation to wait for a signal to be delivered.
cancel | Cancel all operations associated with the signal set.
clear | Remove all signals from a signal_set.
get_executor | Get the executor associated with the object.
get_io_context | (Deprecated: Use get_executor().) Get the io_context associated with the object.
get_io_service | (Deprecated: Use get_executor().) Get the io_context associated with the object.
remove | Remove a signal from a signal_set.
signal_set | Construct a signal set without adding any signals. Construct a signal set and add one signal. Construct a signal set and add two signals. Construct a signal set and add three signals.
~signal_set | Destroys the signal set.

The `signal_set` class provides the ability to perform an asynchronous wait for one or more signals to occur.

##### Thread Safety

Distinct objects: Safe.

Shared objects: Unsafe.

##### Example

Performing an asynchronous wait:

    void handler(
        const boost::system::error_code& error,
        int signal_number)
    {
      if (!error)
      {
        // A signal occurred.
      }
    }

    ...

    // Construct a signal set registered for process termination.
    boost::asio::signal_set signals(io_context, SIGINT, SIGTERM);

    // Start an asynchronous wait for one of the signals to occur.
    signals.async_wait(handler);

##### Queueing of signal notifications

If a signal is registered with a `signal_set`, and the signal occurs when there are no waiting handlers, then the signal notification is queued. The next async_wait operation on that `signal_set` will dequeue the notification. If multiple notifications are queued, subsequent async_wait operations dequeue them one at a time. Signal notifications are dequeued in order of ascending signal number.

If a signal number is removed from a `signal_set` (using the `remove` or `erase` member functions) then any queued notifications for that signal are discarded.

##### Multiple registration of signals

The same signal number may be registered with different `signal_set` objects. When the signal occurs, one handler is called for each `signal_set` object.

Note that multiple registration only works for signals that are registered using Asio. The application must not also register a signal handler using functions such as `signal()` or `sigaction()`.

##### Signal masking on POSIX platforms

POSIX allows signals to be blocked using functions such as `sigprocmask()` and `pthread_sigmask()`. For signals to be delivered, programs must ensure that any signals registered using `signal_set` objects are unblocked in at least one thread.

##### Requirements

Header: `boost/asio/signal_set.hpp`

Convenience header: `boost/asio.hpp`