8、Linux C 信号机制

已于 2025-03-31 12:16:38 修改
阅读量1k 收藏 29
点赞数 21
分类专栏： LinuxC 文章标签： linux c语言 运维
于 2025-03-29 18:35:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_66405876/article/details/146704851
版权

一、信号概述

1. 信号概念

信号是一种在软件层次上对中断机制的模拟，是一种异步通信方式。信号的产生和处理都由操作系统内核完成，用于在进程之间传递信息或通知某些事件的发生。

2. 信号的产生

信号可以通过以下方式产生：

  1. 按键产生：例如用户按下Ctrl-C产生SIGINT信号，按下Ctrl-\产生SIGQUIT信号。

  2. 系统调用函数产生：例如kill、raise等函数。

  3. 硬件异常：例如非法指令、除以零等。

  4. 命令行产生：例如使用kill命令向进程发送信号。

  5. 软件条件：例如访问非法内存、管道写入端关闭等。

3. 信号处理方式

信号可以有以下几种处理方式：

  1. 缺省方式：执行系统默认的动作。

  2. 忽略信号：对信号不做任何处理。

  3. 捕捉信号：通过自定义函数处理信号。

二、常用信号

信号名含义默认操作
SIGHUP用户终端关闭时产生，发给与终端关联的会话内的所有进程终止
SIGINT用户键入Ctrl-C时产生，发送给当前终端的所有前台进程终止
SIGQUIT用户键入Ctrl-\时产生，与SIGINT类似终止
SIGILL进程企图执行非法指令时产生终止
SIGSEGV非法访问内存时产生，如野指针、缓冲区溢出终止
SIGPIPE进程往没有读端的管道中写入时产生，代表“管道断裂”终止
SIGKILL用来结束进程，不能被捕捉和忽略终止
SIGSTOP暂停进程，不能被捕捉和忽略暂停进程
SIGTSTP用户键入Ctrl-Z时产生，用于暂停进程暂停进程
SIGCONT让暂停的进程继续运行继续运行
SIGALRM定时器时间到时产生终止
SIGUSR1保留给用户程序使用的信号终止
SIGUSR2保留给用户程序使用的信号终止
SIGCHLD子进程状态改变时发给父进程忽略

三、信号相关函数

1. kill函数

函数介绍
#include <sys/types.h>
#include <signal.h>
​
int kill(pid_t pid, int sig);

  • 参数：

    • pid：目标进程的进程ID。

      • > 0：发送信号给指定进程。

      • = 0：发送信号给与调用进程处于同一进程组的所有进程。

      • < -1：发送信号给该进程组的所有进程。

      • = -1：发送信号给所有有权限发送信号的进程。

    • sig：要发送的信号编号。

  • 返回值：成功时返回0，失败时返回-1。

  • 作用：向指定进程发送信号。

示例代码
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
​
int main() {
    pid_t pid = 1234; // 假设目标进程ID为1234
    if (kill(pid, SIGINT) < 0) {
        perror("kill");
        return -1;
    }
    printf("信号已发送到进程 %d\n", pid);
    return 0;
}

2. raise函数

函数介绍
#include <signal.h>
​
int raise(int sig);

  • 参数：

    • sig：要发送的信号编号。

  • 返回值：成功时返回0，失败时返回非0值。

  • 作用：向调用进程自身发送信号。

示例代码
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
​
void handle(int sig) {
    printf("捕获到信号 %d\n", sig);
}
​
int main() {
    signal(SIGINT, handle); // 设置SIGINT的处理函数
    raise(SIGINT); // 向自身发送SIGINT信号
    while (1) {
        sleep(1);
    }
    return 0;
}

3. alarm函数

函数介绍
#include <unistd.h>
​
unsigned int alarm(unsigned int seconds);

  • 参数：

    • seconds：定时时间，单位为秒。如果seconds为0，则清除之前设置的定时器。

  • 返回值：返回上次设置的定时器剩余时间（秒）。如果之前没有设置定时器，则返回0。

  • 作用：设置一个定时器，定时结束后向进程发送SIGALRM信号。

示例代码
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
​
void handle(int sig) {
    printf("定时器信号捕获到\n");
}
​
int main() {
    signal(SIGALRM, handle); // 设置SIGALRM的处理函数
    alarm(5); // 设置5秒后发送SIGALRM信号
    while (1) {
        sleep(1);
    }
    return 0;
}

4. ualarm函数

函数介绍
#include <unistd.h>
​
useconds_t ualarm(useconds_t usecs, useconds_t interval);

  • 参数：

    • usecs：第一次定时的时间，单位为微秒。

    • interval：触发后的间隔时间，单位为微秒。如果interval不为0，则定时器会周期性触发。

  • 返回值：返回上次设置的定时器剩余时间（微秒）。如果之前没有设置定时器，则返回0。

  • 作用：设置一个微秒级的定时器，定时结束后向进程发送SIGALRM信号，并可以设置定时器的间隔时间。

示例代码
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
​
void handle(int sig) {
    printf("定时器信号捕获到\n");
}
​
int main() {
    signal(SIGALRM, handle); // 设置SIGALRM的处理函数
    ualarm(5000000, 1000000); // 5秒后发送SIGALRM信号，之后每隔1秒发送一次
    while (1) {
        sleep(1);
    }
    return 0;
}

5. setitimer函数

函数介绍
#include <sys/time.h>
​
int setitimer(int which, const struct itimerval *new_value, struct itimerval *old_value);

  • 参数：

    • which：定时器类型。

      • ITIMER_REAL：以实际时间计时，发送SIGALRM信号。

      • ITIMER_VIRTUAL：以用户态运行时间计时，发送SIGVTALRM信号。

      • ITIMER_PROF：以用户态和内核态运行时间计时，发送SIGPROF信号。

    • new_value：指向新的定时器值的结构体。

    • old_value：指向存储旧的定时器值的结构体（可选）。

  • 结构体itimerval：

    • struct timeval it_interval：定时器的间隔时间。

    • struct timeval it_value：定时器的初始时间。

  • 结构体timeval：

    • time_t tv_sec：秒。

    • suseconds_t tv_usec：微秒。

  • 返回值：成功时返回0，失败时返回-1。

  • 作用：设置一个间隔定时器。

示例代码
#include <stdio.h>
#include <signal.h>
#include <sys/time.h>
#include <unistd.h>
​
void handle(int sig) {
    printf("定时器信号捕获到\n");
}
​
int main() {
    struct itimerval timer;
    timer.it_interval.tv_sec = 1;
    timer.it_interval.tv_usec = 0;
    timer.it_value.tv_sec = 5;
    timer.it_value.tv_usec = 0;
​
    signal(SIGALRM, handle); // 设置SIGALRM的处理函数
    setitimer(ITIMER_REAL, &timer, NULL); // 设置定时器
    while (1) {
        sleep(1);
    }
    return 0;
}

6. signal函数

函数介绍
#include <signal.h>
​
typedef void (*sighandler_t)(int);
​
sighandler_t signal(int signum, sighandler_t handler);

  • 参数：

    • signum：要设置的信号编号。

    • handler：信号处理函数。

      • SIG_DFL：恢复为默认处理方式。

      • SIG_IGN：忽略信号。

      • 其他：自定义处理函数。

  • 返回值：成功时返回之前的信号处理函数，失败时返回SIG_ERR。

  • 作用：设置信号处理方式。

示例代码
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
​
void handle(int sig) {
    printf("捕获到信号 %d\n", sig);
}
​
int main() {
    signal(SIGINT, handle); // 设置SIGINT的处理函数
    while (1) {
        sleep(1);
    }
    return 0;
}

7. sigaction函数

函数介绍
#include <signal.h>
​
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

  • 参数：

    • signum：要设置的信号编号。

    • act：指向新的信号处理方式的结构体。

    • oldact：指向存储旧的信号处理方式的结构体（可选）。

  • 结构体sigaction：

    • void (*sa_handler)(int)：信号处理函数。

    • void (*sa_sigaction)(int, siginfo_t *, void *)：支持传递额外信息的信号处理函数。

    • sigset_t sa_mask：在信号处理函数执行期间需要屏蔽的信号集。

    • int sa_flags：信号处理标志。

      • SA_SIGINFO：使用sa_sigaction成员而不是sa_handler作为信号处理函数。

      • SA_RESTART：使被信号打断的系统调用自动重新发起。

      • SA_RESETHAND：信号处理之后重新设置为默认的处理方式。

      • SA_NODEFER：使对信号的屏蔽无效，即在信号处理函数执行期间仍能发出这个信号。

    • void (*sa_restorer)(void)：已废弃。

  • 返回值：成功时返回0，失败时返回-1。

  • 作用：设置信号处理方式，功能比signal更强大。

示例代码
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
​
void handle(int sig) {
    printf("捕获到信号 %d\n", sig);
}
​
int main() {
    struct sigaction act;
    act.sa_handler = handle;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
​
    sigaction(SIGINT, &act, NULL); // 设置SIGINT的处理方式
    while (1) {
        sleep(1);
    }
    return 0;
}

四、信号集操作函数

1. sigemptyset函数

函数介绍
#include <signal.h>
​
int sigemptyset(sigset_t *set);

  • 参数：

    • set：指向信号集的指针。

  • 返回值：成功时返回0，失败时返回-1。

  • 作用：清空信号集。

示例代码
#include <stdio.h>
#include <signal.h>
​
int main() {
    sigset_t set;
    sigemptyset(&set); // 清空信号集
    return 0;
}

2. sigfillset函数

函数介绍
#include <signal.h>
​
int sigfillset(sigset_t *set);

  • 参数：

    • set：指向信号集的指针。

  • 返回值：成功时返回0，失败时返回-1。

  • 作用：将信号集中的所有信号都设置为1。

示例代码
#include <stdio.h>
#include <signal.h>
​
int main() {
    sigset_t set;
    sigfillset(&set); // 填充信号集
    return 0;
}

3. sigaddset函数

函数介绍
#include <signal.h>
​
int sigaddset(sigset_t *set, int signum);

  • 参数：

    • set：指向信号集的指针。

    • signum：要添加到信号集中的信号编号。

  • 返回值：成功时返回0，失败时返回-1。

  • 作用：将指定信号添加到信号集中。

示例代码
#include <stdio.h>
#include <signal.h>
​
int main() {
    sigset_t set;
    sigemptyset(&set);
    sigaddset(&set, SIGINT); // 添加SIGINT到信号集
    return 0;
}

4. sigdelset函数

函数介绍
#include <signal.h>
​
int sigdelset(sigset_t *set, int signum);

  • 参数：

    • set：指向信号集的指针。

    • signum：要从信号集中移除的信号编号。

  • 返回值：成功时返回0，失败时返回-1。

  • 作用：从信号集中移除指定的信号。

示例代码
#include <stdio.h>
#include <signal.h>
​
int main() {
    sigset_t set;
    sigfillset(&set);
    sigdelset(&set, SIGINT); // 从信号集中移除SIGINT
    return 0;
}

5. sigismember函数

函数介绍
#include <signal.h>
​
int sigismember(const sigset_t *set, int signum);

  • 参数：

    • set：指向信号集的指针。

    • signum：要检查的信号编号。

  • 返回值：

    • 如果信号在信号集中，返回1。

    • 如果信号不在信号集中，返回0。

    • 如果出错，返回-1。

  • 作用：检查指定信号是否在信号集中。

示例代码
#include <stdio.h>
#include <signal.h>
​
int main() {
    sigset_t set;
    sigemptyset(&set);
    sigaddset(&set, SIGINT);
​
    if (sigismember(&set, SIGINT)) {
        printf("SIGINT在信号集中。\n");
    } else {
        printf("SIGINT不在信号集中。\n");
    }
​
    return 0;
}

五、信号的阻塞与挂起

1. sigprocmask函数

函数介绍
#include <signal.h>
​
int sigprocmask(int how, const sigset_t *set, sigset_t *oset);

  • 参数：

    • how：指定如何修改当前信号屏蔽字。

      • SIG_BLOCK：将set中的信号添加到当前信号屏蔽字中。

      • SIG_UNBLOCK：从当前信号屏蔽字中移除set中的信号。

      • SIG_SETMASK：将当前信号屏蔽字设置为set中的信号。

    • set：指向新的信号屏蔽集的指针。

    • oset：指向存储旧的信号屏蔽集的指针（可选）。

  • 返回值：成功时返回0，失败时返回-1。

  • 作用：设置或获取进程的信号屏蔽字。

示例代码
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
​
void handle(int sig) {
    printf("捕获到信号 %d\n", sig);
}
​
int main() {
    sigset_t set;
​
    sigemptyset(&set);
    sigaddset(&set, SIGINT);
​
    signal(SIGINT, handle);
​
    sigprocmask(SIG_BLOCK, &set, NULL); // 阻塞SIGINT信号
    sleep(5); // 在这5秒内，SIGINT信号会被阻塞
​
    sigprocmask(SIG_UNBLOCK, &set, NULL); // 解除SIGINT信号的阻塞
​
    while (1) {
        sleep(1);
    }
    return 0;
}

2. pause函数

函数介绍
#include <unistd.h>
​
int pause(void);

  • 返回值：总是返回-1，并设置errno为EINTR。

  • 作用：使进程挂起，直到接收到信号为止。

示例代码
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
​
void handle(int sig) {
    printf("捕获到信号 %d\n", sig);
}
​
int main() {
    signal(SIGINT, handle);
​
    printf("进程已挂起。按Ctrl-C继续。\n");
    pause(); // 挂起进程
    printf("进程已恢复。\n");
    return 0;
}

3. sigsuspend函数

函数介绍
#include <signal.h>
​
int sigsuspend(const sigset_t *sigmask);

  • 参数：

    • sigmask：指向信号屏蔽集的指针。

  • 返回值：总是返回-1，并设置errno为EINTR。

  • 作用：将进程的信号屏蔽字设置为sigmask，然后挂起进程，直到接收到信号为止。

示例代码
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
​
void handle(int sig) {
    printf("捕获到信号 %d\n", sig);
}
​
int main() {
    sigset_t set;
​
    sigemptyset(&set);
    sigaddset(&set, SIGINT);
​
    signal(SIGINT, handle);
​
    printf("进程已挂起。按Ctrl-C继续。\n");
    sigsuspend(&set); // 挂起进程
    printf("进程已恢复。\n");
    return 0;
}

六、使用SIGCHLD信号回收子进程

1. SIGCHLD信号

SIGCHLD信号在以下情况下产生：

  1. 子进程终止。

  2. 子进程接收到SIGSTOP信号而暂停。

  3. 子进程从暂停状态被唤醒。

父进程可以通过捕捉SIGCHLD信号来回收子进程，避免产生僵尸进程。

示例代码
#include <stdio.h>
#include <signal.h>
#include <sys/wait.h>
#include <unistd.h>
​
void handle(int sig) {
    wait(NULL); // 回收子进程
    printf("子进程已终止。信号 %d 收到。\n", sig);
}
​
int main() {
    pid_t pid;
​
    struct sigaction act;
    act.sa_handler = handle;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    sigaction(SIGCHLD, &act, NULL); // 设置SIGCHLD的处理函数
​
    pid = fork();
    if (pid > 0) {
        // 父进程
        while (1) {
            printf("父进程正在运行。PID: %d\n", getpid());
            sleep(1);
        }
    } else if (pid == 0) {
        // 子进程
        printf("子进程正在运行。PID: %d\n", getpid());
        sleep(5);
        exit(0);
    }
​
    return 0;
}

七、定时器的实现

1. alarm函数

alarm函数用于设置一个定时器，当定时时间到达时，系统会向进程发送SIGALRM信号。

函数原型：

#include <unistd.h>
​
unsigned int alarm(unsigned int seconds);

参数：

  • seconds：定时时间，单位为秒。如果seconds为0，则清除之前设置的定时器。

返回值：

  • 返回上次设置的定时器剩余时间（秒）。如果之前没有设置定时器，则返回0。

示例代码：

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
​
void handle_sigalrm(int sig) {
    printf("定时器信号捕获到\n");
    alarm(1); // 重新设置定时器，实现周期性触发
}
​
int main() {
    signal(SIGALRM, handle_sigalrm);
​
    alarm(1); // 设置1秒后触发定时器
​
    printf("等待定时器信号...\n");
    while (1) {
        pause();
    }
​
    return 0;
}

2. ualarm函数

ualarm函数用于设置一个微秒级的定时器，当定时时间到达时，系统会向进程发送SIGALRM信号。它可以设置一次性定时器或周期性定时器。

函数原型：

#include <unistd.h>
​
useconds_t ualarm(useconds_t usecs, useconds_t interval);

参数：

  • usecs：首次触发的时间，单位为微秒。

  • interval：触发后的间隔时间，单位为微秒。如果interval不为0，则定时器会周期性触发。

返回值：

  • 返回上次设置的定时器剩余时间（微秒）。如果之前没有设置定时器，则返回0。

示例代码：

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
​
void handle_sigalrm(int sig) {
    printf("定时器信号捕获到\n");
}
​
int main() {
    signal(SIGALRM, handle_sigalrm);
​
    ualarm(5000000, 1000000); // 5秒后触发，之后每隔1秒触发一次
​
    printf("等待定时器信号...\n");
    while (1) {
        pause();
    }
​
    return 0;
}

3. setitimer函数

setitimer函数用于设置一个间隔定时器，可以指定定时器的类型，并在定时时间到达时发送相应的信号。

函数原型：

#include <sys/time.h>
​
int setitimer(int which, const struct itimerval *new_value, struct itimerval *old_value);

参数：

  • which：定时器类型，可选值为：

    • ITIMER_REAL：基于实际时间的定时器，触发时发送SIGALRM信号。

    • ITIMER_VIRTUAL：基于用户态运行时间的定时器，触发时发送SIGVTALRM信号。

    • ITIMER_PROF：基于用户态和内核态运行时间的定时器，触发时发送SIGPROF信号。

  • new_value：指向新的定时器设置的指针。

  • old_value：指向存储旧的定时器设置的指针（可选）。

结构体itimerval：

struct itimerval {
    struct timeval it_interval; // 定时器的间隔时间
    struct timeval it_value;    // 定时器的初始时间
};

结构体timeval：

struct timeval {
    long tv_sec;         // 秒
    long tv_usec;        // 微秒
};

返回值：

  • 成功时返回0，失败时返回-1。

示例代码：

#include <stdio.h>
#include <signal.h>
#include <sys/time.h>
#include <unistd.h>
​
void handle_sigalrm(int sig) {
    printf("定时器信号捕获到\n");
    struct itimerval timer;
    timer.it_interval.tv_sec = 1;
    timer.it_interval.tv_usec = 0;
    timer.it_value.tv_sec = 1;
    timer.it_value.tv_usec = 0;
    setitimer(ITIMER_REAL, &timer, NULL); // 重新设置定时器
}
​
int main() {
    struct itimerval timer;
​
    signal(SIGALRM, handle_sigalrm);
​
    timer.it_interval.tv_sec = 1;
    timer.it_interval.tv_usec = 0;
    timer.it_value.tv_sec = 1;
    timer.it_value.tv_usec = 0;
    setitimer(ITIMER_REAL, &timer, NULL);
​
    printf("等待定时器信号...\n");
    while (1) {
        pause();
    }
​
    return 0;
}

八、信号的捕捉与处理

1. 信号捕捉过程

信号捕捉的步骤如下：

  1. 定义信号处理函数，该函数在信号到达时被调用。

  2. 使用signal或sigaction函数将信号与处理函数关联起来。

2. signal函数

signal函数用于设置信号的处理方式。

函数原型：

#include <signal.h>
​
typedef void (*sighandler_t)(int);
​
sighandler_t signal(int signum, sighandler_t handler);

参数：

  • signum：要设置处理方式的信号编号。

  • handler：信号处理函数，或者SIG_DFL（恢复默认处理）、SIG_IGN（忽略信号）。

返回值：

  • 返回之前的信号处理函数，如果设置失败则返回SIG_ERR。

示例代码：

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
​
void handle_sigint(int sig) {
    printf("SIGINT信号捕获到\n");
}
​
int main() {
    signal(SIGINT, handle_sigint);
​
    printf("进程正在运行。按Ctrl+C发送SIGINT。\n");
    while (1) {
        sleep(1);
    }
​
    return 0;
}

3. sigaction函数

sigaction函数提供了更灵活的信号处理设置，推荐使用。

函数原型：

#include <signal.h>
​
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

参数：

  • signum：要设置处理方式的信号编号。

  • act：指向新的信号处理动作的指针。

  • oldact：指向存储旧的信号处理动作的指针（可选）。

结构体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_flags标志：

  • SA_SIGINFO：使用sa_sigaction而不是sa_handler。

  • SA_RESTART：被信号中断的系统调用会自动重新发起。

  • SA_NODEFER：在信号处理函数执行期间，不对该信号进行屏蔽。

示例代码：

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
​
void handle_sigint(int sig) {
    printf("SIGINT信号捕获到\n");
}
​
int main() {
    struct sigaction act;
​
    act.sa_handler = handle_sigint;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
​
    sigaction(SIGINT, &act, NULL);
​
    printf("进程正在运行。按Ctrl+C发送SIGINT。\n");
    while (1) {
        sleep(1);
    }
​
    return 0;
}

九、信号的阻塞与挂起

1. 信号的阻塞

信号的阻塞是指阻止信号被处理，但信号仍然可以产生。阻塞信号不会被立即处理，而是等到解除阻塞后才处理。

示例代码
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
​
void handle(int sig) {
    printf("捕获到信号 %d\n", sig);
}
​
int main() {
    sigset_t set;
​
    sigemptyset(&set);
    sigaddset(&set, SIGINT);
​
    signal(SIGINT, handle);
​
    sigprocmask(SIG_BLOCK, &set, NULL); // 阻塞SIGINT信号
    sleep(5); // 在这5秒内，SIGINT信号会被阻塞
​
    sigprocmask(SIG_UNBLOCK, &set, NULL); // 解除SIGINT信号的阻塞
​
    while (1) {
        sleep(1);
    }
    return 0;
}

2. pause函数

pause函数使进程挂起，直到接收到信号为止。如果信号的处理动作是终止进程，则pause函数不会返回；如果信号的处理动作是忽略，则进程继续挂起；如果信号的处理动作是捕捉，则调用完信号处理函数后，pause函数返回-1。

示例代码
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
​
void handle(int sig) {
    printf("捕获到信号 %d\n", sig);
}
​
int main() {
    signal(SIGINT, handle);
​
    printf("进程已挂起。按Ctrl-C继续。\n");
    pause(); // 挂起进程
​
    printf("进程已恢复。\n");
    return 0;
}

3. sigsuspend函数

sigsuspend函数将进程的信号屏蔽字设置为指定的信号集，然后挂起进程，直到接收到信号为止。它通常用于在信号处理函数中临时更改信号屏蔽字。

示例代码
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
​
void handle(int sig) {
    printf("捕获到信号 %d\n", sig);
}
​
int main() {
    sigset_t set;
​
    sigemptyset(&set);
    sigaddset(&set, SIGINT);
​
    signal(SIGINT, handle);
​
    printf("进程已挂起。按Ctrl-C继续。\n");
    sigsuspend(&set); // 挂起进程
​
    printf("进程已恢复。\n");
    return 0;
}

十、信号集操作

1. 信号集操作函数

信号集操作函数用于管理信号集，可以清空、填充、添加、删除和检查信号集中的信号。

示例代码
#include <stdio.h>
#include <signal.h>
​
int main() {
    sigset_t set;
​
    sigemptyset(&set); // 清空信号集
    sigaddset(&set, SIGINT); // 添加SIGINT到信号集
    sigaddset(&set, SIGQUIT); // 添加SIGQUIT到信号集
​
    if (sigismember(&set, SIGINT)) {
        printf("SIGINT在信号集中。\n");
    } else {
        printf("SIGINT不在信号集中。\n");
    }
​
    if (sigismember(&set, SIGQUIT)) {
        printf("SIGQUIT在信号集中。\n");
    } else {
        printf("SIGQUIT不在信号集中。\n");
    }
​
    sigdelset(&set, SIGINT); // 从信号集中删除SIGINT
​
    if (sigismember(&set, SIGINT)) {
        printf("SIGINT在信号集中。\n");
    } else {
        printf("SIGINT不在信号集中。\n");
    }
​
    return 0;
}

十一、信号的忽略与默认处理

1. 忽略信号

可以使用signal函数将信号处理方式设置为SIG_IGN，从而忽略指定的信号。

示例代码
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
​
int main() {
    signal(SIGINT, SIG_IGN); // 忽略SIGINT信号
​
    printf("SIGINT信号被忽略。按Ctrl+C测试。\n");
    while (1) {
        sleep(1);
    }
​
    return 0;
}

2. 恢复默认处理

可以使用signal函数将信号处理方式设置为SIG_DFL，从而恢复系统的默认处理方式。

示例代码
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
​
void handle(int sig) {
    printf("捕获到信号 %d\n", sig);
}
​
int main() {
    signal(SIGINT, handle); // 设置SIGINT的处理函数
    sleep(5);
​
    signal(SIGINT, SIG_DFL); // 恢复SIGINT的默认处理方式
​
    printf("SIGINT信号恢复为默认处理。按Ctrl+C测试。\n");
    while (1) {
        sleep(1);
    }
​
    return 0;
}

十二、信号在进程间通信中的应用

1. 使用kill命令发送信号

可以在命令行使用kill命令向指定进程发送信号。

示例代码
# 向进程ID为1234的进程发送SIGINT信号
kill -SIGINT 1234

2. 使用raise函数发送信号给自己

可以使用raise函数向自身发送信号。

示例代码
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
​
void handle(int sig) {
    printf("捕获到信号 %d\n", sig);
}
​
int main() {
    signal(SIGINT, handle); // 设置SIGINT的处理函数
    raise(SIGINT); // 向自身发送SIGINT信号
    while (1) {
        sleep(1);
    }
    return 0;
}
Linux信号机制
04-09
Linux信号机制是操作系统内核中用于进程间通信和异常处理的一种机制。它允许一个进程向另一个进程发送消息，这些消息可以是关于特定事件的通知，或者是请求执行特定操作的命令。在Linux系统中，信号机制是基于POSIX...
linux平台C语言信号和操的实现
11-25
"Linux平台C语言信号和槽的实现"是一个项目，它旨在在不依赖Qt库的情况下，使用C语言模仿Qt的信号和槽机制。Qt的信号与槽是用于对象间通信的一种强大机制，但它们是用C++实现的，而此项目则是将其概念应用到C语言中...
Linux信号机制探析--信号的处理
完颜振江
09-24 1451
在 shell 脚本中，可以通过exit/bin/bashexit 42执行这个脚本后，# 输出 420通常表示成功执行。非 0表示错误，具体数值代表不同的错误类型。128 + 信号编号表示进程因信号被终止。通过检查，你可以判断上一个命令的执行结果并作出相应处理。
linux下的信号机制
weixin_74994990的博客
11-28 780
就例如当我们在linux上创建了一个死循环的程序，想让它停止，我们会使用Ctrl+c，而这样的本质就是给这个进程发送了一个信号，程序接收到这个信号，发现这个信号的默认行为就是将程序终止，所以程序就会终止，像这样的信号，在linux下有这些。进程可以忽略信号、执行默认操作，或者捕获信号并执行自定义的处理函数。对应信号被捕捉以后，再次给进程发送那个对应的信号，进程便会执行你设置的函数，而不是系统默认的行为，但是注意的是，某些信号是不能被捕捉的，例如9号信号，终止进程的信号，还有某些强制的信号。
详解 Linux 信号机制
不搞数学的汤老师
06-12 2200
信号是事件发生时对进程的通知机制，有时也称之为软件中断。 一个进程（具有权限）能够向另一个进程发送信号。进程也可向自己发送信号。可以作为一种同步技术，甚至可作为 IPC （进程间通信）。 信号到达默认执行以下操作之一： 忽略信号 杀死进程 产生核心转储文件，并杀死进程 暂停进程 唤醒进程 除了默认操作以外，也能改变信号的响应行为。称之为信号的处置设置。程序可以对信号做以下的设置： 默认操作 忽略信号 执行信号处理程序 信号处理程序是由程序员编写的函数，根据收到的信号执行对应的任务。无法对信号
Linux 的信号机制
千千道的博客
12-28 1462
Linux 信号机制作为操作系统内核与进程之间的重要通信手段，为系统的稳定运行、进程间的协作以及错误处理提供了高效、灵活的方式。深入理解信号机制的原理、产生方式、处理流程以及应用场景，对于开发高质量、健壮的 Linux 应用程序具有至关重要的意义，能够帮助开发者更好地利用系统资源，优化程序行为，提高系统的整体性能和可靠性。
Linux信号处理
weixin_53333929的博客
07-15 853
在Linux系统中，使用C语言处理信号是一个常见的需求，尤其是在编写需要响应特定系统事件（如中断、定时器到期、用户请求等）的程序时。Linux提供了一套机制来允许进程捕获和处理信号。这里，我们将详细讨论如何使用C语言在Linux中设置信号处理程序。
Linux信号量机制总结与实例解析
极客代码
06-23 1634
本章通过几个实战案例，展示了信号量在实际应用中的强大功能。这些案例涵盖了不同类型的系统和应用场景，使读者能够将所学知识应用于实际工作中，提高工作效率。通过这些案例的学习，读者应该能够更好地理解信号量操作的应用，并能够将这些技术应用于自己的实际工作中。无论你是初学者还是有经验的开发者，本教程都将帮助你掌握Linux信号量的核心技能，为你提供解决实际问题的工具和思路。本章通过几个实战案例，展示了Linux信号量在实际应用中的强大功能。
LinuxC信号
未来的路
06-03 1012
linux的信号相关接口
【Linux】信号机制(非实时信号)
Hello_World_213的博客
01-11 3114
Linux信号机制详解, 信号产生/信号发送与保存/信号处理
Linux信号机制及其原理分析
qq_34231329的博客
06-30 1519
在最近在工作中，使用到了信号的相关知识，之前我们在分析系统进程的时候也提到了信号，但并没有对信号这个机制做出深入的理解，借此机会，我们深入分析一下信号机制是怎样实现的信号（），是系统中的一种古老的进程间通信机制，而作为类系统，早期也是模仿了系统，自然也保留下了这个机制。信号是一种异步通信机制，它是在软件层面上对中断机制的一种模拟注：本篇文章基于glibc版本2.35，Linux内核版本5.17，x86_64架构信号可以由内核产生，也可以由用户产生，这边举几个例子：用户在终端输入时，会产生一个信号在程序中对一
Linux线程同步之信号C语言实例
09-03
总结来说，在Linux中使用C语言进行线程同步时，可以通过信号机制配合信号处理函数和`sigwait`来控制线程的执行流程。合理地利用这些工具，可以有效地避免竞态条件，提高程序的并发性和正确性。在实际编程中，还需要...
linux信号的机制
12-23
### Linux信号机制详解 #### 一、信号的基本概念 在Linux操作系统中，信号（Signal）是一种重要的进程间通信（IPC, Inter-Process Communication）机制，主要用于通知进程发生了某些类型的异常事件或状态变化。...
Linux信号机制的分析与研究.pdf
09-06
Linux信号机制是操作系统中进程间通信的重要方式，尤其在Linux环境下，它被广泛应用于进程管理、异常处理和用户交互。信号是一种轻量级的通知机制，它通知进程发生了特定的异步事件，但并不传递数据。在Linux 2.4...
Linux中进程与计划任务
最新发布
yinglongdiwan的博客
04-02 1039
也是用于关闭进程的一个命令，但和 kill 不同的是，killall 命令不再依靠 PID 来杀死单个进程，而是通过程序的进程名来杀死一类进程。进程是一个具有一定独立功能的程序在一个数据集上的一次动态执行的过程，是操作系统进行资源分配和调度的一个独立单位，是应用程序运行的载体。kill 命令是按照 PID 来确定进程的，所以 kill 命令只能识别 PID，而不能识别进程名。"ps -le" 可以查看系统中所有的进程，而且还能看到进程的父进程的 PID 和进程优先级；-P pid: 显示指定进程的子进程。
linux三种安装方式的优缺点
y88605的博客
04-02 639
【代码】linux三种安装方式的优缺点。
Linux——多线程—01
aaa114514aaaa的博客
03-31 1185
有关Linux中多线程的学习和理解【线程的概念和对线程的理解】【对Linux线程的全面理解】【线程控制的相关接口和操作】【原生线程库的理解(用户级线程)】
六十天Linux从0到项目搭建（第二十二天）（pipe、管道四种场景）
weixin_73266891的博客
03-31 679
是 Unix/Linux 系统中用于创建匿名管道的系统调用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值