首页 > 系统相关> > LINUX系统编程-- 5 信号

LINUX系统编程-- 5 信号

2021-09-16 09:02:26 作者：互联网

LINUX系统编程-- 5 信号

五信号

五信号

并发分两种：信号（进程间通信）与线程

内容：

1、信号的概念
2、signal
3、信号的不可靠
4、可重入函数
5、信号的响应过程
6、常用函数：kill、raise、alarm、pause、abort、system、sleep等
7、信号集
8、信号屏蔽字、peding集的处理
9、sigsuspend（）、sigaction（）、setitimer
10、实时信号

1信号的概念和相关概念

并发概念。
信号是初步异步、线程是强烈异步
同步概念
异步概念

异步事件的处理：查询法，通知法

信号是软件中断。信号的响应依赖于中断。

1、 kill -l 查看全部的信号，是shell命令

1-31是标准信号。之后的是实时信号

2 core文件：一个程序的某一个现场

默认下，是不产生core文件的：
在这里插入图片描述
可知默认设置下，允许的core文件的大小是0。也就是不产生core文件。
我们可以用ulimit -c 10240 来设置core文件的最大为10M。
当执行一个程序出错时，就会有core文件的产生。core文件后面的数字是进程号。

3 signal函数

函数原型是：
void（*signal（int signum，void（*func）（int）））（int）

4ctrl+c是SIGINT的快捷方式（2号信号）

5 实例

例一：

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
int main()
{
    int i;

    signal(SIGINT,SIG_IGN);

    for (i = 0;i < N;i++){
        write(1,"*",1);
        sleep(1);
    }
    exit(0);
}

这个程序使得ctrl+c不再管用，因为忽略掉了这个信号。

例二：

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

#define N 20

void handler(int sig){
    write(1,"!",1);
}


int main()
{
    int i;

    signal(SIGINT,handler);

    for (i = 0;i < N;i++){
        write(1,"*",1);
        sleep(1);
    }
    
    exit(0);
}

注意点：

signal函数最需要注意的就是，回调函数！当signal函数的第二个参数是函数地址指向信号处理函数的时候，这时的信号处理函数是一个回调函数。signal只是起到了对这个信号处理函数的注册作用！！当有指定的信号发生的时候，信号处理函数才会执行。（信号处理函数执行的一个前提就是，信号发生时，程序未结束！）
回调函数一般放在程序的开头，声明和定义放在一块。
信号会打断阻塞的系统调用！！！！以open为例，当open打开一个很慢的设备的时候，open是在阻塞的，这个时候会被信号打断，打断的结果是，返回-1，并设置error为EINTR！read、write函数也是同理，当读数据或者写数据的时候，如果是阻塞中，也是会被信号打断的（同样也是将errno设置为EINTR）！
通常来讲，我们将系统调用被信号打断称为假错，也就是说，这不是程序本身的问题，所以通常我们会在出错处理上加一个出错判断。

6 信号的不可靠

指的是信号的行为不可靠。
第一次调用还没结束，第二次调用就开始了，第二次调用用的环境是第一次调用还没调用完的环境，所以会出问题。
待补充。。
。。
。。
。。
。。

7 可重入函数

是解决信号的不可靠的一种方法！
可重入函数就是说，当第一次信号处理函数还没执行完时，若又来了一个信号，那么会先把第一次的信号处理函数执行完。（而忽略第二次的信号）。也就是说，信号处理函数第一次调用没结束，发生第二次调用但不会出错

可重入函数都是安全的，就如“可重入”的意思一样，如果某个函数是非可重入函数，那么此函数不能用于信号处理函数中。通常这个信号会提供第二个版本（通常是后面有_r）,

所有的系统调用都是可重入的！一部分库函数也是可重入的，比如说：memcpy

8 信号的响应过程

在这里插入图片描述

9 常用函数

1、 kill函数

kill（）-需要注意的就是第一个参数，可以取正负或者0，各自有不同的含义。

pid>0 给指定进程发送信号
pid==0 组内广播，即给所有同组进程发送信号
pid==-1 全局广播，给所有自己有权限发送信号的进程发送信号，除init进程外，不包括init进程。一般就是init进程会发全局广播。
pid<-1 发送给指定进程组。将信号发送给进程组ID绝对值 == pid绝对值的进程组中的每个进程
sig == 0 不会发送任何信号，用于检测一个进程或者进程组是否存在。

返回值： 0成功 -1失败
如果失败，查看errno 如下：

EINVAL 表示目标信号无效
EPERM 表示进程没有向任何目标进程发送信号的权限，即表示目标进程或进程组存在，但是你没有发送信号的权限！！
ESRCH pid或进程组不存在。注意，现有的进程可能是僵死进程，即已经提交了终止请求，但还没有被等待(2)的进程。

2、raise()
给当前进程发送信号，自己给自己发信号

在多进程中，相当于：

kill(getpid(), sig);

在多线程中:相当于:

pthread_kill(pthread_self(), sig);

3、alarm()
设置一个发送信号的闹钟；
alarm()以秒为单位安排将一个SIGALRM信号发送给调用进程。 SIGALRM 也是终止信号。

alarm例子：
例一：使用单一计时器

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
	alarm(5);
	while(1);
	exit(0);
}
mhr@ubuntu:~/Desktop/xitongbiancheng/parallel/signal/test$ gcc alarm.c 
mhr@ubuntu:~/Desktop/xitongbiancheng/parallel/signal/test$ ./a.out 
Alarm clock
mhr@ubuntu:~/Desktop/xitongbiancheng/parallel/signal/test$   延迟5秒

例二：alarm的连续设置最有一个alarm有效

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
	alarm(5);
	alarm(10);
	alarm(1);
	while(1);
	exit(0);
}

mhr@ubuntu:~/Desktop/xitongbiancheng/parallel/signal/test$ gcc alarm.c 
mhr@ubuntu:~/Desktop/xitongbiancheng/parallel/signal/test$ ./a.out 
Alarm clock
只延迟1秒
mhr@ubuntu:~/Desktop/xitongbiancheng/parallel/signal/test$

例三：
在alarm这里需要注意的是，当要改变sigalarm的默认行为的时候，signal 一定要写在 alarm前面，如果alarm写在前面，如下：

alarm(5);
       ... 中间程序 经过了5秒
signal(SIGALRM,alarm_handler);

这种情况中间程序做了5秒以上的工作，那么5秒后当此时信号来了，程序还没有执行到 signal() 也就看不到给信号注册的新的行为：alarm_handler，那么就会沿用这个信号默认的行为，即终止程序。

所以正确写法是：

/ signal 一定要写在 alarm前面
signal(SIGALRM,alarm_handler);
	alarm(5);

4、pause函数
等待一个信号，即这是人为做出来的一个阻塞的系统调用。（我们专门做出来的一个用来被打断的阻塞的系统调用）。
pause()使调用进程(或线程)处于休眠状态，直到发出终止进程或调用信号捕捉函数的信号。

这个函数需要注意的就是他是使进程处于休眠状态，即不在占用CPU资源，而while（1），虽然效果与pause一样，但是while使CPU一直在运行！

5、补充
在有些环境下 sleep() 是由 alarm() + pause()封装的。有些是用nanosleep()封装的。

所以不建议使用 sleep()，理由是在 sleep() 是由 alarm() + pause()封装的环境中，当你程序中同时使用 sleep() 和 alarm()的时候，必然有覆盖一个 alarm，即 alarm() 和 sleep()当中必然会有一个失效！！当前我们使用的环境用sleep不会有任何问题，因为他是用nanosleep封装的，但是为了保证程序的可移植性，还是尽量避免使用sleep。

6、alarm实例：

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

static int loop = 1;

static void alarm_handler(int s)
{
	loop = 0;
}

int main()
{
	int64_t count = 0;

// signal 一定要写在 alarm前面
signal(SIGALRM,alarm_handler);
	alarm(5);
	
	while(loop)
		count++;

	printf("%ld\n",count);
	exit(0);
}



mhr@ubuntu:~/Desktop/xitongbiancheng/parallel/signal/test$ gcc alarm.c 
mhr@ubuntu:~/Desktop/xitongbiancheng/parallel/signal/test$ time ./a.out 
2629709698

real	0m5.002s
user	0m4.936s
sys	0m0.000s
mhr@ubuntu:~/Desktop/xitongbiancheng/parallel/signal/test$

补充：

alarm比time的精度高。
volatile 关键字：去到这个变量真正的存储空间取数值，而不是根据局部结构判断取值

9.1 漏桶实例，流量控制

实现一个cat，这个mycat与cat不同的点是每秒cat10个字符输出到标准输出。
读取一个视频、一个音频等都是要进行流量控制的！数据不是一股脑全读完的。

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>

#define BUFSIZE 10

static volatile int loop = 0;

static void alrm_handler(int s)
{
	alarm(1);//重新定时
	loop = 1;
}

int main(int argc,char *argv[])
{
	int sfd,dfd=1;
	char buf[BUFSIZE];
	int len,ret,pos;


	if(argc < 2)
	{
		fprintf(stderr,"Usage:%s <src_file> <dest_file>\n",argv[0]);
		exit(1);
	}

	signal(SIGALRM,alrm_handler);
	alarm(1);

	do
	{
		sfd = open(argv[1],O_RDONLY);
		if(sfd < 0)
		{
			if(errno != EINTR)//防止是 信号打断阻塞的系统调用
			{
				perror("open()");
				exit(1);	
			}
		}
	}while(sfd < 0);

	while(1)
	{

//休眠挂起 直到收到信号，重新开始执行while(!loop)循环，实现一秒一输出
// 这里也可以 不用pause()，while()后 执行空，但是这样 CPU 占用率会很高，一秒钟会在这里执行循环上亿次，所以用pause()替换，直接休眠等待信号来唤醒
/*		
while(!loop)
			;
*/
		while(!loop)
			pause();
		loop = 0;

		while((len = read(sfd,buf,BUFSIZE)) < 0)
		{	
			if(errno == EINTR)//防止是 信号打断阻塞的系统调用
				continue;
			perror("read()");
			break;
		}

		if(len == 0)
			break;

		//确保写进去 len 个字节
		pos = 0;
		while(len > 0)
		{
			ret = write(dfd,buf+pos,len);
			if(ret < 0)
			{
				if(errno == EINTR) //防止是 信号打断阻塞的系统调用
					continue;
				perror("write()");
				exit(1);

			}
			pos += ret;
			len -= ret;

		}

	}

	close(sfd);

}

缺点：如果读取的是打印机类的设备，并且当时打印机上面没有数据，那么程序就会一直循环于 read处.

while((len = read(sfd,buf,BUFSIZE)) < 0)
{
if(errno == EINTR)//防止是信号打断阻塞的系统调用
continue;

问题是这几句，一直循环于：
读阻塞，打断阻塞判断是假错误(信号打断阻塞的系统调用) 返回重新读。。。。
读阻塞，打断阻塞判断是假错误(信号打断阻塞的系统调用) 返回重新读。。。。
读阻塞，打断阻塞判断是假错误(信号打断阻塞的系统调用) 返回重新读。。。。

所以漏桶的缺陷就是如果没有数据的时候就会一直循环等待，直到有数据，如果忽然来的数据量很大，也不能快速的去读数据，只能慢慢的一秒10个字节的去读n次

9.2 令牌桶，流量控制

令牌桶的优势，就是当没有数据可读的时候，会积攒自己的权限，意思是如果之前30秒一直没有数据，读空了30秒，那么就存下30个权限，等到有数据的时候，快速使用前面30个权限，快速连续读30次。

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>
 
#define CPS 10
#define BUFSIZE CPS
#define BURST 100

static volatile int token = 0;

static void alrm_handler(int s)
{
	alarm(1);
	token++;
	if(token > BURST)
		token = BURST;
}

int main(int argc,char *argv[])
{
	int sfd,dfd=1;
	char buf[BUFSIZE];
	int len,ret,pos;

	if(argc < 2)
	{
		fprintf(stderr,"Usage:%s <src_file> <dest_file>\n",argv[0]);
		exit(1);
	}
	

	signal(SIGALRM,alrm_handler);
	alarm(1);

	do
	{
		sfd = open(argv[1],O_RDONLY);
		if(sfd < 0)
		{
			if(errno != EINTR)//signal
			{
				perror("open()");
				exit(1);	
			}

		}
	}while(sfd < 0);


	while(1)
	{

		while(token <= 0)
			pause();
		token--;

		while((len = read(sfd,buf,BUFSIZE)) < 0)
		{	if(errno == EINTR)//signal
				continue;
			perror("read()");
			break;
		}
		if(len == 0)
			break;

		//确保写进去 len 个字节
		pos = 0;
		while(len > 0)
		{
			ret = write(dfd,buf+pos,len);
			if(ret < 0)
			{
				if(errno == EINTR) //signal
					continue;
				perror("write()");
				exit(1);
			}
			pos += ret;
			len -= ret;
		}

	}
	
	close(sfd);
		
}

9.3 令牌桶封装成库实例

将上述的令牌桶流量控制的一些细节做进一步优化，并将上述的机制封装成一个库，供后续直接使用。

//mytbf.h
#ifndef MYTBF_H__
#define MYTBF_H__

#define MYTBF_MAX 1024

typedef void mytbf_t;

mytbf_t *mytbf_init(int cps,int burst);

//获取token
int mytbf_fetchtoken(mytbf_t *,int);
//归还token
int mytbf_returntoken(mytbf_t *,int);

int mytbf_destroy(mytbf_t *);

#endif

//mystf.c
#include <asm-generic/errno-base.h>
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

#include "mytbf.h"

struct mytbf_st{
    int csp;
    int burst;
    int token;
    int pos;//任务列表的下标
};

static struct mytbf_st *job[MYTBF_MAX];
static volatile int inited = 0;
static void (*alarm_status)(int);

static int get_free_pos(){
    for (int i = 0;i < MYTBF_MAX;i++){
        if (job[i] == NULL)
          return  i;
    }
    return -1;
}


//信号处理函数
static void handler(int sig){
    alarm(1);
    for (int i = 0;i < MYTBF_MAX;i++){
        if (job[i] != NULL){
            job[i]->token += job[i]->csp;
            if (job[i]->token > job[i]->burst){
                job[i]->token = job[i]->burst;
            }
        }
    }
}

//装载信号处理模块
static void mod_load(){
    alarm_status = signal(SIGALRM,handler);//保存alarm信号处理函数原来的状态
    alarm(1);
}
//卸载信号处理模块 当发生异常退出时 可以将占用的资源释放 将alarm信号取消
static void mod_unload(){
    signal(SIGALRM,alarm_status);
    alarm(0);
    for (int i = 0;i < MYTBF_MAX;i++){
        free(job[i]);
    }
}

mytbf_t *mytbf_init(int cps,int burst){
    struct mytbf_st *tbf;

    if (!inited){
        mod_load();
    }

    //将新的tbf装载到任务组中
    int pos;
    pos = get_free_pos();
    if (pos == -1){
        return NULL;
    }

    tbf = malloc(sizeof(*tbf));
    if (tbf == NULL)
        return NULL;
    tbf->token = 0;
    tbf->csp = cps;
    tbf->burst = burst;
    tbf->pos = pos;
    
    job[pos] = tbf;

    return tbf;
}

//获取token ptr是一个 void * size是用户想要获取的token数
int mytbf_fetchtoken(mytbf_t *ptr,int size){
    struct mytbf_st *tbf = ptr;

    if (size <= 0){
        return -EINVAL;
    }
    
    //有token继续
    while (tbf->token <= 0)
      pause();
    
    int n =tbf->token<size?tbf->token:size;

    tbf->token -= n;
    //用户获取了 n 个token
    return n;
}

//归还token ptr是一个 void *
int mytbf_returntoken(mytbf_t *ptr,int size){
    struct mytbf_st *tbf = ptr;

    if (size <= 0){
        return -EINVAL;
    }
    
    tbf->token += size;
    if (tbf->token > tbf->burst)
        tbf->token = tbf->burst;

    return size;
}

int mytbf_destroy(mytbf_t *ptr){
    struct mytbf_st *tbf = ptr;
    job[tbf->pos] = NULL;
    free(tbf);
    return 0;
}

//main.c
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <signal.h>
#include <math.h>

#include "mytbf.h"

static const int SIZE = 1024;
static const int CPS = 3;
static const int BURST = 100;//最大令牌数

static volatile int token = 0;//持有令牌数

int main(int argc,char** argv)
{
    if (argc < 2){
        fprintf(stdout,"Usage...");
        exit(1);
    }

    mytbf_t *tbf;

    tbf = mytbf_init(CPS,BURST);
    if (tbf == NULL){
        fprintf(stderr,"tbf init error");
        exit(1);
    }

    //打开文件
    int sfd,dfd = 0;
    do{
        sfd = open(argv[1],O_RDONLY);
        if (sfd < 0){
            if (errno == EINTR)
              continue;
            fprintf(stderr,"%s\n",strerror(errno));
            exit(1);
        }
    }while(sfd < 0);

    char buf[SIZE];
    
    while(1){
        
        int len,ret,pos = 0;
        int size = mytbf_fetchtoken(tbf,SIZE);
        
        int i = 0;
        while(i < 2){
            sleep(1);
            i++;
        }

        if (size < 0){
            fprintf(stderr,"mytbf_fetchtoken()%s\n",strerror(-size));
            exit(1);
        }

        len = read(sfd,buf,size);
        while (len < 0){
            if (errno == EINTR)
              continue;
            strerror(errno);
            break;
        }

        //读取结束
        if (len == 0){
            break;
        }

        //要是读到结尾没用完token
        if (size - len > 0){
            mytbf_returntoken(tbf,size-len);
        }

        //以防写入不足
        while(len > 0){
            ret = write(dfd,buf+pos,len);
            while (ret < 0){
                if (errno == EINTR){
                  continue;
                }
                printf("%s\n",strerror(errno));
                exit(1);
            }

            pos += ret;
            len -= ret;
        }
    }

    close(sfd);
    mytbf_destroy(tbf);

    exit(0);
}

9.4 setitimer函数

上面的计时等核心都是通过alarm函数实现的。实际开发过程中，
优先使用setitimer来计时！更灵活而且误差不累积。（计时，优先使用setitimer）
（程序中优先使用setitimer，而不是alarm！！！）

参数：
1、which

TIMER_REAL 以系统真实的时间来计算，时间到了它送出SIGALRM信号。可以代替 alarm
ITIMER_VIRTUAL 以该进程在用户态下花费的时间来计算，它送出SIGVTALRM信号
ITIMER_PROF 以该进程在用户态下和内核态下所费的时间来计算。它送出SIGPROF信号。

2、相关结构体

 struct itimerval {
           struct timeval it_interval; /* Interval for periodic timer */ 设置的定时器时间
           struct timeval it_value;    /* Time until next expiration */ 定时器剩余时间
       };

       struct timeval {
           time_t      tv_sec;         /* seconds */
           suseconds_t tv_usec;        /* microseconds */
       };

下面使用一个alarm或者setitimer计时器来实现多任务计时器的功能。

//流量控制之漏桶实验，用setitimer()实现
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>
#include <sys/time.h>

#define BUFSIZE 10

static volatile int loop = 0;

static void alrm_handler(int s)
{
	//alarm(1);
	loop = 1;
}

int main(int argc,char *argv[])
{
	int sfd,dfd=1;
	char buf[BUFSIZE];
	int len,ret,pos;
	struct itimerval itv;
	if(argc < 2)
	{
		fprintf(stderr,"Usage:%s <src_file> <dest_file>\n",argv[0]);
		exit(1);
	}
	

	signal(SIGALRM,alrm_handler);
	//alarm(1);
	itv.it_interval.tv_sec = 1;
	itv.it_interval.tv_usec = 0;
	itv.it_value.tv_sec = 1;
	itv.it_value.tv_usec = 1;

	if(setitimer(ITIMER_REAL,&itv,NULL) < 0)
	{
		perror("setitimer()");
		exit(1);
	}

	do
	{
		sfd = open(argv[1],O_RDONLY);
		if(sfd < 0)
		{
			if(errno != EINTR)//signal
			{
				perror("open()");
				exit(1);	
			}

		}
	}while(sfd < 0);


	while(1)
	{

		while(!loop)
			pause();
		
		loop = 0;

		while((len = read(sfd,buf,BUFSIZE)) < 0)
		{	if(errno == EINTR)//signal
				continue;
			perror("read()");
			break;
		}
		if(len == 0)
			break;

		//确保写进去 len 个字节
		pos = 0;
		while(len > 0)
		{
			ret = write(dfd,buf+pos,len);
			if(ret < 0)
			{
				if(errno == EINTR) //signal
					continue;
				perror("write()");
				exit(1);
			}
			pos += ret;
			len -= ret;
		}
	}
	close(sfd);	
}

9.5 system

如果想在有信号的程序当中正常使用 system()，需要阻塞SIGCHLD信号，忽略SIGINT信号和SIGQUIT信号

10 信号集

sigemptyset()
sigfillset()
sigaddset()
sigdelset()
sifismember()

1、信号屏蔽字/pending集的处理
sigprocmask():我们无法控制信号何时到来，但可以选择如何响应它

例一：
每秒向标准输出打印一个* 打印五秒换行。程序不受 CTRL+C 即 SIGINT信号影响，收到 SIGINT信号响应信号打印！。

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

void sig_handler(int s)
{
	write(1,"!",1);
}

int main()
{
	int i,j;

	signal(SIGINT,sig_handler);
	for(j=0;j < 1000;j++)
	{

		for(i=0 ; i<5 ; i++)
		{
			write(1,"*",1);
			sleep(1);
		}	
		write(1,"\n",1);
	}


	exit(0);
}

例二：
修改： sigprocmask(SIG_BLOCK…）+ sigprocmask(SIG_UNBLOCK…）只在两行*之间输出！，即选择响应 SIGINT 信号的时间。

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


void sig_handler(int s)
{
	write(1,"!",1);
}

int main()
{
	int i,j;
	sigset_t set;//创建信号集

	signal(SIGINT,sig_handler);
	
	sigemptyset(&set); //清空信号集
	sigaddset(&set,SIGINT); // 添加 SIGINT信号 到信号集


	for(j=0;j < 1000;j++)
	{

		sigprocmask(SIG_BLOCK,&set,NULL); // 对 set信号集中的信号 进行阻塞，即将mask信号屏蔽位置0
		for(i=0 ; i<5 ; i++) 
		{
			write(1,"*",1);
			sleep(1);
		}	
		write(1,"\n",1);
		sigprocmask(SIG_UNBLOCK,&set,NULL); // 对 set信号集中的信号 解除阻塞，即将mask信号屏蔽位置1
	}


	exit(0);
}


mhr@ubuntu:~/Desktop/xitongbiancheng/parallel/signal/test$ 
mhr@ubuntu:~/Desktop/xitongbiancheng/parallel/signal/test$ gcc sigprocmask.c 
mhr@ubuntu:~/Desktop/xitongbiancheng/parallel/signal/test$ ./a.out 
***^C*^C*^C^C^C^C^C
!*^C^C^C^C^C^C*^C^C^C^C^C^C*^C**
!*****
*^C*^C^C^C^C^C*^C^C*^C*
!*****
*****
*****
*****
*****
****^C*^C
!***^C^C**
!*****^\Quit (core dumped)
mhr@ubuntu:~/Desktop/xitongbiancheng/parallel/signal/test$

发现实验中 SIGINT 信号不会打断阻塞的系统调用了。只有 SIG_BLOCK 之后才会，原因同上，因为已经屏蔽了该信号。

例三：
上面的例二有个问题，还是宏观思想的问题，当进入上面这个模块之后，若是SIGINT本身是非阻塞的，那么没有问题，因为这个模块先将信号阻塞然后接触阻塞。如果这个信号进入这个模块前是阻塞的，那么将会出问题，因为从这个模块出去后对SIGINT信号将是非阻塞的！
所以进入每个模块前要先记录资源的原始状态，从模块结束后恢复原状态！

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


void sig_handler(int s)
{
	write(1,"!",1);
}

int main()
{
	int i,j;
	sigset_t set，saveset;//创建信号集

	signal(SIGINT,sig_handler);
	
	sigemptyset(&set); //清空信号集
	sigaddset(&set,SIGINT); // 添加 SIGINT信号 到信号集

//在当前模块修改之前 保存信号集状态，以便 当前模块执行完成后恢复 信号集状态
sigprocmask(SIG_UNBLOCK,&set,&saveset);

	for(j=0;j < 1000;j++)
	{

		sigprocmask(SIG_BLOCK,&set,NULL); // 对 set信号集中的信号 进行阻塞，即将mask信号屏蔽位置0
		for(i=0 ; i<5 ; i++) 
		{
			write(1,"*",1);
			sleep(1);
		}	
		write(1,"\n",1);
		sigprocmask(SIG_UNBLOCK,&set,NULL); // 对 set信号集中的信号 解除阻塞，即将mask信号屏蔽位置1
	}

// 恢复 之前信号集状态
sigprocmask(SIG_SETMASK,&saveset,NULL);

	exit(0);
}

11 sigsuspend() 设置信号集状态与挂起的原子操作

函数功能：
（以下三步为原子操作）

第一步：设置当前进程信号集状态为目标信号集状态mask,并保存进程旧的信号集状态为 oldmask

第二步：马上进入等待信号阶段

第三步：收到信号唤醒后设置当前进程信号集状态为旧的信号集状态oldmask。

例子一：
用pause()实现，打印一行*后，停止等待信号驱动程序继续跑，
pause()休眠等待信号唤醒，CTRL+C 唤醒程序执行打印下一行。

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


void sig_handler(int s)
{
	write(1,"!",1);
}

int main()
{
	int i,j;
	sigset_t set,saveset;

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

	
	sigprocmask(SIG_UNBLOCK,&set,&saveset);

	for(j=0;j < 1000;j++)
	{

		sigprocmask(SIG_BLOCK,&set,NULL); 
		for(i=0 ; i<5 ; i++) 
		{
			write(1,"*",1);
			sleep(1);
		}	
		write(1,"\n",1);
		sigprocmask(SIG_UNBLOCK,&set,NULL); 
 pause();
	}

	sigprocmask(SIG_SETMASK,&saveset,NULL);

	exit(0);
}

mhr@ubuntu:~/Desktop/xitongbiancheng/test$ ./a.out 
*****
^C!*****
^C!**^C***
!

上面需要注意的：

crtl+\ :是终止进程。
crtl+c :也是终止进程。
crtl+z：是将进程挂起，并不是结束进程，可以再次输入fg，将挂起的进程再次运行！
pause，使调用进程（线程）进入休眠状态（就是挂起）；直到接收到信号且信号处理函数成功返回 pause函数才会返回

上面的程序存在问题，如果在当前行打印途中发送 SIGINT信号，不会驱动程序打印下一行数据，这是因为在sigprocmask(SIG_UNBLOCK,&set,NULL); pause()这两个函数中间，当解除信号阻塞之后，还没来得及执行pause()，就把 SIGINT信号响应掉了，所以信号就作用不到 pause()，即不会唤醒进程，程序响应 SIGINT信号之后，打印！再执行到 pause()。我们知道，程序在运行当中可以理解为时时刻刻都在被中断，时间片一直在反复的耗尽，也就是反复进入内核态等待调度，再继续执行程序，所以此时刚刚好从内核态切换回用户态，发现SIGINT信号，于是马上响应信号动作。我们的初衷是执行完解除阻塞后，马上pause()挂起，最后SIGINT信号作用到 pause()上，打印下一行，所以这个问题的原因就是 sigprocmask(SIG_UNBLOCK,&set,NULL) 与 pause() 这两个操作组合是非原子操作，是不原子的。

例二：
修改：用 sigsuspend()实现

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


void sig_handler(int s)
{
	write(1,"!",1);
}

int main()
{
	int i,j;
	sigset_t set,saveset,oset;

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

	
	sigprocmask(SIG_UNBLOCK,&set,&saveset);//保存进入该模块前的状态

	sigprocmask(SIG_BLOCK,&set,&oset); 
	for(j=0;j < 1000;j++)
	{

		
		for(i=0 ; i<5 ; i++) 
		{
			write(1,"*",1);
			sleep(1);
		}	
		write(1,"\n",1);
		
		sigsuspend(&oset);
	}

	sigprocmask(SIG_SETMASK,&saveset,NULL);//恢复进入该模块前的状态

	exit(0);
}

mhr@ubuntu:~/Desktop/xitongbiancheng/parallel/signal/test$ 
mhr@ubuntu:~/Desktop/xitongbiancheng/parallel/signal/test$ 
mhr@ubuntu:~/Desktop/xitongbiancheng/parallel/signal/test$ gcc sigsuspend.c 
mhr@ubuntu:~/Desktop/xitongbiancheng/parallel/signal/test$ ./a.out 
*****
^C!*****
^C!**^C*^C^C**
!*****
^C!**^\Quit (core dumped)
mhr@ubuntu:~/Desktop/xitongbiancheng/parallel/signal/test$

12 sigaction(),区别于 signal()

signal()的缺陷1 ：当多个信号共用一个信号处理函数的时候，可能会发生重入，导致段错误。所以我们希望，在响应一个信号的时候，将其他信号阻塞。 sigaction()可以弥补
signal()的缺陷2 ：不能指定接收信号来源， sigaction()可以弥补.

signal()的缺陷1 试验：当多个信号共用一个信号处理函数的时候，可能会发生重入。以前面的守护进程为例：

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <syslog.h>

#define FILENAME "/tmp/out"

static int craetdeamon(void)
{
	pid_t pid;
	int fd;	
	
	pid = fork();
	if(pid < 0)
	{
		perror("fork()");
		return -1;
	}

	if(pid > 0)
	{
		printf("%d\n",getpid());
		exit(0);
	}

	fd = open("/dev/null",O_RDWR);
	if(fd < 0)
	{	
		perror("open()");
		return -1;
	}

	dup2(fd,0);
	dup2(fd,1);
	dup2(fd,2);	
	if(fd > 2)
	{
		close(fd);
	}
	setsid();return

	chdir("/");
	return 0;
}

static void exitdeamon(int s)
{
	fclose(fb);
	closelog();
}


int main(int argc,char* argv[])
{
	FILE* fp;
	int i;

signal(SIGINT,exitdeamon);
signal(SIGQUIT,exitdeamon);
signal(SIGTERM,exitdeamon);

	openlog("craetdeamon",LOG_PID,LOG_DAEMON);
	if(craetdeamon())
	{
		syslog(LOG_ERR,"craetdeamon failed!");
		exit(1);
	}else{
		syslog(LOG_INFO,"craetdeamon successded!");
	}

	fp = fopen(FILENAME,"w");
	if(fp == NULL)
	{
		syslog(LOG_ERR,"fopen %s failed!",FILENAME);
		exit(1);
	}

	syslog(LOG_INFO,"fopen %s successede!",FILENAME);

	for(i = 0; ;i++)
	{
		fprintf(fp,"%d\n",i);
		fflush(fp);
		syslog(LOG_DEBUG,"%d is printed!",i);
		sleep(1);
	}
	exit(0);

}

程序的本意是，守护进程接收到 SIGINT，SIGQUIT，SIGTERM 三个信号任意信号的时候终止守护进程，多个信号共用一个信号处理函数。但是有一个问题：
-接收到这三个信号中的任意信号，都会执行处理函数中内容，假如有这样的情形：

1 程序接受到了 SIGINT 信号，程序收到中断后扎内核，被调度后，从内核态切换到用户态，发现收到了 SIGINT信号，于是开始执行处理函数，但是只执行了 fclose(fb); 这一句，就再次被打断，进程内核态，等待调度。
2 在等待调度的时候，程序又收到了 SIGQUIT 信号，等到程序被调度，从内核态切换到用户态时候，发现收到了 SIGQUIT信号，于是再次执行信号处理函数，再次执行到 fclose(fb);。于是fb 被两次 fclose(),会发生段错误。发生了重入！！

用 sigaction() 实现多信号共用一个处理函数。

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

#define FILENAME "/tmp/out"

static FILE* fp;

static int craetdeamon(void)
{
	pid_t pid;
	int fd;	

	pid = fork();
	if(pid < 0)
	{
		perror("fork()");
		return -1;
	}

	if(pid > 0)
	{
		printf("%d\n",getpid());
		exit(0);
	}

	fd = open("/dev/null",O_RDWR);
	if(fd < 0)
	{	
		perror("open()");
		return -1;
	}

	dup2(fd,0);
	dup2(fd,1);
	dup2(fd,2);	
	if(fd > 2)
	{
		close(fd);
	}
	setsid();return
	chdir("/");
	return 0;

}

static void exitdeamon(int s)
{
	fclose(fp);
	closelog();
}



int main(int argc,char* argv[])
{
	int i;
	struct sigaction sa;


	sa.sa_handler = exitdeamon;
	sigemptyset(&sa.sa_mask);
	sigaddset(&sa.sa_mask,SIGQUIT);
	sigaddset(&sa.sa_mask,SIGTERM);
	sigaddset(&sa.sa_mask,SIGINT);

	sigaction(SIGINT,&sa,NULL);
	sigaction(SIGTERM,&sa,NULL);
	sigaction(SIGQUIT,&sa,NULL);

	openlog("craetdeamon",LOG_PID,LOG_DAEMON);

	if(craetdeamon())
	{
		syslog(LOG_ERR,"craetdeamon failed!");
		exit(1);
	}else{
		syslog(LOG_INFO,"craetdeamon successded!");
	}


	fp = fopen(FILENAME,"w");
	if(fp == NULL)
	{
		syslog(LOG_ERR,"fopen %s failed!",FILENAME);
		exit(1);
	}

	syslog(LOG_INFO,"fopen %s successede!",FILENAME);

	for(i = 0; ;i++)
	{
	fprintf(fp,"%d\n",i);
		fflush(fp);
		syslog(LOG_DEBUG,"%d is printed!",i);
		sleep(1);
	}

	exit(0);

}

signal()缺陷2：不能识别信号来源

回顾之前的流量控制（流量控制的库）：
在终端1 运行：

mhr@ubuntu:~/Desktop/xitongbiancheng/parallel/signal/test$ ./a.out /etc/services

在终端2 运行

mhr@ubuntu:~/Desktop/xitongbiancheng/parallel/signal/test$ while true ; do kill -ALRM 10405 ;done

会发现程序会瞬间执行完成。即从其他终端以用户的角度向指定进程不停的发送 ALRM 信号，导致流控失效。问题在于 signal() 并不会检查区分信号的来源，属性信息，只要来了该信号，就会响应动作。但是实际上程序利用 alarm来发送信号，实际上 alarm信号是从 kernel 发送过来的，而刚刚的实验信号，是从user 发送的。所以需要指定只响应从某处来的信号，即指定信号来源，指定从 kernel来的信号，signal() 无法完成该动作，sigaction()可以。

利用sigactino修改后的版本：

//信号处理函数
static void handler(int sig,siginfo_t *infop,void *unused){
    struct itimerval itv;

    if (infop->si_code != SI_KERNEL){
        return ;
    }

    itv.it_interval.tv_sec = 1;
    itv.it_interval.tv_usec = 0;
    itv.it_value.tv_sec = 1;
    itv.it_value.tv_usec = 0;
    if(setitimer(ITIMER_REAL,&itv,NULL) < 0){
        perror("setitimer()");
        exit(1);
    }
    for (int i = 0;i < MYTBF_MAX;i++){
        if (job[i] != NULL){
            job[i]->token += job[i]->csp;
            if (job[i]->token > job[i]->burst){
                job[i]->token = job[i]->burst;
            }
        }
    }
}

//装载信号处理模块
static void mod_load(){
    struct sigaction sa;
    sa.sa_sigaction = handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_SIGINFO;

    if (sigaction(SIGALRM,&sa,&old_sa) < 0){
        perror("sigaction()");
        exit(1);
    }


    struct itimerval itv;
    itv.it_interval.tv_sec = 1;
    itv.it_interval.tv_usec = 0;
    itv.it_value.tv_sec = 1;
    itv.it_value.tv_usec = 0;
    if(setitimer(ITIMER_REAL,&itv,&old_itv) < 0){
        perror("setitimer()");
        exit(1);
    }
}
//卸载信号处理模块 当发生异常退出时 可以将占用的资源释放 将alarm信号取消
static void mod_unload(){
   //signal(SIGALRM,alarm_status);
   sigaction(SIGALRM,&old_sa,NULL);
   
   //恢复时钟信号状态
    struct itimerval itv;
    itv.it_interval.tv_sec = 0;
    itv.it_interval.tv_usec = 0;
    itv.it_value.tv_sec = 0;
    itv.it_value.tv_usec = 0;
    if(setitimer(ITIMER_REAL,&itv,&old_itv) < 0){
        perror("setitimer()");
        exit(1);
    }

    for (int i = 0;i < MYTBF_MAX;i++){
        free(job[i]);
    }
}

13 实时信号

如果一个进程既受到标准信号，又受到实时信号，那么先响应标准信号后相应实时信号。

标准信号特点：

1 标准信号会丢失
2 标准信号没有一个严格的响应顺序要求，未定义行为。

标准信号中有两个未定义行为的信号，留给我们使用：SIGUSR1,SIGUSR2

实时信号用于解决标准信号的不足：

1 实时信号不会丢失
2 实时信号响应有顺序要求

实时信号的例子：
选择40) SIGRTMIN+6 信号举例

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

#define MYRTSIGNAL (SIGRTMIN+6)

void sig_handler(int s)
{
	write(1,"!",1);
}

int main()
{
	int i,j;
	sigset_t set,saveset,oset;

	signal(MYRTSIGNAL,sig_handler);
	
	sigemptyset(&set); 
	sigaddset(&set,MYRTSIGNAL); 

	
	sigprocmask(SIG_UNBLOCK,&set,&saveset);

	sigprocmask(SIG_BLOCK,&set,&oset); 
	for(j=0;j < 1000;j++)
	{

		
		for(i=0 ; i<5 ; i++) 
		{
			write(1,"*",1);
			sleep(1);
		}	
		write(1,"\n",1);
		
		sigsuspend(&oset);
	}

	sigprocmask(SIG_SETMASK,&saveset,NULL);

	exit(0);
}

在这里插入图片描述

发现实时信号不会丢失，连续发送三次信号，如果是标准信号，只会响应一次，而实时信号响应了三次。

标签：--,signal,编程,int,exit,信号,LINUX,include,alarm
来源： https://blog.csdn.net/luseysd/article/details/120321481

LINUX系统编程-- 5 信号