C++ 信号处理：`signal` 函数与多线程环境的挑战

好的，各位朋友们，今天咱们来聊聊C++里面的信号处理，尤其是signal函数在多线程环境下的那些坑。这玩意儿啊，用起来看着简单，但一不小心就容易挖坑把自己埋了。

第一部分：什么是信号？signal函数是干啥的？

想象一下，你正在愉快地写代码，突然有人踹了你一脚（或者系统发生了什么事情），你被打断了，得先处理一下这个突发事件，然后再回去继续写代码。这个“踹一脚”就是信号。

信号是操作系统用来通知进程发生了某些事件的一种机制。这些事件可以是用户按下了Ctrl+C（SIGINT信号），程序遇到了除零错误（SIGFPE信号），或者子进程结束了（SIGCHLD信号）等等。

signal函数呢，就是C++（更准确地说是C标准库）提供的一个接口，让你告诉操作系统，收到某个信号的时候，你想干点啥。它的原型长这样：

#include <csignal>

typedef void (*sighandler_t)(int);

sighandler_t signal(int signum, sighandler_t handler);

signum: 你要处理的信号的编号，比如SIGINT、SIGSEGV。
handler: 一个函数指针，指向你的信号处理函数。当收到signum信号时，操作系统就会调用这个函数。这个函数接收一个int参数，就是收到的信号编号。
返回值：如果成功，返回之前注册的信号处理函数的指针；如果出错，返回SIG_ERR。

简单来说，你用signal函数告诉操作系统：“嘿，老兄，如果我收到SIGINT信号，就去执行这个函数。”

示例代码：一个简单的信号处理

#include <iostream>
#include <csignal>
#include <unistd.h> // For sleep()

void signalHandler(int signum) {
  std::cout << "Interrupt signal (" << signum << ") received.n";
  // 清理资源，退出程序...
  exit(signum);
}

int main() {
  // 注册信号处理函数
  signal(SIGINT, signalHandler);

  while (true) {
    std::cout << "Going to sleep....n";
    sleep(1);
  }

  return 0;
}

这段代码注册了一个signalHandler函数来处理SIGINT信号（通常是Ctrl+C）。当你运行这段程序，然后按下Ctrl+C时，你会看到“Interrupt signal (2) received.”的输出，然后程序退出。

第二部分：多线程环境下的signal函数：坑来了！

单线程下，signal函数用起来还算简单。但是，一旦涉及到多线程，问题就复杂了。主要有以下几个坑：

信号处理函数在哪个线程执行？

这是最关键的问题。POSIX标准规定，信号处理函数会在进程中的任何一个线程中执行。也就是说，你没法控制信号处理函数到底在哪个线程里跑。这就会导致各种各样的问题。

想象一下，你的程序有多个线程，其中一个线程正在修改一个全局变量，突然收到了一个信号，信号处理函数也在试图修改这个全局变量。这就会发生数据竞争，导致程序崩溃或者行为异常。

为了更清晰地说明，我们用表格来总结一下：

特性	单线程环境	多线程环境
信号处理线程	信号处理函数在主线程中执行。	信号处理函数在进程中的任何一个线程中执行。无法预测具体是哪个线程。
数据竞争	相对较少，通常可以通过简单的方式避免。	风险很高。信号处理函数可能在任何时候中断任何线程，访问共享资源可能导致数据竞争、死锁等问题。
线程安全	通常不需要特别考虑线程安全问题。	必须非常小心！因为信号处理函数可能访问任何线程的共享数据，所以必须采取适当的同步机制（互斥锁、原子操作等）来保证线程安全。
可移植性	相对较好。	差。不同操作系统对信号处理的实现可能存在差异，尤其是在多线程环境下。使用`signal`函数在多线程程序中可能会导致不可预测的行为。更好的选择是使用`pthread_sigmask`和`sigwait`等函数。

不可重入函数（Non-reentrant functions）

有些函数是不可重入的。这意味着如果一个线程正在执行这个函数，另一个线程（或者同一个线程因为信号处理）又开始执行这个函数，就会发生问题。标准C库里有很多函数都是不可重入的，比如malloc、printf。

如果在信号处理函数中调用了不可重入的函数，而恰好某个线程正在执行这个函数，程序就可能会崩溃。
死锁

如果信号处理函数需要获取一个互斥锁，而恰好某个线程已经持有这个互斥锁，并且被信号中断了，那么信号处理函数就会一直阻塞，导致死锁。

示例代码：一个潜在的死锁

#include <iostream>
#include <csignal>
#include <mutex>
#include <unistd.h>
#include <thread>

std::mutex mtx;

void signalHandler(int signum) {
  std::cout << "Signal handler called.n";
  mtx.lock(); // 尝试获取互斥锁，可能导致死锁
  std::cout << "Signal handler acquired lock.n";
  mtx.unlock();
  exit(signum);
}

void workerThread() {
  mtx.lock();
  std::cout << "Worker thread acquired lock.n";
  sleep(5); // 模拟长时间操作
  std::cout << "Worker thread releasing lock.n";
  mtx.unlock();
}

int main() {
  signal(SIGINT, signalHandler);

  std::thread t(workerThread);
  t.detach();

  while (true) {
    sleep(1);
  }

  return 0;
}

在这个例子中，workerThread线程获取了互斥锁mtx，然后睡眠5秒。如果在workerThread睡眠期间，你按下Ctrl+C，signalHandler函数会被调用，它也会尝试获取mtx。由于workerThread还持有mtx，signalHandler会一直阻塞，导致死锁。

第三部分：更好的选择：pthread_sigmask和sigwait

既然signal函数在多线程环境下这么坑，有没有更好的替代方案呢？答案是肯定的。POSIX标准提供了pthread_sigmask和sigwait这两个函数，它们可以更安全、更可靠地处理多线程环境下的信号。

pthread_sigmask: 允许你控制线程可以接收哪些信号。你可以用它来阻塞某些信号，让它们暂时不被传递给线程。
sigwait: 阻塞调用线程，直到收到指定的信号。

使用pthread_sigmask和sigwait的思路是：

创建一个专门的线程来处理信号。
在所有其他线程中，使用pthread_sigmask屏蔽掉需要处理的信号。
在信号处理线程中，使用sigwait等待信号。当收到信号时，sigwait返回，信号处理线程就可以安全地处理信号了。

这样，就可以避免信号处理函数在任意线程中执行，从而避免数据竞争和死锁等问题。

示例代码：使用pthread_sigmask和sigwait

#include <iostream>
#include <csignal>
#include <pthread.h>
#include <unistd.h>
#include <thread>

void* signalHandlerThread(void* arg) {
  sigset_t* set = (sigset_t*)arg;
  int sig;

  while (true) {
    int ret = sigwait(set, &sig);
    if (ret == 0) {
      std::cout << "Signal " << sig << " received in signal handler thread.n";
      // 在这里安全地处理信号
      exit(sig);
    } else {
      perror("sigwait");
    }
  }
  return nullptr;
}

int main() {
  sigset_t set;
  sigemptyset(&set);
  sigaddset(&set, SIGINT); // 添加要处理的信号

  // 阻塞主线程和其他线程中的 SIGINT 信号
  pthread_sigmask(SIG_BLOCK, &set, nullptr);

  // 创建信号处理线程
  pthread_t signalThread;
  pthread_create(&signalThread, nullptr, signalHandlerThread, &set);
  pthread_detach(signalThread);

  while (true) {
    std::cout << "Main thread is running...n";
    sleep(1);
  }

  return 0;
}

在这个例子中，我们创建了一个signalHandlerThread线程来专门处理SIGINT信号。在main函数中，我们使用pthread_sigmask阻塞了SIGINT信号，这样SIGINT信号就不会传递给main线程。然后，signalHandlerThread线程使用sigwait等待SIGINT信号。当收到SIGINT信号时，sigwait返回，signalHandlerThread线程就可以安全地处理信号了。

第四部分：总结与建议

signal函数在单线程环境下用起来还行，但在多线程环境下，简直就是一颗定时炸弹。为了避免各种坑，强烈建议在多线程程序中使用pthread_sigmask和sigwait来处理信号。

以下是一些建议：

尽量避免在信号处理函数中访问共享资源。 如果必须访问，一定要使用适当的同步机制（互斥锁、原子操作等）来保证线程安全。
不要在信号处理函数中调用不可重入的函数。
使用pthread_sigmask和sigwait来处理多线程环境下的信号。
仔细测试你的代码，确保信号处理逻辑正确。

最后，记住，信号处理是一个复杂的问题，需要谨慎对待。不要想当然地认为你的代码是正确的，一定要进行充分的测试。

希望这次讲座对大家有所帮助。记住，编程不易，且行且珍惜！遇到问题，多查资料，多思考，总能找到解决方案的。下次再见！

发表回复 取消回复

发表回复取消回复