深入了解 Linux 信号

目录

一、什么是 Linux 信号

1.1 信号的定义和作用

1.2 信号的分类和编号

二、Linux 信号的发送和接收

2.1 发送信号的方法

2.2 接收信号的方法

2.3 信号的处理方式

三、信号的处理函数

3.1 信号的默认处理函数

3.2 注册信号处理函数

3.3 信号处理函数的编写技巧

四、信号的处理机制

4.1 信号的信号处理机制

4.2 信号的信号屏蔽机制

4.3 信号的信号队列机制

五、信号的应用场景

5.1 进程间通信

5.2 处理异常

5.3 系统调试

六、Linux 信号的注意事项

6.1 信号的并发安全性

6.2 信号的可靠性

6.3 信号的使用场景限制

引言：Linux 信号是操作系统中的重要组成部分，可以用于进程间通信、处理异常等多种场景。本文将深入介绍 Linux 信号的相关知识，包括信号的定义、类型、发送和接收、处理等内容，帮助读者更好地理解和使用 Linux 信号

一、什么是 Linux 信号

1.1 信号的定义和作用

信号的定义：信号是 Linux 操作系统中用于进程间通信、处理异常等情况的一种机制。它是由操作系统向一个进程或者线程发送的一种异步通知，用于通知该进程或线程某种事件已经发生，需要做出相应的处理。

信号的作用：

1. 进程间通信：进程可以通过向其他进程发送信号的方式进行通信，例如某个进程在完成了某项工作之后，可以向另一个进程发送 SIGUSR1 信号，通知其进行下一步的操作。

2. 处理异常：信号可以被用来处理程序中的异常情况，例如当一个进程尝试访问未分配的内存或者除以 0 时，系统会向该进程发送 SIGSEGV 或 SIGFPE 信号，用于处理这些异常情况。

3. 系统调试：信号可以用于程序的调试，例如在程序运行时，可以向该进程发送 SIGUSR2 信号，用于打印程序的状态信息等。

1.2 信号的分类和编号

在 Linux 中，信号被分类为标准信号和实时信号，每个信号都有一个唯一的编号。标准信号是最基本的信号类型，由整数编号表示，编号范围是 1 到 31。实时信号是 Linux 中的扩展信号类型，由整数编号表示，编号范围是 32 到 64。

下面是常见的信号编号和对应的信号名称：

kill -l可以查看操作系统拥有的信号

需要注意的是，不同的操作系统可能对信号的编号有所不同，因此在跨平台开发时应当注意信号编号的兼容性。

二、Linux 信号的发送和接收

2.1 发送信号的方法

在 Linux 中，进程可以通过向其他进程或自身发送信号的方式进行通信或处理异常情况。下面介绍几种常见的发送信号的方法。

1. kill 命令

kill 命令是 Linux 中最常用的发送信号的命令，语法如下：

kill [-signal] PID

其中，-signal 可选参数表示要发送的信号类型，如果省略该参数，则默认发送 SIGTERM 信号。PID 表示接收信号的进程 ID。

例如，要向进程 ID 123 发送 SIGINT 信号，可以执行以下命令：

kill -SIGINT 123

2. kill 函数

除了使用 kill 命令，程序中也可以通过 kill 函数来发送信号。kill 函数的原型如下：

int kill(pid_t pid, int sig);

其中，pid 表示接收信号的进程 ID，sig 表示要发送的信号类型。如果函数调用成功，则返回 0，否则返回 -1 并设置 errno。

例如，要向进程 ID 123 发送 SIGINT 信号，可以执行以下代码：

#include <signal.h>
#include <unistd.h>

int main() {
  pid_t pid = 123;
  int sig = SIGINT;
  if (kill(pid, sig) == -1) {
    perror("kill");
    return 1;
  }
  return 0;
}

3. raise 函数

raise 函数是一个简单的发送信号的函数，可以用来向当前进程发送信号。raise 函数的原型如下：

int raise(int sig);

其中，sig 表示要发送的信号类型。如果函数调用成功，则返回 0，否则返回 -1 并设置 errno。

例如，要向当前进程发送 SIGTERM 信号，可以执行以下代码：

#include <signal.h>

int main() {
  int sig = SIGTERM;
  if (raise(sig) == -1) {
    perror("raise");
    return 1;
  }
  return 0;
}

4. pthread_kill 函数

如果在多线程程序中需要向另一个线程发送信号，可以使用 pthread_kill 函数。pthread_kill 函数的原型如下：

int pthread_kill(pthread_t thread, int sig);

其中，thread 表示接收信号的线程 ID，sig 表示要发送的信号类型。如果函数调用成功，则返回 0，否则返回错误码。

例如，要向线程 ID 456 发送 SIGUSR1 信号，可以执行以下代码：

#include <pthread.h>
#include <signal.h>

void* thread_func(void* arg) {
  // 线程函数
  return NULL;
}

int main() {
  pthread_t tid = 456;
  int sig = SIGUSR1;
  if (pthread_kill(tid, sig) != 0) {
    perror("pthread_kill");
    return 1;
  }
  return 0;
}

2.2 接收信号的方法

在 Linux 中，进程可以通过注册信号处理函数来接收信号并处理。下面介绍几种常见的接收信号的方法。

1. signal 函数

signal 函数可以用来注册信号处理函数。signal 函数的原型如下：

void (*signal(int sig, void (*handler)(int)))(int);

其中，sig 表示要注册的信号类型，handler 是一个函数指针，指向信号处理函数。signal 函数返回一个函数指针，指向之前注册的信号处理函数。如果注册信号处理函数失败，则返回 SIG_ERR。

例如，要注册 SIGINT 信号的处理函数，可以执行以下代码：

#include <stdio.h>
#include <signal.h>

void sigint_handler(int sig) {
  printf("Received SIGINT signal\n");
}

int main() {
  if (signal(SIGINT, sigint_handler) == SIG_ERR) {
    perror("signal");
    return 1;
  }

  // 程序主逻辑

  return 0;
}

2. sigaction 函数

在Linux中，sigaction函数是用于设置和检索信号处理器的函数。

sigaction函数有以下语法：

#include <signal.h>

int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

其中，sig 表示要注册的信号类型，act 是一个指向 struct sigaction 结构体的指针，表示新的信号处理函数和信号处理选项，oldact 是一个指向 struct sigaction 结构体的指针，用于获取之前注册的信号处理函数和信号处理选项。

struct sigaction 结构体的定义如下：

struct sigaction {
    void (*sa_handler)(int);
    void (*sa_sigaction)(int, siginfo_t *, void *);
    sigset_t sa_mask;
    int sa_flags;
    void (*sa_restorer)(void);
};

其中，sa_handler字段指定信号处理函数的地址。如果设置为SIG_IGN，则表示忽略该信号。如果设置为SIG_DFL，则表示使用默认处理器，也可以自己设置需处理的函数逻辑。

sa_sigaction字段指定一个信号处理器函数，这个函数包含三个参数：一个整数表示信号编号，一个指向siginfo_t结构体的指针，和一个指向void类型的指针。

sa_mask字段指定了在执行信号处理函数期间要阻塞哪些信号。

sa_flags字段是一个标志位，可以包括以下值：

• SA_NOCLDSTOP：如果设置了该标志，则当子进程停止或恢复时不会生成SIGCHLD信号。
• SA_RESTART：如果设置了该标志，则系统调用在接收到信号后将被自动重启。
• SA_SIGINFO：如果设置了该标志，则使用sa_sigaction字段中指定的信号处理器。

sa_restorer字段是一个指向恢复函数的指针，用于恢复某些机器状态。

调用sigaction函数后，如果成功，则返回0，否则返回-1，并设置errno错误号。可以使用以下代码来检查errno：

例如，要注册 SIGINT 信号的处理函数，可以执行以下代码：

#include <stdio.h>
#include <signal.h>

void sigint_handler(int sig) {
  printf("Received SIGINT signal\n");
}

int main() {
  struct sigaction newact = {
     newact.sa_handler = sigint_handler
  };
  struct sigaction oldact;

  if (sigaction(SIGINT, &newact, &oldact) == -1) {
    perror("sigaction");
    return 1;
  }

  // 程序主逻辑

  return 0;
}

在使用sigaction函数之前，应该先定义一个信号处理函数并将其注册。可以使用signal函数来注册一个信号处理函数，但是signal函数在某些情况下可能会出现问题，建议使用sigaction函数来注册信号处理函数。

3. sigwait 函数

sigwait 函数可以用于阻塞等待一个或多个信号，并在信号到达时唤醒。sigwait 函数的原型如下：

int sigwait(const sigset_t* set, int* sig);

其中，set 表示要等待的信号集，sig 是一个指针，用于返回收到的信号编号。

例如，要阻塞等待 SIGINT 信号的到来，可以执行以下代码：

#include <stdio.h>
#include <signal.h>

int main() {
  sigset_t set;
  int sig;

  sigemptyset(&set);
  sigaddset(&set, SIGINT);

  if (sigwait(&set, &sig) == -1) {
    perror("sigwait");
    return 1;
  }

  printf("Received signal: %d\n", sig);

  // 程序主逻辑

  return 0;
}

4. pause 函数

pause 函数可以用于阻塞进程，直到接收到一个信号为止。pause 函数的原型如下：

int pause(void);

例如，要阻塞进程直到接收到 SIGINT 信号为止，可以执行以下代码：

#include <stdio.h>
#include <signal.h>

void sigint_handler(int sig) {
  printf("Received SIGINT signal\n");
}

int main() {
  if (signal(SIGINT, sigint_handler) == SIG_ERR) {
    perror("signal");
    return 1;
  }

  printf("Waiting for SIGINT signal...\n");

  pause();

  // 程序主逻辑

  return 0;
}

以上是几种常见的接收信号的方法，根据不同的需求可以选择合适的方法来注册信号处理函数和接收信号。

2.3 信号的处理方式

在 Linux 中，信号的处理方式一共有三种：忽略信号、执行默认处理函数和执行自定义处理函数。这些处理方式可以通过 signal 函数和 sigaction 函数来设置。

1. 忽略信号

如果将一个信号的处理方式设置为忽略，则当进程接收到该信号时，内核将不做任何处理，直接丢弃该信号。通常情况下，只有少数信号可以被忽略，如 SIGCHLD 信号。忽略信号的方式可以通过 signal 函数来设置，例如：

#include <stdio.h>
#include <signal.h>

int main() {
  if (signal(SIGINT, SIG_IGN) == SIG_ERR) {
    perror("signal");
    return 1;
  }

  printf("Waiting for SIGINT signal...\n");

  // 程序主逻辑

  return 0;
}

在上面的代码中，将 SIGINT 信号的处理方式设置为忽略，当进程接收到 SIGINT 信号时，该信号将被直接丢弃。

2. 执行默认处理函数

每个信号都有一个默认的处理方式，当进程接收到该信号时，内核会执行默认的处理函数。默认的处理函数可以是终止进程、核心转储、停止进程、忽略信号等。

如果想要将一个信号的处理方式设置为默认处理方式，可以通过 signal 函数来设置，例如：

#include <stdio.h>
#include <signal.h>

int main() {
  if (signal(SIGINT, SIG_DFL) == SIG_ERR) {
    perror("signal");
    return 1;
  }

  printf("Waiting for SIGINT signal...\n");

  // 程序主逻辑

  return 0;
}

在上面的代码中，将 SIGINT 信号的处理方式设置为默认处理方式，当进程接收到 SIGINT 信号时，内核将执行默认的处理函数。

3. 执行自定义处理函数

如果想要自定义一个信号的处理方式，可以编写一个信号处理函数，并使用 signal 函数或 sigaction 函数将其注册为该信号的处理函数。当进程接收到该信号时，内核将执行该信号处理函数。

例如，编写一个自定义的 SIGINT 信号处理函数：

#include <stdio.h>
#include <signal.h>

void sigint_handler(int sig) {
  printf("Received SIGINT signal\n");
}

int main() {
  if (signal(SIGINT, sigint_handler) == SIG_ERR) {
    perror("signal");
    return 1;
  }

  printf("Waiting for SIGINT signal...\n");

  // 程序主逻辑

  return 0;
}

在上面的代码中，将 SIGINT 信号的处理方式设置为自定义处理函数 sigint_handler，当进程接收到 SIGINT 信号时，内核将执行该函数。

4. 使用 sigaction 函数设置信号

除了使用 signal 函数外，还可以使用 sigaction 函数来设置信号的处理方式。相比于 signal 函数，sigaction 函数的功能更加强大，可以更细致地控制信号的处理方式，例如可以指定信号处理函数的参数、阻塞其他信号等。

sigaction 函数的函数原型如下：

int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

其中，signum 表示要设置的信号编号；act 表示要设置的信号处理方式；oldact 表示原来的信号处理方式（可以为 NULL，表示不需要保存原来的处理方式）。

sigaction 函数需要一个 struct sigaction 结构体作为参数，该结构体定义如下：

struct sigaction {
  void (*sa_handler)(int);
  void (*sa_sigaction)(int, siginfo_t *, void *);
  sigset_t sa_mask;
  int sa_flags;
  void (*sa_restorer)(void);
};

其中，sa_handler 表示信号处理函数；sa_sigaction 表示信号处理函数的增强版，可以传递更多的参数；sa_mask 表示要在信号处理函数中阻塞的信号集合；sa_flags 表示信号处理的一些标志，例如设置为 SA_RESTART 可以使被信号打断的系统调用自动重启；sa_restorer 表示一个指向恢复函数的指针，通常为 NULL。

下面是一个使用 sigaction 函数设置信号处理方式的示例代码：

#include <stdio.h>
#include <signal.h>

void sigint_handler(int sig) {
  printf("Received SIGINT signal\n");
}

int main() {
  struct sigaction act, oldact;

  act.sa_handler = sigint_handler;
  sigemptyset(&act.sa_mask);
  act.sa_flags = 0;

  if (sigaction(SIGINT, &act, &oldact) < 0) {
    perror("sigaction");
    return 1;
  }

  printf("Waiting for SIGINT signal...\n");

  // 程序主逻辑

  return 0;
}

在上面的代码中，将 SIGINT 信号的处理方式设置为自定义处理函数 sigint_handler，使用了 sigaction 函数来设置。如果设置成功，该函数会返回 0，否则返回 -1。注意，需要使用 sigemptyset 函数来初始化信号集合，以避免阻塞其他信号。如果要还原信号的原来处理方式，可以使用 sigaction 函数，并将 oldact 参数传递给它。

三、信号的处理函数

3.1 信号的默认处理函数

当程序收到一个信号时，如果没有设置该信号的处理函数，则会按照默认的处理方式进行处理。每个信号都有自己的默认处理方式，下面列出了一些常见信号的默认处理方式：

1. SIGHUP：终止进程
2. SIGINT：终止进程
3. SIGQUIT：终止进程，并生成 core dump 文件
4. SIGILL：终止进程，并生成 core dump 文件
5. SIGABRT：终止进程，并生成 core dump 文件
6. SIGFPE：终止进程，并生成 core dump 文件
7. SIGKILL：强制终止进程
8. SIGSEGV：终止进程，并生成 core dump 文件
9. SIGPIPE：终止进程
10. SIGALRM：终止进程
11. SIGTERM：终止进程
12. SIGUSR1：终止进程
13. SIGUSR2：终止进程

注意，有一些信号是不可以被捕获和处理的，例如 SIGKILL 和 SIGSTOP，这两个信号的处理方式无法被改变，只能直接终止进程。

除了上述列举的常见信号，还有一些其他的信号也具有默认的处理方式，如下：

1. SIGBUS：终止进程，并生成 core dump 文件
2. SIGCHLD：忽略该信号，即不进行处理
3. SIGCONT：继续进程，如果进程被挂起，则恢复运行
4. SIGSTOP：暂停进程
5. SIGTSTP：暂停进程，并发送 SIGSTOP 信号给进程组中所有进程
6. SIGTTIN：暂停进程
7. SIGTTOU：暂停进程
8. SIGURG：忽略该信号
9. SIGXCPU：终止进程，并生成 core dump 文件
10. SIGXFSZ：终止进程，并生成 core dump 文件

需要注意的是，在 Linux 中，如果一个进程收到了某个信号，并且该信号的默认处理方式是终止进程，那么这个进程的资源可能不会被完全释放，这时需要进行清理工作，例如关闭文件、释放锁等，以避免资源泄漏

core dump文件的定义

当一个程序在运行时发生严重错误，如访问非法内存地址或除以零等，操作系统会向该程序发送一个信号，通知它出现了一个错误。如果程序没有处理该信号，操作系统会将该程序终止，并将程序的内存映像保存到一个称为 core dump 文件的文件中。

Core dump 文件通常包含程序在崩溃时的内存快照和一些其他有用的调试信息，例如程序的寄存器状态、堆栈跟踪信息和调用栈信息等。这些信息可以帮助程序员在调试时定位错误。

Core dump 文件通常非常大，可以是程序内存使用量的几倍甚至几十倍。因此，在生产环境中，可以通过禁用 core dump 生成来减少磁盘空间的使用。在开发和测试环境中，生成 core dump 文件可以提供有用的调试信息，帮助程序员解决问题。

在Linux系统中，默认情况下，默认是关闭的，core dump 文件被保存在当前工作目录下的名为 core 或者 core.<pid> 的文件中。其中 <pid> 是崩溃程序的进程ID。可以通过 ulimit -c unlimited 命令来打开 core dump 生成。此外，还可以使用 gdb 或其他调试工具来分析 core dump 文件中的信息。

3.2 注册信号处理函数

在 Linux 中，可以通过 signal() 函数或者 sigaction() 函数来注册信号处理函数。

signal() 函数用于注册信号处理函数，其原型如下：

typedef void (*sighandler_t)(int);

sighandler_t signal(int signum, sighandler_t handler);

其中，signum 表示要注册的信号编号，handler 表示信号处理函数的地址。该函数返回一个指向原信号处理函数的指针，如果出现错误，则返回 SIG_ERR。

例如，下面的代码将捕获 SIGINT 信号，并在捕获到信号时打印一条消息：

#include <stdio.h>
#include <signal.h>

void sigint_handler(int signum)
{
    printf("Caught signal %d (SIGINT)\n", signum);
}

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

    while (1) {
        /* do something */
    }

    return 0;
}

sigaction() 函数也用于注册信号处理函数，其原型如下：

int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

其中，signum 表示要注册的信号编号，act 是一个指向 struct sigaction 结构体的指针，用于设置信号处理函数和一些其他选项，oldact 是一个指向 struct sigaction 结构体的指针，用于存储之前的信号处理函数和选项。

struct sigaction 结构体包含以下成员：

struct sigaction {
    void (*sa_handler)(int);
    void (*sa_sigaction)(int, siginfo_t *, void *);
    sigset_t sa_mask;
    int sa_flags;
    void (*sa_restorer)(void);
};

其中，sa_handler 表示信号处理函数的地址，sa_mask 表示信号屏蔽集，sa_flags 表示一些选项，例如是否启用信号排队等。

例如，下面的代码也是将捕获 SIGINT 信号，并在捕获到信号时打印一条消息，但是使用的是 sigaction() 函数：

#include <stdio.h>
#include <signal.h>

void sigint_handler(int signum)
{
    printf("Caught signal %d (SIGINT)\n", signum);
}

int main()
{
    struct sigaction sa;

    sa.sa_handler = sigint_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;

    sigaction(SIGINT, &sa, NULL);

    while (1) {
        /* do something */
    }

    return 0;
}

需要注意的是，在使用 signal() 函数注册信号处理函数时，如果同一个信号被注册了多个处理函数，则只有最后一个处理函数会生效。而在使用 sigaction() 函数注册信号处理函数时，可以指定一些选项，例如是否启用信号排队等。因此，通常情况下，建议使用 sigaction() 函数来注册信号处理函数。

3.3 信号处理函数的编写技巧

编写信号处理函数需要注意一些技巧，下面是一些建议：

1. 简洁明了：信号处理函数应该尽量简短，只包含必要的操作，并且不能阻塞太长时间，否则可能会影响系统的稳定性。

2. 不要调用不可重入函数：因为信号处理函数是在异步上下文中执行的，不能保证当前进程处于什么状态，如果在信号处理函数中调用了不可重入函数，可能会导致死锁等问题。

3. 保证对共享数据的访问安全：如果信号处理函数需要访问共享数据，必须保证访问的安全性，通常可以使用互斥锁等机制来保护共享数据。

4. 不要在信号处理函数中使用动态分配内存：因为信号处理函数是在异步上下文中执行的，不能保证当前进程处于什么状态，如果在信号处理函数中使用动态分配内存，可能会导致内存泄漏等问题。

5. 使用 sigaction() 函数注册信号处理函数：相比于 signal() 函数，sigaction() 函数提供了更多的选项，例如是否启用信号排队等，更加灵活。

6. 在信号处理函数中尽量不要进行 IO 操作：因为 IO 操作是阻塞的，如果在信号处理函数中进行 IO 操作，可能会导致信号排队等问题。

7. 在信号处理函数中不要使用 printf() 等标准 IO 函数：因为这些函数是不可重入的，可能会导致死锁等问题。

8. 可以使用 siglongjmp() 函数来进行非局部跳转：在一些情况下，需要从信号处理函数中跳转到某个特定位置，可以使用 siglongjmp() 函数来实现非局部跳转。

总之，在编写信号处理函数时需要注意保证代码的简洁明了，尽可能避免使用不可重入函数，保证对共享数据的访问安全，尽量不进行 IO 操作，使用 sigaction() 函数注册信号处理函数等。

四、信号的处理机制

4.1 信号的信号处理机制

Linux 中的信号处理机制是基于异步事件的。当一个进程接收到一个信号时，内核会向该进程发送一个信号事件，即向该进程的信号处理函数发送一个回调通知，以处理该信号。信号处理机制的流程如下：

1. 内核检测到进程接收到一个信号，然后向该进程发送一个信号事件。

2. 该进程在收到信号事件后，根据注册的信号处理函数进行回调。

3. 如果该进程没有为该信号注册信号处理函数，则会采取默认的处理方式，例如终止进程或忽略信号等。

4. 在信号处理函数中，可以对信号进行处理，例如清理资源、跳转到其他代码区域、修改程序的状态等。

5. 一旦信号处理函数执行完成，进程将恢复执行原来的代码。

6. 对于某些信号，可以通过信号处理函数的返回值来控制进程的行为。例如，如果在 SIGTERM 信号处理函数中返回 0，则表示该进程已经准备好退出，可以正常终止进程。如果返回非零值，则表示该进程尚未准备好退出，内核会继续向该进程发送 SIGTERM 信号，直到进程返回 0 或接收到 SIGKILL 信号强制终止。

7. 在信号处理函数中，应该尽量不使用系统调用。因为一些系统调用可能会阻塞进程，导致信号处理函数的执行时间过长。如果必须要使用系统调用，可以使用一些异步的、非阻塞的系统调用，例如 epoll 或者非阻塞 I/O 等。

8. 当信号处理函数正在执行时，进程可能会接收到同一个信号。如果信号处理函数中还没有完成对该信号的处理，内核会将该信号放入挂起信号队列中，并等待信号处理函数返回后再次触发信号处理函数。因此，信号处理函数应该尽可能的快速执行完，并尽快退出。

需要注意的是，Linux 中的信号处理机制是基于异步事件的，因此信号处理函数的执行是不可预测的。在信号处理函数中，应该尽可能避免使用不可重入函数，避免访问共享数据等可能导致死锁或其他问题的操作。同时，也应该尽可能简短，以免阻塞进程的正常运行。

4.2 信号的信号屏蔽机制

Linux 中的信号屏蔽机制是用于控制进程哪些信号可以被接收和哪些信号应该被阻塞的。当一个进程收到一个信号时，内核会检查该信号是否被屏蔽。如果该信号被屏蔽，则会将该信号放入挂起信号队列中，等待该信号被解除屏蔽后再次触发信号处理函数。信号屏蔽机制的主要作用是保护进程免受不必要的干扰和损失。

sigprocmask()函数

Linux 中的信号屏蔽机制可以通过 sigprocmask() 系统调用来实现。sigprocmask() 函数用于设置进程的信号屏蔽字，可以通过该函数将一组信号添加到信号屏蔽字中或从信号屏蔽字中移除一组信号。以下是一些常用的信号屏蔽相关的函数：

sigprocmask()是一个系统调用，用于设置和修改当前进程的信号屏蔽集。在信号处理程序运行期间，为避免在处理一个信号时被另一个信号打断，可以将某些信号添加到进程的信号屏蔽集中。

sigprocmask()函数的原型为：

int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

1. sigprocmask(int how, const sigset_t *set, sigset_t *oldset)：用于设置进程的信号屏蔽字。how 参数指定了对信号屏蔽字的修改方式，可以是以下三个值之一：

• SIG_BLOCK：将 set 中的信号添加到进程的信号屏蔽字中。
• SIG_UNBLOCK：将 set 中的信号从进程的信号屏蔽字中移除。
• SIG_SETMASK：将进程的信号屏蔽字设置为 set 中的信号。

set参数是一个指向sigset_t类型的指针，它指向要添加、删除或设置的信号集。oldset参数是一个指向sigset_t类型的指针，用于保存旧的信号屏蔽集。

sigset_t类型是一个用于保存信号集的数据类型。它是一个位掩码，每个位表示一个信号，如果该位被设置，则表示该信号被阻塞。可以使用以下函数来操作sigset_t类型：

1. sigemptyset(sigset_t *set)：用于清空信号集合。

2. sigfillset(sigset_t *set)：用于向信号集合中添加所有的信号。

3. sigaddset(sigset_t *set, int signum)：用于向信号集合中添加一个信号。

4. sigdelset(sigset_t *set, int signum)：用于从信号集合中删除一个信号。

5. sigismember(const sigset_t *set, int signum)：用于判断一个信号是否在信号集合中。

需要注意的是，在修改进程的信号屏蔽字时，需要保证进程的原子性。通常情况下，我们可以使用 sigprocmask() 函数来设置和获取进程的信号屏蔽字，以确保修改信号屏蔽字的操作是原子性的。此外，在信号处理函数中，如果需要屏蔽某些信号，可以使用 sigfillset() 或 sigaddset() 函数将这些信号添加到进程的信号屏蔽字中，以保护信号处理函数的执行。

信号屏蔽机制还有一个重要的特性是信号的排队。当一个信号被发送到一个进程时，如果该信号已经在进程的信号队列中等待处理，那么该信号会被排队，并在信号处理函数执行完毕后依次触发。信号排队机制的作用是保证信号不会丢失，确保进程能够正常处理所有接收到的信号。

在 Linux 中，信号队列是由内核维护的。当进程收到一个信号时，内核会将该信号添加到进程的信号队列中，并为该信号创建一个 siginfo 结构体，用于记录该信号的相关信息，例如信号的发送者、信号的发送时间等。当信号处理函数执行完毕后，内核会将该信号从信号队列中删除，并且将该信号对应的 siginfo 结构体传递给信号处理函数。

需要注意的是，如果多个相同类型的信号被发送到进程中，并且它们在信号处理函数执行之前被排队，那么只会有一个信号被触发，其他的信号将被忽略。这种情况下，进程只会收到一个信号，而不是多个信号。

总之，信号屏蔽机制和信号排队机制是 Linux 中非常重要的机制，可以帮助进程管理信号的接收和处理，确保进程能够正常地运行，并且避免信号的丢失和混乱。理解和掌握信号屏蔽机制和信号排队机制对于开发高可靠性的 Linux 程序非常重要。

4.3 信号的信号队列机制

在Linux中，每个进程都有一个信号队列，用于存放向该进程发送的信号。当一个信号到达进程时，内核会检查进程是否阻塞该信号，如果没有阻塞，则将信号添加到进程的信号队列中。如果该信号已经在队列中等待处理，则不会再次添加。

每个进程的信号队列大小是有限制的。可以通过 ulimit 命令查看当前进程的信号队列大小限制。默认情况下，该限制为 8192。如果队列已满，新的信号将被静默地丢弃。

信号队列中的每个信号都有一个相关的数据结构 siginfo_t，其中包含了信号的信息，如信号的类型、发送者的 PID、时间戳等。当信号从队列中被取出时，该数据结构将被传递给信号处理函数。

在处理信号时，如果多个相同类型的信号被排队等待处理，只会有一个信号被处理，其余信号将被忽略。因此，在编写信号处理函数时，应该确保处理所有等待的信号。可以使用 sigaction 函数的 SA_SIGINFO 标志来获取队列中所有排队的信号。

信号队列的实现细节因操作系统而异，但通常使用循环队列的方式实现。在处理信号队列时，内核会根据信号的优先级和进程的调度策略来决定下一个要处理的信号。例如，如果有多个优先级较高的信号等待处理，内核可能会先处理它们，而暂时忽略优先级较低的信号。

总之，信号队列是 Linux 中非常重要的机制，用于存放进程接收到的信号，并确保它们按照正确的顺序处理。了解信号队列的工作原理和实现细节可以帮助开发者编写更可靠和高效的 Linux 程序。

五、信号的应用场景

5.1 进程间通信

进程间通信（IPC）是操作系统中一个重要的概念，用于在不同进程之间传递数据和信息。Linux 中信号是一种简单而有效的进程间通信机制，可以用于在进程之间传递简短的消息或通知，如进程的启动、停止、异常情况等。

下面是一些使用信号进行进程间通信的常见场景：

        1、进程的启动和停止

父进程可以使用 kill 函数向子进程发送 SIGTERM 信号来请求它停止运行。子进程可以安装一个信号处理函数，在接收到 SIGTERM 信号时优雅地退出，释放所有资源并保存状态。

        2、进程的状态同步

进程可以使用信号来向其他进程发送状态信息，如进程的健康状态、运行状态、异常情况等。接收进程可以根据收到的信号来作出相应的处理，如启动或停止某些操作，修改自己的状态等。

        3、进程间的协同操作

两个或多个进程可以使用信号进行协同操作，如互相通知对方某些事件的发生、请求对方执行某些操作等。在这种场景下，进程可以使用不同的信号来表示不同的事件或请求，接收进程可以根据信号类型来确定下一步的操作。

        4、进程的异常处理

当进程遇到异常情况时，如内存溢出、除以零等，可以使用信号来向其他进程发送异常信息。接收进程可以根据收到的信号来记录异常信息，生成错误报告等。

总之，信号是 Linux 中一种轻量级、高效的进程间通信机制，可用于实现各种类型的通信和协同操作。但是需要注意的是，由于信号本质上是异步事件，处理信号时需要谨慎，以避免出现竞态条件和数据不一致的问题。

5.2 处理异常

Linux 中的信号机制可以用于处理各种异常情况，如程序执行过程中的错误、非法操作、内存溢出等。在遇到这些异常情况时，系统会向进程发送相应的信号，进程可以安装信号处理函数来捕获并处理这些信号，以避免程序崩溃或出现严重错误。

下面是一些使用信号处理异常的常见场景：

        1、程序崩溃处理

当程序出现异常情况时，如空指针访问、内存溢出等，系统会向进程发送 SIGSEGV 或 SIGABRT 信号，进程可以安装信号处理函数来捕获这些信号，打印出错信息、保存程序状态，最终退出程序或进行恢复操作。

        2、非法操作处理

进程可以使用信号来捕获非法操作，如非法指令、非法访问等。在接收到这些信号时，进程可以使用信号处理函数来打印错误信息、终止程序或进行其他处理。

        3、系统资源不足处理

当系统资源不足时，如内存不足、文件打开数达到最大限制等，系统会向进程发送相应的信号，进程可以使用信号处理函数来释放资源、减少内存使用、关闭文件等，以避免系统崩溃。

        4、进程间通信错误处理

当进程间通信出现错误时，如通信超时、通信失败等，进程可以使用信号来捕获这些错误，打印错误信息、重新发送数据等。

总之，信号机制是 Linux 中一种非常有效的处理异常情况的方式，可以用于捕获各种类型的异常、进行错误处理、保护系统安全等。在编写程序时，需要注意对各种异常情况的处理，及时捕获信号并进行相应的处理，以提高程序的稳定性和可靠性。

5.3 系统调试

信号机制在 Linux 系统调试中也扮演着重要的角色，可以用于在程序运行过程中提供调试信息、打印错误信息、检测程序状态等。

下面是一些使用信号进行系统调试的常见场景：

        1、调试信息输出

程序中可以使用信号来输出调试信息，如程序当前状态、变量值、函数调用堆栈等。在程序运行时，可以通过键盘或其他程序向进程发送信号，进程会捕获并输出相应的调试信息，方便进行程序调试。

        2、断点调试

可以使用信号来实现断点调试，当程序执行到断点处时，进程会收到 SIGTRAP 信号，此时可以打印调试信息、暂停程序执行等操作。

        3、性能分析

在程序运行过程中，可以使用信号来记录程序运行时间、函数调用次数、内存使用情况等信息，以进行性能分析和优化。

        4、检测程序状态

在程序运行过程中，可以使用信号来检测程序状态，如检测程序是否处于死循环、是否卡死等。当程序出现异常情况时，可以向进程发送相应的信号，进程可以捕获并输出错误信息、暂停程序等，方便进行调试和修复。

总之，信号机制在 Linux 系统调试中非常有用，可以提供丰富的调试信息、实现灵活的断点调试、记录程序状态等，方便程序员进行调试和优化。在编写程序时，需要适时地使用信号机制，为程序调试和优化提供有力支持。

六、Linux 信号的注意事项

6.1 信号的并发安全性

信号的并发安全性是指在多线程或多进程环境下，使用信号机制时需要注意的问题，以保证程序的正确性和稳定性。

首先，需要注意信号的可重入性问题。可重入性是指当信号处理函数被中断时，可以安全地再次调用该函数，而不会引起死锁或其他问题。因此，在编写信号处理函数时，需要确保函数不会使用任何静态或全局变量，并且不会进行动态内存分配等可能会引起竞态条件的操作。

其次，需要注意信号的并发处理问题。在多线程或多进程环境下，如果多个线程或进程同时向同一个进程发送信号，那么这些信号将会交叉处理，可能会引起竞态条件或死锁等问题。因此，需要使用信号屏蔽机制或者其他同步机制来保证信号的顺序性和唯一性。

还需要注意信号的可靠性问题。信号是一种异步通信机制，发送方不能保证接收方一定能收到信号。在信号处理函数中，需要注意检查信号是否真正被接收并处理，以避免出现错误或不确定性的情况。

此外，还需要注意信号的阻塞和解除阻塞机制。在使用信号屏蔽机制时，需要注意信号的阻塞和解除阻塞顺序，以避免出现死锁或不确定性的情况。通常情况下，应该避免在信号处理函数中阻塞同一个信号，因为这可能会导致死锁。

在多线程或多进程环境下，可以使用pthread_sigmask()函数来控制信号的屏蔽和解除屏蔽。该函数可以设置一个信号掩码，指定需要屏蔽的信号，并且在信号处理函数中自动解除该信号的屏蔽。使用该函数可以有效地避免信号的竞态条件和死锁问题。

另外，需要注意在使用信号时，尽可能避免在信号处理函数中进行长时间的操作，因为这可能会阻塞其他信号的处理和程序的正常运行。如果必须进行长时间的操作，可以考虑将操作放在另外一个线程或进程中进行，以避免对信号处理和程序的影响。

总之，在多线程或多进程环境下使用信号机制时，需要注意信号的并发安全性，特别是信号的可重入性、并发处理、可靠性、阻塞和解除阻塞等问题。合理地使用信号屏蔽机制和其他同步机制，可以有效地避免竞态条件、死锁和其他并发问题，确保程序的正确性和稳定性。

6.2 信号的可靠性

信号的可靠性是指信号在发送和接收过程中的正确性和可靠性。在 Linux 中，信号是异步的，即信号的发送和接收并不是同步的。这意味着，当一个进程发送信号时，不能保证信号能够立即被接收方处理。信号的可靠性是指，在发送和接收过程中，能够保证信号能够正确地被接收和处理，不会丢失或重复。

Linux 中的信号机制是基于内核的，当一个信号被发送到进程时，内核会将信号的信息保存在进程的信号队列中。如果进程当前没有阻塞该信号，并且进程正在执行一个非信号处理函数的代码段，则内核会将信号递送给进程，即调用该信号对应的信号处理函数。否则，进程会在下一次执行非信号处理函数的代码段时，检查信号队列并处理所有等待的信号。

在信号的发送和接收过程中，有一些情况会导致信号的不可靠性，例如信号的丢失和重复。信号的丢失是指当进程处理一个信号时，如果此时有一个相同的信号被发送到该进程，但是该信号被忽略了，导致该信号被丢失。信号的重复是指当进程处理一个信号时，如果此时有一个相同的信号被发送到该进程，并且该信号在处理前已经被加入到信号队列中，则该信号会被重复处理。

为了避免信号的不可靠性，可以采取以下措施：

        1、信号队列机制

当进程被信号中断时，如果同类型的信号还没有被处理，就会将该信号添加到进程的信号队列中，等待进程处理完当前信号后再依次处理队列中的信号。这种机制可以保证同一类型的信号不会重复到达。

        2、信号屏蔽机制

进程可以通过设置信号屏蔽字来阻塞一些信号的传递，以避免在处理信号时被其他信号中断。当信号屏蔽被解除时，被屏蔽的信号将会被发送给进程，保证了信号的顺序性。

        3、可重入函数

在信号处理函数中尽可能使用可重入函数，以避免由于信号处理函数在执行时被中断而导致的数据竞争和死锁问题。

总之，信号的可靠性是保证 Linux 程序正确性和稳定性的重要因素。为了保证信号的可靠性，需要合理使用信号机制，并且注意信号的并发安全性、可重入性和信号的阻塞和解除阻塞等问题，以避免信号的丢失和重复等问题。

6.3 信号的使用场景限制

尽管信号在 Linux 系统中具有广泛的应用场景，但它的使用也受到一些限制，主要体现在以下几个方面：

        1、信号是异步的

由于信号是异步的，信号处理程序可能会在任何时刻被中断或被其他信号所替换，这就给信号处理程序的设计和实现带来了一定的挑战。因此，在处理信号时需要特别小心，尽量避免使用不可重入的函数和进行长时间的计算操作。

        2、信号数量有限

Linux 系统中的信号数量是有限制的，一般情况下，系统最多支持 64 种不同的信号。由于信号种类数量的限制，可能导致在一些复杂应用场景下无法实现更多的功能。

        3、信号不可靠

信号的不可靠性是指在信号发送和接收的过程中，可能会出现信号丢失或信号重复的情况。虽然 Linux 系统提供了一些机制来保证信号的可靠性，但是这些机制也会增加一些复杂性。

        4、信号不支持传递参数

与其他进程间通信方式不同，信号不能传递参数，因此在使用信号进行进程间通信时，需要通过其他的方式来传递数据。

        5、信号的发送有限制

在发送信号时，需要具有足够的权限。例如，只有具有相应权限的进程才能向特定进程发送信号。

综上所述，虽然信号在 Linux 系统中具有广泛的应用场景，但是它的使用场景也受到一些限制。在实际应用中，需要根据具体的情况选择合适的进程间通信方式，以满足应用需求。

结论：Linux 信号作为操作系统中的重要组成部分，在多种场景中都有广泛的应用。了解 Linux 信号的相关知识对于系统程序员和应用程序员都非常重要。本文从信号的定义、发送和接收、处理、处理函数、处理机制、应用场景等多个方面进行了介绍，希望能够帮助读者更好地理解和使用 Linux 信号。文章来源地址https://www.toymoban.com/news/detail-774615.html

到了这里，关于深入了解 Linux 信号的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！