如何在C ++中使用std :: bind函数作为信号处理程序？

Question

我使用以下代码将信号处理添加到我的C ++类：

namespace {
    std::atomic<bool> signal_flag(false);   
}
void terminate_or_interrupt_handler(int signal) {
    switch (signal) {
        case SIGTERM:
            WARN("SIGTERM received");
            signal_flag.store(true);
            break;
        case SIGINT:
            WARN("SIGINT received");
            signal_flag.store(true);
            break;
        default:
            throw (std::runtime_error("Unhandled signal received"));
    }
}
signal(SIGTERM, &terminate_or_interrupt_handler);

此代码有效，但它要求信号处理函数在与信号标志变量相同的范围内定义。我决定修改代码并通过引用函数传递signal_flag并使用std::bind将处理程序“特化”到我的类。

 void terminate_or_interrupt_handler(std::atomic<bool>& signal_flag, int signal) {
    switch (signal) {
        case SIGTERM:
            WARN("SIGTERM received");
            signal_flag.store(true);
            break;
        case SIGINT:
            WARN("SIGINT received");
            signal_flag.store(true);
            break;
        default:
            throw (std::runtime_error("Unhandled signal received"));
    }
}
auto my_handler = std::bind(terminate_or_interrupt_handler, std::ref(my_class_signal_flag), std::placeholders::_1);
signal(SIGTERM, &my_handler);

但是，我收到此编译错误：

error: cannot convert ‘std::_Bind<void (*(std::reference_wrapper<std::atomic<bool> >, std::_Placeholder<1>))(std::atomic<bool>&, int)>*’ to ‘__sighandler_t’ {aka ‘void (*)(int)’}

有没有办法在C ++中使用绑定函数和signal函数？

Answer 1

std::bind的结果是一个未指定的函数对象，其类型无法转换为void (*)(int)。尝试封装它：

void handler_foo(int signal)
{
    return terminate_or_interrupt_handler(signal_flag, signal);
}

或者，如果C ++ 11可用，lambda可能会更好：

signal(SIGTERM, [](int signal) { return terminate_or_interrupt_handler(signal_flag, signal); });

请注意，由于signal_flag是一个全局变量（名称空间范围变量），因此不需要捕获。非捕获lambda可以隐式转换为相应的函数指针类型。

Answer 2

如果您的软件在Linux下运行并且您的过程使用poll()或select()，那么使用signalfd()可能会更加清晰。

我已经在2789行左右的snap_communicator class中实现了这样的功能。有一份实施副本。

snap_communicator::snap_signal::snap_signal(int posix_signal)
    : f_signal(posix_signal)
    //, f_socket(-1) -- auto-init
    //, f_signal_info() -- auto-init
    //, f_unblock(false) -- auto-init
{
    int const r(sigismember(&g_signal_handlers, f_signal));
    if(r != 0)
    {
        if(r == 1)
        {
            // this could be fixed, but probably not worth the trouble...
            throw snap_communicator_initialization_error("the same signal cannot be created more than once in your entire process.");
        }
        // f_signal is not considered valid by this OS
        throw snap_communicator_initialization_error("posix_signal (f_signal) is not a valid/recognized signal number.");
    }

    // create a mask for that signal
    //
    sigset_t set;
    sigemptyset(&set);
    sigaddset(&set, f_signal); // ignore error, we already know f_signal is valid

    // first we block the signal
    //
    if(sigprocmask(SIG_BLOCK, &set, nullptr) != 0)
    {
        throw snap_communicator_runtime_error("sigprocmask() failed to block signal.");
    }

    // second we create a "socket" for the signal (really it is a file
    // descriptor manager by the kernel)
    //
    f_socket = signalfd(-1, &set, SFD_NONBLOCK | SFD_CLOEXEC);
    if(f_socket == -1)
    {
        int const e(errno);
        SNAP_LOG_ERROR("signalfd() failed to create a signal listener for signal ")(f_signal)(" (errno: ")(e)(" -- ")(strerror(e))(")");
        throw snap_communicator_runtime_error("signalfd() failed to create a signal listener.");
    }

    // mark this signal as in use
    //
    sigaddset(&g_signal_handlers, f_signal); // ignore error, we already know f_signal is valid
}

使用该“套接字”，您可以执行poll()，并在信号到达时触发等效于读取事件。

您检索信号信息，如下所示：

int const r(read(f_socket, &f_signal_info, sizeof(f_signal_info)));

与f_signal_info宣布为：

struct signalfd_siginfo     f_signal_info;

最棒的是，现在所有这些都发生在我的类中，我没有任何“怪异”的信号处理程序，它可以锁定我的线程，不能正确处理C ++异常，以及其他潜在的问题。在我的结尾，我有C ++类，其中包含虚拟函数，每当事件发生时都会被调用，包括SIGINT，SIGPIPE，SIGCHLD等Unix信号...你也可以使用boost信号实现回调，这使你能够使用std::bind()。

所有这些说，我仍然使用signal()为SIGSEGV，SIGBUS等等，当它们发生时我不会做任何额外的工作。我尝试在那些上记录堆栈跟踪，就是这样。所以我不使用signalfd()。