A comunicação entre processos linux - Signal

Sinal é conjunto SIG_BLOCK

Quando um sinal é enviado para o kernel, não enviado para o processo. Mas quando o bloqueio seja limpo ou sinal bloqueado é enviado para o processo.

sinal pendente pode ser detectada da seguinte maneira

//获取当前的阻塞未决信号
if(sigpending(&pendset) < 0)
{
	perror("sigpending error!");
	exit(1);
}else
{
	//查询当前的未决信号中是否有SIGINT中
	if(sigismember(&pendset, SIGINT))
	{
        //todo
    }else
    {
        //to do
    }
}

 

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


void handle_signale_func(int sig);
void handle_signale_alarm(int sig);

int main(int argc, char *argv[])
{

	sigset_t set, pendset;

	struct sigaction action1, action2;

//	signal(SIGALRM, handle_signale_alarm);

	//5秒闹钟信号到，给进程发送结束信号
//	alarm(5);

	
	//初始化信号集合
	if(sigemptyset(&set) < 0)
	{
		perror("sigemptyset error!");
		exit(1);	
	}

	//信号加入到集合中
	if(sigaddset(&set, SIGQUIT) < 0)
	{
		perror("sigaddset error!");
		exit(1);
	}

	if(sigaddset(&set, SIGINT) < 0)
	{
		perror("sigaddset SIGINT error!");
		exit(1);
	}

	//检查信号是否在集合当中
	if(sigismember(&set, SIGINT))
	{
		sigemptyset(&action1.sa_mask);
		action1.sa_handler = handle_signale_func;
		action1.sa_flags = 0;
		sigaction(SIGINT, &action1, NULL);
	}

	
	if(sigismember(&set, SIGQUIT))
	{
		sigemptyset(&action2.sa_mask);
		action2.sa_handler = SIG_DFL; 
		action2.sa_flags = 0;
		sigaction(SIGQUIT, &action2, NULL);
	}


	//设置信号屏蔽字
	if(sigprocmask(SIG_BLOCK, &set, NULL) < 0)
	{
		perror("sigprocmask error!");
		exit(1);
	}else
	{
		printf("signal set blocked , Press any key!\n");
		getchar();
	}
	
	//删除一个信号集
	if(sigprocmask(SIG_UNBLOCK, &set, NULL) < 0)
	{
		perror("sigprocmask SIG_UNBLOCK error!");
		exit(1);
	}else
	{
		printf("signal set unblock state!\n");
	}

#if 0
	//获取当前的阻塞未决信号
	if(sigpending(&pendset) < 0)
	{
		perror("sigpending error!");
		exit(1);
	}else
	{
		//查询当前的未决信号中是否有SIGINT中
		if(sigismember(&pendset, SIGINT))
		{
			printf("cur pending signal is SIGINT \n");	
		}else
		{
			printf("the process exist peend sig, but, dont SIGINT!\n");
		}
	}

	//删除一个信号集
	if(sigprocmask(SIG_UNBLOCK, &set, NULL) < 0)
	{
		perror("sigprocmask SIG_UNBLOCK error!");
		exit(1);
	}else
	{
		printf("signal set unblock state!\n");
	}

		
	while(1)
	{
		
		//获取当前的阻塞未决信号
		if(sigpending(&pendset) < 0)
		{
			perror("sigpending error!");
			exit(1);
		}else
		{
			//查询当前的未决信号中是否有SIGINT中
			if(sigismember(&pendset, SIGINT))
			{
				printf("cur pending signal is SIGINT \n");	
			}else
			{
				printf("the process exist peend sig, but, dont SIGINT!\n");
			}
		}
		sleep(1);
	}
#endif
	while(1);
	exit(0);

}
void handle_signale_func(int sig)
{

	printf("你杀不死我!\n");

}

void handle_signale_alarm(int sig)
{
	printf("handle_signale_alarm pid:%d\n", getpid());
	kill(getpid(), SIGHUP);
}

resumo:

1, o processamento de sinal do caminho pesado: Ignorar (SIG_IGN), padrão (SIG_DFL), cadastre-se uma margem de apreciação de retorno (sinal)

2, kill envia um sinal para o processo especificado, raise pode enviar um sinal para si mesmo

3, o sinal é mascarado e não é descartada, mas é salva temporariamente. Espere até desmascarado, ou será enviado para o processo de