进程间通信 ------ 信号通信

进程间通信 ===》信号通信
应用：异步通信。 中断,

1~64；32应用编程。
如何响应：
   

 kill 发信号

kill      -xx     xxxx  
发送进程  信号    接收进程
kill -9 1000
a.out  9 1000
1、发送端
#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int sig);
功能：通过该函数可以给pid进程发送信号为sig的系统信号。
参数：pid 要接收信号的进程pid
  sig 当前程序要发送的信号编号 《=== kill  -l
返回值：成功 0
失败  -1；

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<unistd.h>
  4 #include<sys/types.h>                                                       
  5 #include<signal.h>
  6 
  7 int main(int argc, const char *argv[])
  8 {
  9     printf("input pid");
 10     char buf[10]={0};
 11     fgets(buf,sizeof(buf),stdin);
 12     pid_t pid=atoi(buf); //字符串转为数字
 13     int ret=kill(pid,9);
 14     if(ret==-1)
 15     {
 16         perror("kill");
 17         exit(1);
 18     }
 19     return 0;
 20 }

 echo $$ 当前进程的id号

raise

raise 自己给自己发信号，所以只写自己的id

int raise(int sig)== kill(getpid(),int sig);
功能：给进程自己发送sig信号

alarm

unsigned int alarm(unsigned int seconds);SIGALAM
功能：定时由系统给当前进程发送信号,也称为闹钟函数,时间到了会提醒，但是不耽误做其他事情
（告诉内核帮助记录时间）
  闹钟只有一个，定时只有一次有效，
  但是必须根据代码逻辑是否执行判断。

pause

int pause(void);
功能：进程暂停，不再继续执行，除非
  收到其他信号。

走到第五秒就暂停了，cpu就跑到其他地方了，也相当于休眠

3、接收端
每个进程都会对信号作出默认响应，但不是唯一响应。
一般如下三种处理方式：
1、默认处理
2、忽略处理 9,19（强制关闭与暂停）
3、自定义处理 9,19 捕获

信号注册函数原型：signal

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

 typedef void (*sighandler_t)(int);
 ===》void (*xx)(int); == void fun(int);
 ===》xx是 void fun(int) 类型函数的函数指针
 ===》typedef void(*xx)(int)   sighandler_t; ///错误
  typedef int   myint;

 ===>sighandler_t signal(int signum, sighandler_t handler);
 ===> signal(int sig, sighandler_t fun);
 ===> signal(int sig, xxx fun);
 ===>fun 有三个宏表示：SIG_DFL 表示默认处理
   SIG_IGN 表示忽略处理
   fun     表示自定义处理

signal ( kill -l , 函数名 ）

void 函数名（int num)

{

}

1）在暂停后终端发来一个信号（SIGCONT）使运行继续

kill -18 29521

  1 #include<stdlib.h>                                        
  2 #include<stdio.h>
  3 #include<signal.h>
  4 #include<unistd.h>
  5 
  6 void myhandle(int num)
  7 {
  8 }
  9 int main(int argc, const char *argv[])
 10 {
 11     signal(SIGCONT,myhandle);//从终端传送一个信号是继续
 12     int i=0;
 13     while(1)
 14     {
 15         printf("working %d\n",getpid());
 16         sleep(1);
 17         i++;
 18         if(i==5)
 19         {
 20             pause();
 21         }
 22     }
 23     return 0;
 24 }
~                                                             
~          

2）自己一直在玩，期间老爸叫了三次没有反应，之后老妈叫四遍在第四次停止游戏

signal(SIGUSR1,handle1);

signal(SIGUSR2,jamdle2);

SIG_IGN(忽略)

SIG_DFL(关闭)

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <unistd.h>
  4 #include <signal.h>                                       
  5 
  6 void handle1(int num)
  7 {
  8     static int i = 0;
  9     printf("老爸叫你\n");
 10     i++;
 11     if(3 == i )
 12     {
 13         signal(SIGUSR1,SIG_IGN);
 14     }
 15 
 16 }
 17 void handle2(int num)
 18 {
 19     static int i = 0 ;
 20     printf("老妈叫你\n");
 21     i++;
 22     if(4== i)
 23     {
 24         signal(SIGUSR2,SIG_DFL);
 25     }
 26 }
 27 int main(int argc, char *argv[])
 28 {
 29     signal(SIGUSR1,handle1);
 30     signal(SIGUSR2,handle2);
 31     while(1)
 32     {
 33         printf("i'm playing pid :%d\n",getpid());
 34         sleep(1);
 35     }
 36     return 0;
 37 }
 38 
~      

 

 3)一个handle可以定义多个信号函数，根据num

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

void handle1(int num)
{
    if(SIGUSR1== num)
    {
        static int i = 0;
        printf("老爸叫你\n");
        i++;
        if(3 == i )
        {
            signal(SIGUSR1,SIG_IGN);
        }
    }
    if(SIGUSR2 == num)
    {
        static int j = 0 ;
        printf("老妈叫你\n");
        j++;
        if(4== j)
        {
            signal(SIGUSR2,SIG_DFL);
        }

    }
}
int main(int argc, char *argv[])
{
    signal(SIGUSR1,handle1);
    signal(SIGUSR2,handle1);
    while(1)    
    {
        printf("i'm playing pid :%d\n",getpid());
        sleep(1);
    }
    return 0;
}