信号通信

信号通信的框架：

信号的发送（发送信号进程）：kill() raise() alarm()

信号的接收（接收信号进程）：pause() sleep() while()

信号的处理（接收信号进程）：signal()

内核有64中信号，通过kill -l 查看

杀死进程

#include<stdio.h>
int main()
{

    while(1);
    return 0;
}

test.c进程号为4968，通过kill -9 4968对·进程杀死

kill

头文件：#include <signal.h>

​ #include< sys/types.h>

函数原型：int kill (pid _t pid,int sig)

函数传入值：pid:正数：要接收信号的进程的进程号

​ 0：信号被发送到所有pid进程号在同一个进程组的进程

​ -1：信号发送给所有进程表中的进程（除了进程号最大的进程外）

​ sig:信号

返回值：成功0，失败-1

kill函数实现：

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<fcntl.h>
#include<signal.h>
int main(int argc,char *argv[])
{
    int sig;
    int pid;
    if(argc<3)
    {
        printf("please input param\n");
        return -1;
    }
    sig = atoi(argv[1]);
    pid = atoi(argv[2]);
    printf("sig= %d,pid = %d\n",sig,pid);
    kill(pid,sig);
    return 0;
}

信号的发送：

raise()

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<fcntl.h>
#include<signal.h>
int main()
{

    printf("raise before\n");
    raise(9);//_exit() not exit()
    printf("raise after \n");
    return 0;
}

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<fcntl.h>
#include<signal.h>
int main()
{

    printf("raise before");
    raise(9);//_exit() not exit()
    printf("raise after \n");
    return 0;
}

alarm（）：定时一段时间，再发送信号。

alarm与raiseb比较

相同点：让内核发送信号给当前进程

不同点：1.alarm只会发送SIGALARM信号

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

头文件：include<unistd.h>

函数原型:unsigned int alarm(unsignal int seconds)

函数传入值：second，指定秒数

函数返回值：成功调用alarm（）前，进程中已经设置了闹钟时间，则返回上一个闹钟时间剩余时间，否则返回0

​ 出错：-1

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<fcntl.h>
#include<signal.h>
int main()
{
    int i =0;

    printf("alarm before\n");
    alarm(9);//_exit() not exit()
    printf("alarm after \n");
    while(i<20)
    {
    i++;
    sleep(1);
    printf("process things,i =%d\n",i);
    }

    return 0;
}

信号的接收：

pause（）：进程状态为S

头文件：#include<unistd.h>

函数原型：int pause（void）

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<fcntl.h>
#include<signal.h>
int main()
{
    int i =0;

    printf("alarm before\n");
    pause();//_exit() not exit()
    printf("alarm after \n");
    while(i<20)
    {
    i++;
    sleep(1);
    printf("process things,i =%d\n",i);
    }

    return 0;
}

信号的处理：

signal（）

头文件：#include<signal.h>

函数原型：void (*signal(int signum,void(*handler)(int)))(int);

*A =void(handler)(int))=函数指针变量

*void (signal(int signum,A(int)

第一个参数信号值，第二个参数函数指针

返回值：函数指针

函数传入值：signal：指定信号

​ handler：SIG_ING:忽略该信号

​ SIG_DFL:采用系统默认方式处理信号

​ 自定义的信号处理函数指针

函数返回值：成功：设置之前的信号处理方式

​ 出错：-1

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<fcntl.h>
#include<signal.h>
void myfun(int signum)
{
    int i ;
    i =0;
    while(i<10)
    {
    printf("process signal signum=%d\n",signum);
    sleep(1);
    i++;
    }
    return;//return main
}
int main()
{
    int i =0;
    signal(14,myfun);
    printf("alarm before\n");
    alarm(9);//_exit() not exit()
    printf("alarm after \n");
    while(i<20)
    {
    i++;
    sleep(1);
    printf("process things,i =%d\n",i);
    }

    return 0;
}

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<fcntl.h>
#include<signal.h>
void myfun(int signum)
{
    int i =0;
    while(i<5)
    {
    printf("receive signum = %d,i = %d\n",signum,i);
    sleep(1);
    i++;    
    }
}
int main()
{
    pid_t pid;
    pid = fork();
    if(pid > 0)
    {
        int i ;
        i =0;
        signal(10,myfun);
        while(1)
        {
            printf("parent process things,i=%d\n",i);
            sleep(1);
            i++;
        }
    }
    if(pid  == 0)
    {
        sleep(10);
        kill(getppid(),10);
        sleep(10);
        exit(0);}
    return 0;
}