首页 > 其他分享 >【C语言】信号

【C语言】信号

时间：2024-06-18 21:57:31浏览次数：9  
标签：set int pid C语言 信号 sa include

【C语言】信号

信号

1. 信号状态

信号有三种状态：产生、未决和递达

信号产生方式：

  • 按键产生，ctrl+c 产生 中断信号SIGINT，ctrl + \ 产生退出信号 SIGQUIT并生成core文件，ctrl +z产生停止信号SIGSTOP
  • 系统调用，例如kill、raise、abort函数
  • 定时器
  • 发生异常

信号未决状态：

​ 是指信号在阻塞信号集中被设置为阻塞，那么接收到这个信号后，会被保存到进程的未决信号集中，当阻塞解除才能执行对应信号处理函数。

信号递达状态：

​ 进程接收到信号并执行了对应操作。

2. 信号处理方式

  • 执行默认的操作
  • 忽略
  • 捕获，执行用户定义的处理函数

信号无法排队，所以如果同时来了很多信号，那么需要用循环进行处理

查看当前系统有哪些信号 kill -l ,其中 SIGKILL 和 SIGSTOP 不能被捕捉，阻塞，或忽略。

 1) SIGHUP	 	2) SIGINT	 3) SIGQUIT	 	4) SIGILL	 5) SIGTRAP
 6) SIGABRT	 	7) SIGBUS	 8) SIGFPE	 	9) SIGKILL	10) SIGUSR1
11) SIGSEGV		12) SIGUSR2	13) SIGPIPE		14) SIGALRM	15) SIGTERM
16) SIGSTKFLT	17) SIGCHLD	18) SIGCONT		19) SIGSTOP	20) SIGTSTP
21) SIGTTIN		22) SIGTTOU	23) SIGURG		24) SIGXCPU	25) SIGXFSZ
26) SIGVTALRM	27) SIGPROF	28) SIGWINCH	29) SIGIO	30) SIGPWR
31) SIGSYS

3. 信号注册相关函数

//signal()
//用于注册信号捕捉函数，当捕获对应信号时，执行相应函数。
#include <signal.h>
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);
参数
    signum: 信号
    handler: 信号处理函数

//sigaction()
//用于注册信号捕捉函数，执行相应函数，并且添加处理方式，返回0成功，返回-1失败
#include <signal.h>
int sigaction(int signum, const struct sigaction *act,struct sigaction *oldact);
struct sigaction {
    void     (*sa_handler)(int);
    void     (*sa_sigaction)(int, siginfo_t *, void *);
    sigset_t   sa_mask;
    int        sa_flags;
    void     (*sa_restorer)(void);
};

参数
    signum: 捕捉的信号
    act: 	传入参数，新的信号处理方式
    	sa_handler:信号处理函数，还可赋值为SIG_IGN表示忽略信号到来 或 SIG_DFL表执行默认动作
        sa_sigaction:如果在 sa_flags 中指定了 SA_SIGINFO ，则 sa_sigaction(而不是SA_handler)作为signum的信号处理函数。此函数接收的信号号作为其第一个参数，一个指向 siginfo_t 类型的指针作为其第二个参数,这个类型结构体包含了很多和进程相关的信息，以及一个指向ucontext_t类型(强制转换为void*)的指针作为第三个参数。(通常，处理程序函数不使用第三个参数。),通常设置为NULL
		sa_mask:信号处理时需要阻塞的信号掩码
        sa_flags:通常为0，表示使用默认标识
        sa_restorer:不应用于应用程序，已舍弃
    oldact :传出参数，旧的信号处理方式
        同上

//kill()
//用于向某个进程发信号。
#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int sig);
参数
    pid 进程id
    sig 信号

//raise()
//用于自己给自己发送信号
#include <signal.h>
int raise(int sig);
返回值
    成功返回0
    失败返回非0

//abort()
//用于自己给自己发送 SIGABRT 信号，等价于 abort() == kill(getpid(), SIGABRT);
#include <stdlib.h>
void abort(void);

//alarm()
//设置时钟seconds秒数，内核会给当前进程发送 SIGALRM 信号，每个进程只有一个定时器
#include <unistd.h>
unsigned int alarm(unsigned int seconds);
返回值
    返回0或者剩余秒数
//取消定时器使用alarm(0)，返回旧闹钟余下秒数，不管进程处于什么状态，计时器一直计时

//setitimer()
//也是设置计时器，比alarm函数计时得更精确，可以精确到微秒。子进程不会继承父进程的计时器
#include <sys/time.h>
int getitimer(int which, struct itimerval *curr_value);
int setitimer(int which, const struct itimerval *new_value,
              struct itimerval *old_value);

struct itimerval {
	struct timeval it_interval; /* Interval for periodic timer */计时周期时间
	struct timeval it_value;    /* Time until next expiration */第一次计时时间，可通过getitimer函数获取该值得到剩余计时时间
};

struct timeval {
	time_t      tv_sec;         /* seconds */
	suseconds_t tv_usec;        /* microseconds */
};
//成功返回0，失败返回-1
参数
    which: 指定定时方式
        ITIMER_REAL		计算实时时间，给当前进程发送 SIGALRM 信号
        ITIMER_VIRTUAL	计算进程运行时间，发送 SIGVTALRM 信号
        ITIMER_PROF		计算进程运行时间和系统调用时间，这个通常和ITIMER_VIRTUAL组合进行评测进程运行时间和系统调用时间，发送 SIGPROF 信号。
        
getitimer 中 curr_value 是传出参数，表示剩余时间。
setitimer 中 
        new_value 设置计时时间
        old_value 通常设置为NULL，如果非NULL,那么是一个传出参数，返回的是原来的计时器。

示例：

创建三个子进程，子进程结束时会给父进程发送 SIGCHLD 信号，父进程执行对应函数回收子进程。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>

void sighandle(int signo)
{
    pid_t pid;
    while (1)
    {
        pid = waitpid(-1, NULL, WNOHANG);
        if (pid > 0)
        {
            printf("child [%d] is over\n", pid);
        }
        else if (pid == 0)
        {
            printf("no more child need clean");
            break;
        }
        else if (pid == -1)
        {
            printf("no child is living, pid==[%d]\n", pid);
            break;
        }
        else
        {
            perror("waitpid error");
            break;
        }
    }
}

int main()
{
    int i = 0;
    pid_t pid;
    signal(SIGCHLD, sighandle);
    for (i = 0; i < 3; i++)
    {
        pid = fork();
        if (pid < 0)
        {
            perror("fork error");
            return -1;
        }
        else if (pid > 0)
        {
            // father
        }
        else
        {
            // child
            printf("here is child [%d],father is [%d]\n", getpid(), getppid());
            break;
        }
    }

    if (i==3)
    {
        while (1)
        {
            sleep(1);
        }
    }
    
    return 0;
}

进程实际执行时间 = 系统时间 + 用户时间 + 损耗时间

损耗的时间主要来来自文件IO操作，IO操作会有用户区到内核区的切换，切换的次数越多越耗时。

4. 信号集相关函数

信号集有阻塞信号集和未决信号集，当某些信号在阻塞信号集中被设置为阻塞，那么当这个信号来时，该进程的未决信号集会将该信号对应设置为未决信号。只有解除该信号为非阻塞，才会执行对应的信号处理函数。

#include <signal.h>
//初始化信号集,清空所有信号
int sigemptyset(sigset_t *set);
//初始化信号集,包含所有信号
int sigfillset(sigset_t *set);
//添加信号进入到某个信号集
int sigaddset(sigset_t *set, int signum);
//从信号集中删除某个信号
int sigdelset(sigset_t *set, int signum);
//上面都是返回0成功，返回-1失败
//判断信号是否在这个信号集中，返回 1在，0不在，-1错误
int sigismember(const sigset_t *set, int signum);

//sigpending()
//获取当前进程的未决信号集，set为传出参数，
int sigpending(sigset_t *set);

//sigprocmask()
//用来修改进程pcb中阻塞信号集中的内容，成功返回0，失败返回-1
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
参数
    how:将后面的set进行某种操作
        SIG_BLOCK	:将set添加到阻塞信号集
        SIG_UNBLOCK	:将set从阻塞信号集移除
        SIG_SETMASK	:直接将set作为阻塞信号集
    set: 信号集，可以使用上面的一系列函数得到
	oldset: 通常设为NULL,否则返回之前的阻塞信号集

示例：

创建三个子进程，并且屏蔽SIGINT中断信号，然后注册SIGCHLD信号处理函数，注册时阻塞SIGCHLD信号

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>

void sighandle(int signo)
{
    pid_t pid;
    while (1)
    {
        pid = waitpid(-1, NULL, WNOHANG);
        if (pid > 0)
        {
            printf("child [%d] is over\n", pid);
        }
        else if (pid == 0)
        {
            printf("no more child need clean\n");
            break;
        }
        else if (pid == -1)
        {
            printf("no child is living, pid==[%d]\n", pid);
            break;
        }
        else
        {
            perror("waitpid error");
            break;
        }
    }
}

int main()
{
    int i = 0;
    pid_t pid;
    char usig = SIGINT;
    // signal(SIGCHLD, sighandle);
    sigset_t set;
    sigset_t oldset;

    int ret = sigemptyset(&set);
    if (ret < 0)
    {
        perror("sigemptyset error");
        return -1;
    }
    ret = sigaddset(&set, usig);
    if (ret < 0)
    {
        perror("sigaddset error");
        return -1;
    }
    ret = sigismember(&set, usig);
    if (ret < 0)
    {
        perror("sigaddset error");
        return -1;
    }
    else if (ret == 0)
    {
        printf("error:usig not in set\n");
        return -1;
    }
    else if (ret == 1)
    {
        printf("usig in set\n");
    }
    //添加信号SIGINT到阻塞信号集
    ret = sigprocmask(SIG_BLOCK, &set, &oldset);
    if (ret < 0)
    {
        perror("sigprocmask error");
        return -1;
    }

    for (i = 0; i < 3; i++)
    {
        pid = fork();
        if (pid < 0)
        {
            perror("fork error");
            return -1;
        }
        else if (pid > 0)
        {
            // father
        }
        else
        {
            // child
            printf("here is child [%d],father is [%d]\n", getpid(), getppid());
            break;
        }
    }

    if (i == 3)
    {
        //注册捕捉函数
        struct sigaction act;
        memset(&act, 0x00, sizeof(act));
        ret = sigemptyset(&act.sa_mask);
        ret = sigaddset(&act.sa_mask, SIGCHLD);
        act.sa_handler = sighandle;
        act.sa_flags = 0;

        ret = sigaction(SIGCHLD, &act, NULL);
        if (ret < 0)
        {
            perror("sigaction error");
            return -1;
        }
        printf("here is father last words\n");
        while (1)
        {
        }
    }

    return 0;
}

//输出
usig in set
here is father last words
here is child [2751],father is [2750]
child [2751] is over
no more child need clean
here is child [2752],father is [2750]
child [2752] is over
no more child need clean
here is child [2753],father is [2750]
child [2753] is over
no child is living, pid==[-1]

示例：

使用定时器，定时发送计时结束信号SIGALRM

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/time.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>

void sighandle(int signo)
{
    
    printf("signo is [%d]\n", signo);
}

int main()
{
    // alarm(3);
    // int getitimer(int which, struct itimerval *curr_value);
    // int setitimer(int which, const struct itimerval *new_value,struct itimerval *old_value);
    struct itimerval time;
    struct itimerval lasttimer;
    memset(&time,0x00,sizeof(time));
    memset(&time,0x00,sizeof(lasttimer));
    time.it_interval.tv_sec = 3;
    time.it_interval.tv_usec = 0;
    time.it_value.tv_sec = 1;
    time.it_value.tv_usec = 0;
    setitimer(ITIMER_REAL, &time, NULL);
    int ret;
    // 注册捕捉函数
    struct sigaction act;
    memset(&act, 0x00, sizeof(act));
    ret = sigemptyset(&act.sa_mask);
    // 信号处理的时候阻塞SIGALRM信号
    ret = sigaddset(&act.sa_mask, SIGALRM);
    act.sa_handler = sighandle;
    act.sa_flags = 0;

    ret = sigaction(SIGALRM, &act, NULL);
    while (1)
    {
        sleep(1);
        getitimer(ITIMER_REAL,&lasttimer);
        printf("[%ld:%ld]\n",lasttimer.it_value.tv_sec,lasttimer.it_value.tv_usec);
    }
    
    return 0;
}
//输出
signo is [14]
[2:978958]
[1:955765]
[0:950218]
signo is [14]
[2:995498]
[1:984102]
[0:970387]
signo is [14]
[2:978756]
[1:964049]
[0:915772]
signo is [14]
...

最后

推荐一个零声教育学习教程，个人觉得老师讲得不错，分享给大家：[Linux，Nginx，ZeroMQ，MySQL，Redis，
fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，
TCP/IP，协程，DPDK等技术内容，点击立即学习:链接

标签：set,int,pid,C语言,信号,sa,include
From： https://blog.csdn.net/qq_44653106/article/details/139784556

相关文章

  • 【C语言】数组参数和指针参数详解
    在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢？1一维数组传参#include<stdio.h>voidtest(intarr[])//ok?{}voidtest(intarr[10])//ok?{}voidtest(int*arr)//ok?{}voidtest2(int*arr[20])//ok?{}voidtest2(int**arr)//ok?......
  • C语言队列操作及其安全问题
    在C语言中，队列是一种常用的数据结构，特别适用于嵌入式开发中的任务调度、缓冲区管理等场景。下面是一个简单的循环队列的模板代码，它使用数组来实现队列，并提供了基本的入队（enqueue）和出队（dequeue）操作。示例代码如下：#include<stdio.h>#include<stdbool.h>#include<string.h>......
  • C语言结构体位域的使用技巧（联合体妙用）
    C语言结构体位域的使用技巧基本概念在C语言中，位域（BitFields）是一种数据结构，它允许程序员访问内存中的单个位。位域通常用于硬件编程，例如嵌入式系统开发，因为它们允许程序员直接访问和控制硬件寄存器的特定位。位域在不同的编译器和平台上可能会有不同的内存对齐和打包行为，......
  • 复习与回顾（C语言）
    学习三阶段：初识——>初阶——>进阶注：蓝色字体皆可跳转一阶：初识1.基本了解C语言的基础知识，对C语言有一个大概的认识2.简单认识每个知识点，后期在初阶和进阶进行详细描述学习内容1.什么是C语言2.第一个C语言程序3.数据类型4.变量、常量5.字符串、转义字符、注释......
  • 高速信号处理板卡设计原理图：519-基于ZU19EG的4路100G光纤的PCIe 加速计算卡
    基于ZU19EG的4路100G光纤的PCIe加速计算卡  一、板卡概述    本板卡系我司自主设计研发，基于Xilinx公司ZynqUltraScale+MPSOC系列SOCXCZU19EG-FFVC1760架构，支持PCIEGen3x16模式。其中，ARM端搭载一组64-bitDDR4，总容量达4GB，可稳定运行在2400MT/s，PL端......
  • 实现CHECKSUM的C语言程序
    什么是校验和？在计算中，校验和是使用算法从较大的数据集创建的小数据，目的是对较大的数据集所做的任何更改都会导致不同的校验和。校验和通常用于验证已传输或存储的数据的完整性，因为数据中的错误或修改可能会导致校验和更改。它们还可用于验证数据的真实性，因为校验和通常是使用......
  • C语言 - 标识符
    C语言中的标识符有助于识别C代码中的变量、常量、函数等。C是一种高级计算机语言，它允许您使用名称引用内存位置，而不是以二进制或十六进制形式使用其地址。C标识符标识符是用户定义的名称，以便于引用内存。它还用于定义程序中的各种元素，例如函数、用户定义类型、标签等。......
  • C语言数据结构队列实现-链表队列
    简单实现了下链表队列代码如下#include<stdio.h>#include<stdlib.h>typedefstructNode{intdata;structNode*next;}Node;//入队列voidinsertList(Node*head,intelem){Node*temp=head;Node*newNode=(Node*)malloc(sizeof(Node));......
  • C语言---------深入理解指针
    目录一、字符指针二、指针数组：三、数组指针：1、定义：2、&数组名和数组名区别：3、数组指针的使用：四、数组参数，指针参数：1、一维数组传参：2、二维数组传参：3、一级指针传参：4、二级指针传参：五、函数指针：1、定义：2、函数名和&函数名：3、函数指针的调用：六、函数指针数组：七......
  • c语言连接两个字符串
    在C语言中，连接两个字符串可以使用标准库函数strcat。这个函数将一个字符串添加到另一个字符串的末尾。使用strcat时，需要确保目标字符串有足够的空间来容纳源字符串，否则可能会导致缓冲区溢出。下面是strcat函数的基本用法示例：#include<stdio.h>#include<string.h>......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99