> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/holoscan/sdk-user-guide/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/holoscan/sdk-user-guide/_mcp/server.

# holoscan::SignalHandler

> The SignalHandler class provides a mechanism to handle signals in a C++ program.

The `SignalHandler` class provides a mechanism to handle signals in a C++ program.

The `SignalHandler` class provides a way to handle signals in a C++ program. It allows registering global signal handlers and context-specific signal handlers. The class is implemented as a singleton, and its instance can be obtained using the get\_instance() method.

```cpp showLineNumbers={false}
#include <holoscan/signal_handler.hpp>
```

---

## Constructors

### SignalHandler \[#signalhandler]

```cpp showLineNumbers={false}
holoscan::SignalHandler::SignalHandler()
```

Constructs a `SignalHandler` object.

### Destructor \[#destructor]

### \~SignalHandler

```cpp showLineNumbers={false}
holoscan::SignalHandler::~SignalHandler()
```

Destructs a `SignalHandler` object.

---

## Methods

### install\_signal\_handler\_impl \[#installsignalhandlerimpl]

```cpp showLineNumbers={false}
void holoscan::SignalHandler::install_signal_handler_impl(
    int signal = 0
)
```

### register\_global\_signal\_handler\_impl \[#registerglobalsignalhandlerimpl]

```cpp showLineNumbers={false}
void holoscan::SignalHandler::register_global_signal_handler_impl(
    int signal,
    std::function<void(int)> handler,
    bool overwrite = false
)
```

### register\_signal\_handler\_impl \[#registersignalhandlerimpl]

```cpp showLineNumbers={false}
void holoscan::SignalHandler::register_signal_handler_impl(
    void *context,
    int signal,
    std::function<void(void *, int)> handler,
    bool overwrite = false
)
```

### unregister\_global\_signal\_handler\_impl \[#unregisterglobalsignalhandlerimpl]

```cpp showLineNumbers={false}
void holoscan::SignalHandler::unregister_global_signal_handler_impl(
    int signal
)
```

### unregister\_signal\_handler\_impl \[#unregistersignalhandlerimpl]

```cpp showLineNumbers={false}
void holoscan::SignalHandler::unregister_signal_handler_impl(
    void *context,
    int signal
)
```

### handle\_signal \[#handlesignal]

```cpp showLineNumbers={false}
void holoscan::SignalHandler::handle_signal(
    int signal
)
```

---

## Static methods

### get\_instance \[#getinstance]

```cpp showLineNumbers={false}
static SignalHandler & holoscan::SignalHandler::get_instance()
```

Returns the singleton instance of the `SignalHandler` class.

**Returns:** `SignalHandler`& The singleton instance of the `SignalHandler` class.

### static\_handle\_signal \[#statichandlesignal]

```cpp showLineNumbers={false}
static void holoscan::SignalHandler::static_handle_signal(
    int signal
)
```

The static method to handles the specified signal.

**Parameters**

**`signal`** `int`

The signal to handle.

---

### install\_signal\_handler \[#installsignalhandler]

```cpp showLineNumbers={false}
static void holoscan::SignalHandler::install_signal_handler(
    int signal = 0
)
```

Installs the signal handler for the specified signal.

**Parameters**

**`signal`** `int` — default: 0

The signal to install the signal handler for. If signal is 0, the signal handler is installed for all existing signals.

---

### register\_global\_signal\_handler \[#registerglobalsignalhandler]

```cpp showLineNumbers={false}
static void holoscan::SignalHandler::register_global_signal_handler(
    int signal,
    std::function<void(int)> handler,
    bool overwrite = false
)
```

Registers a global signal handler for the specified signal.

**Parameters**

**`signal`** `int`

The signal to register the global signal handler for.

---

**`handler`** `std::function<void(int)>`

The global signal handler function.

---

**`overwrite`** `bool` — default: false

If true, overwrites any existing global signal handler for the specified signal.

---

### register\_signal\_handler \[#registersignalhandler]

```cpp showLineNumbers={false}
static void holoscan::SignalHandler::register_signal_handler(
    void *context,
    int signal,
    std::function<void(void *, int)> handler,
    bool overwrite = false
)
```

Registers a context-specific signal handler for the specified signal.

**Parameters**

**`context`** `void *`

The context to register the signal handler for.

---

**`signal`** `int`

The signal to register the signal handler for.

---

**`handler`** `std::function<void(void *, int)>`

The signal handler function.

---

**`overwrite`** `bool` — default: false

If true, overwrites any existing signal handler for the specified context and signal.

---

### unregister\_global\_signal\_handler \[#unregisterglobalsignalhandler]

```cpp showLineNumbers={false}
static void holoscan::SignalHandler::unregister_global_signal_handler(
    int signal
)
```

Unregisters the global signal handler for the specified signal.

**Parameters**

**`signal`** `int`

The signal to unregister the global signal handler for.

---

### unregister\_signal\_handler \[#unregistersignalhandler]

```cpp showLineNumbers={false}
static void holoscan::SignalHandler::unregister_signal_handler(
    void *context,
    int signal
)
```

Unregisters the context-specific signal handler for the specified context and signal.

**Parameters**

**`context`** `void *`

The context to unregister the signal handler for.

---

**`signal`** `int`

The signal to unregister the signal handler for.

---

### clear\_all\_signal\_handlers \[#clearallsignalhandlers]

```cpp showLineNumbers={false}
static void holoscan::SignalHandler::clear_all_signal_handlers()
```

Clears all signal handlers.

### clear\_global\_signal\_handlers \[#clearglobalsignalhandlers]

```cpp showLineNumbers={false}
static void holoscan::SignalHandler::clear_global_signal_handlers()
```

Clears all global signal handlers.

### clear\_signal\_handlers \[#clearsignalhandlers]

```cpp showLineNumbers={false}
static void holoscan::SignalHandler::clear_signal_handlers()
```

Clears all context-specific signal handlers.

---

## Types

### Typedefs

| Name                      | Definition                                                     | Description                                                |
| ------------------------- | -------------------------------------------------------------- | ---------------------------------------------------------- |
| `GlobalSignalHandlerMap`  | `std::unordered_map< int, std::function< void(int)> >`         | Type definition for a global signal handler map.           |
| `SignalHandlerMap`        | `std::unordered_map< int, std::function< void(void *, int)> >` | Type definition for a signal handler map.                  |
| `ContextSignalHandlerMap` | `std::unordered_map< void *, SignalHandlerMap >`               | Type definition for a context-specific signal handler map. |

---

## Member variables

| Name                      | Type                                          | Description                                   |
| ------------------------- | --------------------------------------------- | --------------------------------------------- |
| `global_signal_handlers_` | `GlobalSignalHandlerMap`                      | The global signal handler map.                |
| `signal_handlers_`        | `ContextSignalHandlerMap`                     | The context-specific signal handler map.      |
| `signal_handlers_mutex_`  | `std::recursive_mutex`                        | The mutex to protect the signal handler maps. |
| `old_signal_handlers_`    | `std::unordered_map< int, struct sigaction >` | The old signal handler map.                   |
| `signal_handler_` static  | `struct sigaction`                            | The signal handler struct.                    |