信号通信

信号通信其实就是内核向用户空间进程发送信号，只有内核才能发信号，用户空间进程不能发送信号。信号在内核中已经存在，并且在内核中有很多信号。

信号通信的框架
l 信号的发送（发送信号进程）：kill raise alarm
l 信号的接收（接收信号进程） : pause() sleep while(1)
l 信号的处理（接收信号进程） : signal

用命令kill -l 查看内核中有多少信号

CLC@Embed_Learn:~$ kill -l
 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	34) SIGRTMIN	35) SIGRTMIN+1	36) SIGRTMIN+2	37) SIGRTMIN+3
38) SIGRTMIN+4	39) SIGRTMIN+5	40) SIGRTMIN+6	41) SIGRTMIN+7	42) SIGRTMIN+8
43) SIGRTMIN+9	44) SIGRTMIN+10	45) SIGRTMIN+11	46) SIGRTMIN+12	47) SIGRTMIN+13
48) SIGRTMIN+14	49) SIGRTMIN+15	50) SIGRTMAX-14	51) SIGRTMAX-13	52) SIGRTMAX-12
53) SIGRTMAX-11	54) SIGRTMAX-10	55) SIGRTMAX-9	56) SIGRTMAX-8	57) SIGRTMAX-7
58) SIGRTMAX-6	59) SIGRTMAX-5	60) SIGRTMAX-4	61) SIGRTMAX-3	62) SIGRTMAX-2
63) SIGRTMAX-1	64) SIGRTMAX

一共有64种信号，前面的数字表示信号的id。后面的字母代表信号的功能。

信号通信的发送-kill,raise,alarm

kill：能向所有进程发送信号

函数原型：int kill(pid_t pid, int sig);
函数传入值：pid
正数：要接收信号的进程的进程号
0：信号被发送到所有和pid进程在同一个进程组的进程
-1：信号发给所有的进程表中的进程(除了进程号最大的进程外)
sig：信号
函数返回值：成功：0；失败：-1.

例：

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

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

        int sig;
        int pid;
        if(argv < 3){
    
                printf("Please input number.\n");
                return -1;
        }

        sig = atoi(argc[1]);//将字符强制转换成int型
        pid = atoi(argc[2]);

        printf("sig = %d,pid = %d\n",sig,pid);

        kill(pid,sig);

        printf("kill success.\n");

        return 0;
}

raise: 发信号给自己 == kill(getpid(), sig)

只能向当前进程发送信号
函数原型：int raise(int sig);
函数传入值：sig：信号
函数返回值：成功：0，失败：-1.

例：

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

int main()
{
    
        printf("raise befor.");
        raise(9);//结束自己。相当于_exit
        printf("raise after.\n");
        return 0;
}

CLC@Embed_Learn:~/linux_io/02/02/seven$ ./a.out 
Killed       //并未打印出raise befor.，所以相当于_exit

_exit和exit的区别：
_exit()函数的作用最为简单：直接使进程停止运行，清除其使用的内存空间，并销毁其在内核中的各种数据结构；exit()函数与_exit()函数最大的区别就在于exit()函数在调用exit系统调用之前要检查文件的打开情况，把文件缓冲区中的内容写回文件，就是“清理I/O缓冲”。
exit（0）：正常运行程序并退出程序；
exit（1）：非正常运行导致退出程序；
return（）：返回函数，若在主函数中，则会退出函数并返回一值。

例：父子进程间进行通信

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

int main()
{
    
        pid_t pid;

        pid = fork();

        if(pid > 0)//parent
        {
    
                printf("parent pid = %d\n",getpid());//getpid()获得进程pid号
                printf("pid = %d\n",pid);
                sleep(8);
                if(waitpid(pid,NULL,WNOHANG) == 0){
    //等待子进程是否退出
                        kill(pid,9);
                }
                while(1);
        }

        if(pid == 0 ){
    
                printf("child pid = %d\n",getpid());
                printf("raise function before.\n");
                raise(SIGTSTP);//暂停子进程
                printf("raise function after.\n");
        }
        return 0;
}

CLC@Embed_Learn:~/linux_io/02/02/seven$ ./raise2 
parent pid = 5880
pid = 5881//fork（）函数对父进程的返回值为子进程的pid号。
child pid = 5881
raise function before.

CLC@Embed_Learn:~/linux_io/02/02/seven$ ps aux|grep raise2 //只查看想看的进程
CLC       5880  0.0  0.0   4160   352 pts/2    S+   12:13   0:00 ./raise2
CLC       5881  0.0  0.0   4160    88 pts/2    T+   12:13   0:00 ./raise2
CLC       5883  0.0  0.0  13588   940 pts/3    R+   12:13   0:00 grep --color=auto raise2
CLC@Embed_Learn:~/linux_io/02/02/seven$ ps aux|grep raise2
CLC       5880 34.3  0.0   4160   352 pts/2    R+   12:13   0:04 ./raise2
CLC       5881  0.0  0.0      0     0 pts/2    Z+   12:13   0:00 [raise2] <defunct>
//处于僵尸状态。
CLC       5885  0.0  0.0  13588   936 pts/3    R+   12:13   0:00 grep --color=auto raise2

僵尸进程：子进程结束时，系统会向其父进程发送一个SIGCHLD信号告知父进程子进程已经结束；父进程收到SIGCHLD信号后，如果使用wait系统调用获取子进程退出状态，内核就可以从内存中释放已结束的子进程PCB块，如果未使用wait，则子进程PCB块将留在系统中，这种状态的进程称为僵尸状态。

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

int main()
{
    
        pid_t pid;

        pid = fork();

        if(pid > 0)//parent
        {
    
                printf("parent pid = %d\n",getpid());
                printf("pid = %d\n",pid);
                sleep(8);
                if(waitpid(pid,NULL,WNOHANG) == 0){
    
                        kill(pid,9);
                }
                wait(NULL);//这样不会产生僵尸进程
                while(1);
        }

        if(pid == 0 ){
    
                printf("child pid = %d\n",getpid());
                printf("raise function before.\n");
                raise(SIGTSTP);
                printf("raise function after.\n");
        }
        return 0;
}

调用wait就不会产生僵尸进程。

CLC@Embed_Learn:~/linux_io/02/02/seven$ ps aux|grep raise2
CLC       5951  0.0  0.0   4160   348 pts/2    S+   12:43   0:00 ./raise2
CLC       5952  0.0  0.0   4160    84 pts/2    T+   12:43   0:00 ./raise2
CLC       5954  0.0  0.0  13588   940 pts/3    S+   12:43   0:00 grep --color=auto raise2
CLC@Embed_Learn:~/linux_io/02/02/seven$ ps aux|grep raise2
CLC       5951 15.5  0.0   4160   348 pts/2    R+   12:43   0:01 ./raise2
CLC       5956  0.0  0.0  13588   940 pts/3    S+   12:43   0:00 grep --color=auto raise2

1) wait()函数用于使父进程（也就是调用wait()的进程）阻塞，直到一个子进程结束或者该进程接收到了一个指定的信号为止。如果该父进程没有子进程或者它的子进程已经结束，则wait()函数就会立即返回。
2) waitpid()的作用和wait()一样，但它并不一定要等待第一个终止的子进程（它可以指定需要等待终止的子进程），它还有若干选项，如可提供一个非阻塞版本的 wait()功能，也能支持作业控制。实际上，wait()函数只是 waitpid()函数的一个特例，在Linux 内部实现 wait()函数时直接调用的就是waitpid()函数。

alarm：闹钟信号，只能发送给当前进程

alarm 与 raise 函数的比较：
相同点：让内核发送信号给当前进程
不同点：

1. alarm 只会发送SIGALARM信号
2. alarm 会让内核定时一段时间之后发送信号， raise会让内核立刻发信号

函数原型：unsigned int alarm(unsigned int seconds)
函数传入值：seconds：指定秒数
函数返回值：成功：如果调用此alarm()前，进程中已经设置了闹钟时间，则返回上一个闹钟时间的剩余时间，否则返回0。
失败：-1.

例：alarm函数的用法

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

int main()
{
    
        int i=0;
        printf("alarm befor.\n");
        alarm(9);//延时九秒后终止程序
        printf("alarm after.\n");

        while(i<20){
    //为了使九秒后该程序还没结束
                i++;
                sleep(1);
                printf("i=%d\n",i);
        }
        return 0;
}

CLC@Embed_Learn:~/linux_io/02/02/eight$ gcc alarm.c 
CLC@Embed_Learn:~/linux_io/02/02/eight$ ./a.out 
raise befor.
raise after.
i=1
i=2
i=3
i=4
i=5
i=6
i=7
i=8
Alarm clock//第九秒发送信号，收到信号时，把进程阻止。

信号通信信号的处理-signal

signal(处理哪个信号，怎样处理信号)

void (*signal(int signum, void (*handler)(int)))(int);

A= void (*handler)(int) = 函数指针变量。函数的形式：还有一个整型参数，无返回值的函数。
void (*signal(int signum, A))(int)；
signal 函数有二个参数，第一个参数是一个整形变量（信号值），第二个参数是一个函数指针，是我们自己写的处理函数；
这个函数的返回值是一个函数指针。

demo

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

void myfun(int signum)//接收到14时 进入该函数，该函数结束后，继续运行主函数。
{
    
        int i=0;
        while(i<5){
    
                printf("process signal num = %d\n",signum);
                sleep(1);
                i++;
}
}

int main()
{
    
        int i=0;
        signal(14,myfun);//14传进函数myfun里面进行处理
        printf("alarm befor.\n");
        alarm(4);
        printf("alarm after.\n");

        while(i<10){
    
                i++;
                sleep(1);
                printf("i=%d\n",i);
        }
        return 0;
}

CLC@Embed_Learn:~/linux_io/02/02/nine$ gcc signal.c 
CLC@Embed_Learn:~/linux_io/02/02/nine$ ./a.out 
alarm befor.
alarm after.
i=1
i=2
i=3
process signal num = 14
process signal num = 14
process signal num = 14
process signal num = 14
process signal num = 14
i=4
i=5
i=6
i=7
i=8
i=9
i=10

信号通信接收-pause(),sleep(),while(1)

pause：让进程状态处于S

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

int main()
{
    
        int i=0;
        printf("raise befor.\n");
        pause();//让进程处于睡眠状态
        printf("raise after.\n");

        while(i<20){
    
                i++;
                sleep(1);
                printf("i=%d\n",i);
        }
        return 0;
}

CLC       4525 99.9  0.0   4160    92 ?        R    15:32 375:28 ./a.out
CLC       6146  0.0  0.0   4160   352 pts/2    S+   21:47   0:00 ./a.out
CLC       6157  0.0  0.0  13588   952 pts/3    S+   21:47   0:00 grep --color=auto ./a.out
CLC@Embed_Le

end…