进程间通信--信号

1：信号

什么是信号？
信号是给程序提供一种可以处理异步事件的方法，它利用软件中断来实现。不能自定义信号，所有信号都是系统预定义的。

信号由谁产生？

1)由shell终端根据当前发生的错误（段错误、非法指令等）Ctrl+c而产生相应的信号
比如：
socket通信或者管道通信,如果读端都已经关闭，执行写操作（或者发送数据），
将导致执行写操作的进程收到SIGPIPE信号（表示管道破裂）
该信号的默认行为：终止该进程。
2) 在shell终端，使用kill或killall命令产生信号
./demo & //选择在后台运行该程序
kill -HUP 13733 /* 向PID为13733的进程发送SIGHUP */
kill命令详解

3 ) 在程序代码中，调用kill系统调用产生信号

2：有哪些信号？

常用信号

信号名称 			说明
-------------------------------------------
SIGABORT		进程异常终止
SIGALRM 	    超时告警
SIGFPE 			浮点运算异常
SIGHUP 			连接挂断
SIGILL 		    非法指令
SIGINT 			终端中断  (Ctrl+C将产生该信号)
SIGKILL 	   *终止进程                             
SIGPIPE 		向没有读进程的管道写数据
SIGQUIT 		终端退出（Ctrl+\将产生该信号）
SIGSEGV 		无效内存段访问
SIGTERM 		终止
SIGUSR1        *用户自定义信号1
SIGUSR2        *用户自定义信号2 
-------------------------------------->以上信号如果不被捕获，则进程接受到后都会终止！
SIGCHLD 		子进程已停止或退出
SIGCONT 	   *让暂停的进程继续执行
SIGSTOP 	   *停止执行(即“暂停")
SIGTSTP 		中断挂起
SIGTTIN 		后台进程尝试读操作
SIGTTOU 		后台进程尝试写
-------------------------------------------
我们用程序输出对应的编号
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include
#include
#include

int main()
{
  printf("SIGABRT:%d \n",SIGABRT);
  printf("SIGALRM:%d \n",SIGALRM);
  printf("SIGFPE:%d \n",SIGFPE);
  printf("SIGHUP:%d \n",SIGHUP);
  printf("SIGILL:%d \n",SIGILL);
  printf("SIGINT:%d \n",SIGINT);
  printf("SIGKILL:%d \n",SIGKILL);
  printf("SIGPIPE:%d \n",SIGPIPE);
  printf("SIGQUIT:%d \n",SIGQUIT);
  printf("SIGSEGV:%d \n",SIGSEGV);
  printf("SIGTERM:%d \n",SIGTERM);
  printf("SIGUSR1:%d \n",SIGUSR1);
  printf("SIGUSR2:%d \n",SIGUSR2);
  printf("SIGCHLD:%d \n",SIGCHLD);
  printf("SIGCONT:%d \n",SIGCONT);
  printf("SIGSTOP:%d \n",SIGSTOP);
  printf("SIGTSTP:%d \n",SIGTSTP);
  printf("SIGTTIN:%d \n",SIGTTIN);
  printf("SIGTTOU:%d \n",SIGTTOU);
  return 0;
}
~ 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

结果如下：

3：信号的处理方式？

忽略此信号
捕捉信号，指定信号处理函数进行处理
执行系统默认动作，大多数都是终止进程

3.1 信号的捕获

信号的捕获，是指，指定接受到某种信号后，去执行指定的函数。
注意：SIGKILL和SIGSTOP不能被捕获，即，这两种信号的响应动作不能被改变。
信号的安装
1) 使用signal
用法：man 2 signal

     typedef void (*sighandler_t)(int);
     sighandler_t signal(int signum, sighandler_t handler);
     
    注：signal的返回类型，和它的第二个参数，都是函数指针类型
          
    signal的参数2可去以下特殊值：
    SIG_IGN     忽略信号
    SIG_DFL     恢复默认行为
1
2
3
4
5
6
7
8

//程序运行后 按ctrl c会产生SIGINT的信号 我们自定义回调函数去响应它
#include 
#include 
#include 


void myhandle(int sig) 
{
	printf("Catch a signal : %d\n", sig);
}

int main(void) 
{

	signal(SIGINT, myhandle);
	while (1) {
            sleep(1);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

上面cpp 捕捉函数 用myhandle处理函数去处理对应的信号SIGINT 也就是ctrl+c

    此时就不能结束该进程了！
    只能通过其他终端，给该进程发送一个其他信号，使它终止
         #ps -ef | grep ./demo      //查询进程号  demo是指自己编译出来的exe文件
         #kill  -HUP  进程号      
1
2
3
4

#include
#include
#include
#include

void myhandle(int sig)
{
   printf("catch a signal:%d \n",sig);
   signal(SIGINT,SIG_DFL);
}
int main(void)
{
  signal(SIGINT,myhandle);
  while(1)
  {
    sleep(1);
  }
  return 0;
}
~     
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

上面代码是响应函数myhandle之后 信号就恢复其默认行为 即在此直接终止掉该程序

2 ) 使用sigaction （项目实战强烈推荐使用）
sigaction与signal的区别： sigaction比signal更“健壮”，建议使用sigaction

   用法：man 2 sigaction
   
   结构struct sigaction 
   struct sigaction {
        void (*sa_handler)(int);   /* 信号的响应函数 */
        sigset_t   sa_mask;          /* 屏蔽信号集 */                         
        int sa_flags;                /* 当sa_flags中包含 SA_RESETHAND时，接受到该信号并调用指
        定的信号处理函数执行之后，把该信号的响应行为重置为默认行为SIG_DFL */
        ...
    }
    
    补充：
    当sa_mask包含某个信号A时，则在信号处理函数执行期间，如果发生了该信号A，
     则阻塞该信号A(即暂时不响应该信号），直到信号处理函数执行结束。
     即，信号处理函数执行完之后，再响应该信号A
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#include 
#include 
#include 

void myhandle(int sig) 
{
	printf("Catch a signal : %d\n", sig);
}

int main(void) 
{
	struct sigaction act;

	act.sa_handler = myhandle;
	sigemptyset(&act.sa_mask);
       act.sa_flags = 0;

	sigaction(SIGINT, &act, 0);

	while (1) {
        
	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

//这段代码sigaction运行后信号以默认的行为运行
#include 
#include 
#include 

void myhandle(int sig) 
{
	printf("Catch a signal : %d\n", sig);
}

int main(void) 
{
	struct sigaction act;

	act.sa_handler = myhandle;
	sigemptyset(&act.sa_mask);
	//act.sa_flags = 0;
	act.sa_flags = SA_RESETHAND;

	sigaction(SIGINT, &act, 0);

	while (1) {

	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

3.2信号的发送

信号的发送方式：

（1） 在shell终端用快捷键产生信号
（2） 使用kill，killall命令。
（3） 使用kill函数和alarm函数

使用kill函数
给指定的进程发送指定信号
用法：man 2 kill
注意：
给指定的进程发送信号需要“权限”：
普通用户的进程只能给该用户的其他进程发送信号
root用户可以给所有用户的进程发送信号
kill失败
失败时返回-1
失败原因：
权限不够
信号不存在
指定的进程不存在
实例1：
创建一个子进程,子进程每秒中输出字符串“child process work!",父进程等待用户输入，如果用户按下字符A, 则向子进程发信号SIGUSR1, 子进程的输出字符串改为大写; 如果用户按下字符a, 则向子进程发信号SIGUSR2, 子进程的输出字符串改为小写

#include 
#include 
#include 

int workflag = 0;

void work_up_handle(int sig)
{
        workflag = 1;
}

void work_down_handle(int sig)
{
        workflag = 0;
}


int main(void)
{
        pid_t pd;
        char c;

		//注意fork函数 子进程返回0 父进程返回子进程的pid
        pd = fork();
        
        if (pd == -1) {
                printf("fork error!\n");
                exit(1);
        } else if (pd == 0) {
                char *msg;
                struct sigaction act;
                act.sa_flags = 0;
                act.sa_handler = work_up_handle;
                sigemptyset(&act.sa_mask);
                sigaction(SIGUSR1, &act, 0);
                 act.sa_handler = work_down_handle;
                sigaction(SIGUSR2, &act, 0);

                while (1) {
                        if (!workflag) {
                                msg = "child process work!";
                        } else {
                                msg = "CHILD PROCESS WORK!";
                        }
                        printf("%s\n", msg);
                        sleep(1);
                }

        } else {

                while(1) {
                        c = getchar();
                        printf("my pid:%d \n",pd);
                        printf("i Get c:%c \n",c);
                        if (c == 'A') {
                                kill(pd, SIGUSR1);
                        } else if (c == 'a') {
                                kill(pd, SIGUSR2);
                        }
                }
        }


        return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

实例:2
创建一个子进程,子进程在5秒钟之后给父进程发送一个SIGALR,父进程收到SIGALRM信号之后，“闹铃”（用打印模拟）

#include 
#include 
#include 

int wakeflag = 0;

void wake_handle(int sig) 
{
	wakeflag = 1;
}

int main(void) 
{
	pid_t pd;
	char c;


	pd = fork();
	if (pd == -1) {
		printf("fork error!\n");
		exit(1);
	} else if (pd == 0) {
		sleep(5);
		kill(getppid(), SIGALRM);
	} else {
		struct sigaction act; 
		act.sa_handler = wake_handle;
		act.sa_flags = 0;
		sigemptyset(&act.sa_mask);

		sigaction(SIGALRM,  &act, 0);

		pause(); //把该进程挂起，直到收到任意一个信号

		if (wakeflag) {
			printf("Alarm clock work!!!\n");
		}
	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

上面的实现方法还可以改写成alarm的方式
2)使用alarm函数
作用：在指定时间之内给该进程本身发送一个SIGALRM信号。
用法：man 2 alarm
注意：时间的单位是“秒”
实际闹钟时间比指定的时间要大一点。
如果参数为0，则取消已设置的闹钟。
如果闹钟时间还没有到，再次调用alarm,则闹钟将重新定时
每个进程最多只能使用一个闹钟。

    返回值：
             失败：返回-1
             成功：返回上次闹钟的剩余时间（秒）
1
2
3

#include 
#include 
#include 
#include 

int wakeflag = 0;

void wake_handle(int sig) 
{
	wakeflag = 1;
}

int main(void) 
{
	int ret;
	
	struct sigaction act;
	act.sa_flags = 0;
	act.sa_handler = wake_handle;
	sigemptyset(&act.sa_mask);
	sigaction(SIGALRM, &act, 0);
	
	printf("time =%ld\n", time((time_t*)0));

	ret = alarm(5);
	if (ret == -1) {
		printf("alarm error!\n");
		exit(1);
	}

	//挂起当前进程，直到收到任意一个信号
	pause();

	if (wakeflag) {
		printf("wake up, time =%ld\n", time((time_t*)0));
	}

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

3. 使用raise
   给本进程自身发送信号。
   原型： int raise (int sig)

3.3发送多个信号

进程同时接受到多个函数应该如何处理？
某进程正在执行某个信号对应的操作函数期间（该信号的安装函数），如果此时，该进程又多次收到同一个信号（同一种信号值的信号），
则：如果该信号是不可靠信号（<32），则只能再响应一次。
如果该信号是可靠信号（>32），则能再响应多次（不会遗漏）。但是，都是都必须等该次响应函数执行完之后，才能响应下一次。

某进程正在执行某个信号对应的操作函数期间（该信号的安装函数），如果此时，该进程收到另一个信号（不同信号值的信号），则：
如果该信号被包含在当前信号的signaction的sa_mask（信号屏蔽集）中，则不会立即处理该信号。直到当前的信号处理函数执行完之后，才去执行该信号的处理函数。
否则：
则立即中断当前执行过程（如果处于睡眠，比如sleep, 则立即被唤醒）而去执行这个新的信号响应。新的响应执行完之后，再在返回至原来的信号处理函数继续执行。

#include
#include
#include
#include

static int cut=1;
void myhandle(int sig)
{
   printf("catch a signal:%d \n",sig);
   cut++;
   for(int i=0;i<2e6-1;i++)
   {
     printf("cut:%d \n",cut);
   }
   printf("over!!!\n");
}
int main(void)
{
  struct sigaction act;
  act.sa_handler = myhandle;
  sigemptyset(&act.sa_mask);
  //如果没有下面这句 那么执行SIGINT的时候 接收到SIGUSR1的时候 会立刻执行对于的回调函数 把当前执行的给中止 
  //有下面一句 对于的就会等待SIGINT执行完再执行一次
  sigaddset(&act.sa_mask, SIGUSR1);
  act.sa_flags = 0;

  sigaction(SIGINT,&act,0);
  sigaction(SIGUSR1,&act,0);
  while(1)
  {
    sleep(1);
  }
  return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

3.4信号集？

1). 什么是信号集
    信号集，用sigset_t类型表示，实质是一个无符号长整形。
    用来表示包含多个信号的集合。
      2). 信号集的基本操作
    sigemptyset       把信号集清空
    sigfillset          把所有已定义的信号填充到指定信号集
    sigdelset         从指定的信号集中删除指定的信号
    sigaddset        从指定的信号集中添加指定的信号
    
    sigismember   判断指定的信号是否在指定的信号集中
                              如果是，    返回 1
                              如果不是， 返回 0
                              信号无效， 返回-1
            
    详细用法见  man 
    
3) 进程的“信号屏蔽字”
    进程的“信号屏蔽字”是一个信号集
    想目标进程发送某信号时，如果这个信号在目标进程的信号屏蔽字中，//注意 该信号屏蔽字对进程有作用
    则目标进程将不会捕获到该信号，即不会执行该信号的处理函数。
    当该进程的信号屏蔽字不再包含该信号时，则会捕获这个早已收到的信号（执行对应的函数）
            
    修改进程的“信号屏蔽字”
    使用sigprocmask
    int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
    
    参数:
         how:
               SIG_BLOCK    把参数set中的信号添加到信号屏蔽字中
               SIG_UNBLOCK  把参数set中的信号从信号屏蔽字中删除
               SIG_SETMASK  把参数set中的信号设置为信号屏蔽字
         
         oldset
              返回原来的信号屏蔽字
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#include 
#include 
#include 

void myhandle(int sig) 
{
	printf("Catch a signal : %d\n", sig);
	printf("Catch end.%d\n", sig);
}

int main(void) 
{
	struct sigaction act, act2;

	act.sa_handler = myhandle;
	sigemptyset(&act.sa_mask);
	act.sa_flags = 0;
	sigaction(SIGINT, &act, 0);

	sigset_t proc_sig_msk, old_mask;
	sigemptyset(&proc_sig_msk);
	sigaddset(&proc_sig_msk, SIGINT);

	sigprocmask(SIG_BLOCK, &proc_sig_msk, &old_mask);
	sleep(5);
	printf("had delete SIGINT from process sig mask\n");
	sigprocmask(SIG_UNBLOCK, &proc_sig_msk, &old_mask);
		
	while (1) {
		
	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

该程序最开始 不响应 SIGINT函数 阻塞住了 后面5s后放开 继续响应SIGINT