Linux C系统编程-进程之间的通信信号（五）

进程之间的通信方式–信号

信号kill命令

使用"kill -l"命令查看所有的信号。 "kill"命令在linux下不是"杀死"含义，而是专门用于发送信号。 “-l” list
1，2，3…64代表信号值
SIG代表信号前缀
HUP代表信号名字

这些宏定义是被定义在一个信号专属的头文件： /usr/include/asm-generic/signal.h
给进程PID号发送信号 ： kill命令
1.使用格式： kill -信号值 进程的PID号

9. SIGKILL :杀死进程，进程收到该信号时，会马上退出。

例如：
编写一个循环

int main(int argc,char *argv[])
{
	int i;
	while(1)
	{
		printf("%d\n",i++);
		sleep(1);
	}

}

ps -ef

UID   PID    PPID   C   STIME    TTY     TIME      CMD
jj    5120   4929   0   08:36    PTS/19  00:00:00  ./aaa

发送9信号给进程，进程收到信号马上退出！
kill -SIGKILL 5120

2.给进程的名字发送信号 -> killall命令
使用格式： killall -信号值 进程的名字

~$ killall -9 bash
killall -SIGKILL bash

3.在程序中使用kill函数来发送信号给别的进程。 -> kill() -> man 2 kill
功能： kill - send signal to a process
使用格式：
pid： 发送目标的PID号
sig： 需要发送的信号值

信号的捕捉

1.其实就是进程在收到某个信号之前，必须提前约定好将来收到该信号时需要处理什么事情。

进程1先捕捉SIGUSR1，收到信号就处理某件事情。 --> 进程2发送信号给进程1 --> 进程1收到信号，就会马上处理事情。
进程2发送信号给进程1 --> 进程1捕捉SIGUSR1，收到信号就处理某件事情。 --> 进程1不会处理这个事情。

2.捕捉信号函数
signal() -> man 2 signal
功能： signal - ANSI C signal handling -> 处理信号
提前约定好，将来收到某个信号，我需要做什么事情。

使用格式：
signum：需要捕捉的信号值
handler： 是一个函数指针 类型：void (*)(int) -> 收到信号之后，会执行的函数
返回值：
成功：处理函数的地址
失败：NULL ->SIGERR

例如：
void fun(int sig) -> 这个就是捕捉的信号值
{
}

signal(SIGUSR1,fun); fun必须是void返回值，只有一个int类型的参数。
让子进程发送信号给父进程，父进程收到信号后，如果是SIGUSR1，则打印hello，如果是SIGUSR2,则打印apple。

void fun1(int sig)
{
	printf("hello!\n");
}

void fun2(int sig)
{
	printf("apple!\n");
}

int main()
{
	//产生一个子进程
	pid_t x;
	x = fork();
	if(x > 0)
	{
		//父进程先提前约定好，将来收到信号时需要什么任务。
		signal(SIGUSR1,fun1);
		signal(SIGUSR2,fun2);
		wait(NULL);
		exit(0);
	}
	
	if(x == 0)
	{
		usleep(100000);
		kill(getppid(),SIGUSR1);
		sleep(5);
		kill(getppid(),SIGUSR2);
		exit(0);
	}

	return 0;
}

信号捕捉函数signal的第二个参数
which is either SIG_IGN, SIG_DFL, or the address of a programmer-defined function (a “signal handler”).
SIG_IGN -> 收到信号，就会忽略信号。
SIG_DFL -> 收到信号，则执行信号的默认动作。
the address of a programmer-defined function -> 信号处理函数 void(*)(int) -> 收到信号时，会执行函数。

The signals SIGKILL and SIGSTOP cannot be caught or ignored.
//SIGKILL与SIGSTOP信号不可被捕捉/忽略，当进程收到这两个信号时，一定要响应！

“ctrl + C” 等价于 2) SIGINT 按下"ctrl + C" -> 默认动作回到终端上。

pause and raise

pause() 一般与signal连用。
挂起进程，直到收到一个信号为止。

signal(SIGUSR1,fun);
pause(); // 暂时不会往下运行代码，直到收到某个可以捕捉的信号，就会继续往下执行代码。

功能： wait for signal -> 等待一个信号
返回值：
收到可以捕捉的信号时 -1
收到致命的信号时，直接退出

raise() 自己给自己发信号。
功能： send a signal to the caller 给发送者发送一个信号。
sig： 需要给自己发送的信号值 raise(sig) 等价于 kill(getpid(), sig);

信号集

信号集就是一堆信号的集合。信号集为了可以同时操作多个信号。如果将若干个信号加入到信号集中，那么给信号集设置阻塞属性，那么在信号集中所有信号都会阻塞的属性。

信号忽略：如果忽略某个信号，当别的进程发送该信号给自己时，就等于是没有收到该信号。

例如：
signal(SIGUSR1,SIG_IGN);
pause(); -> 程序会阻塞到这个地方，即使收到SIGUSR1，也会阻塞。
printf(“hello!\n”);

信号阻塞：如果设置了对某个信号阻塞，那么将来收到这个信号时，暂时不能响应该信号，而是将该信号放置在挂起队列上，等到解除对所有信号的阻塞之后，就可以响应挂起队列上的信号。

在linux下，只能对信号集设置阻塞属性，所以说对信号设置阻塞之前，首先将信号加入信号集，再设置信号集的属性为阻塞。
信号集其实一个变量，定义了一个变量，等于定义了一个信号集。

1.关于信号集处理函数
1）清空信号集中所有的信号
int sigemptyset(sigset_t *set);

2）将linux所有信号一次性添加到信号集
int sigfillset(sigset_t *set);

3）将某个信号添加到信号集中
int sigaddset(sigset_t *set, int signum);

4）从信号集中删除某个信号
int sigdelset(sigset_t *set, int signum);

5）测试某个信号值是否为信号集的成员
int sigismember(const sigset_t *set, int signum);

2.sigprocmask()
功能： sigprocmask - change blocked signals//给信号设置阻塞的属性。

SIG_BLOCK -> 设置参数二set为阻塞状态
SIG_UNBLOCK -> 设置参数二set为非阻塞状态
set： 需要设置属性的信号集地址
oset： 保存原有的状态，如果不关注原有的状态，则设置为NULL。

验证信号阻塞情况。
父进程:对某个信号阻塞10秒，10秒之后解除阻塞
子进程 : 在5秒发送该信号给父进程，看看在多少秒会响应。

void fun(int sig)
{
	printf("sig = %d\n",sig);
}

int main()
{
	pid_t x;
	x = fork();
	if(x > 0)
	{
		//0. 首先捕捉信号
		signal(SIGUSR1,fun);
		
		//1. 定义一个信号集
		sigset_t set;
		
		//2. 清空信号集
		sigemptyset(&set);
		
		//3. 将SIGUSR1加入到信号集
		sigaddset(&set,SIGUSR1);
		
		//4. 判断信号是否在信号集中
		int ret,i;
		ret = sigismember(&set,SIGUSR1);
		if(ret <= 0)
			printf("not a member!\n");
		
		//5. 设置信号集为阻塞属性
		sigprocmask(SIG_BLOCK,&set,NULL);
		
		//6. 将阻塞的状态持续10秒
		for(i=10;i>0;i--)
		{
			sleep(1);
			printf("%d\n",i);
		}
		
		//7. 解除阻塞状态
		sigprocmask(SIG_UNBLOCK,&set,NULL);
		
		wait(NULL);
		exit(0);
	}
	
	if(x == 0)
	{
		sleep(5);
		kill(getppid(),SIGUSR1);
		printf("I send signal to parent!\n");
		exit(0);
	}
	
	return 0;
}

结果：
5秒： 子进程已经发送信号给父进程。
10秒： 父进程才会响应该信号。