学习笔记之进程间的通讯之信号

1、概述

信号通过整形数值表示，总共有64个信号，前32个信号继承于unix，后32个信号是自增的；

前32个信号是不可靠信号（信号存在丢失，多次信号，只会处理一次），非实时信号

硬件产生信号：ctrl+c    ctrl+z   ctrl+\     硬件中断

软件产生信号：软件中断  命令：kill -信号编号  进程号   如：kill -9 4502   (9为信号编号，4502为pid)

进程收到一个信号后，会暂停当前工作，先去处理信号，处理完信号后，继续执行之前暂停的工作

2、命令

查看所有信号：kill -l

发送信号：kill -9 4502   (9为信号编号，4502为pid)

3、操作

①发送信号：

kill(atoi(argv[2]), atoi(argv[1]));//参数由main参数传入，均为整形

②干掉自己：

kill(getpid(), 9);//getpid获取自己的进程号
或 //raise(9);发送信号给自己

③闹钟信号：

 alarm(10);    

//设置一个5秒的闹钟。设置完啦，程序继续往下运行
//5秒之后，就会自动发出一个SIGALRM信号给进程本身，
//SIGALRM默认处理动作是结束程序   
sleep(3);
//新设置的闹钟会将之前的闹钟取消掉，并且返回之前闹钟剩余的时间
unsigned int left = alarm(5);
printf("前一个闹钟还剩于%d秒\n", left);

4、重写信号操作

 ①SIGKILL 和 SIGSTOP 不能重写或忽略

typedef void (*sighandler_t)(int);

//一个信号处理函数可以用来处理多个不同的信号
//也可以分别为每一个信号定义一个处理函数
//形参作用：在调用handle函数处理信号时，会将得到的信号传给handle函数的行参
void handle(int sig)
{
    if (SIGINT == sig)
    {    

        //在A信号处理过程中，又来了A信号，则继续当前A信号的处理
        //等当前A信号处理完之后，才会去处理新来的A信号
        //假如新的A信号连续多次到来，则只会处理一次，其余的丢掉

        //在A信号处理过程中，又来了B信号，则暂停当前A信号的处理
        //先去处理新来的B信号，等B信号处理完之后，继续接着执行之前暂停的A处理    
        printf("ctrl+c pressed ...\n");
        int i = 0;
        while (1)
        {
            printf("in hanlde ctrl+c while --> %d\n", ++i);
            sleep(1);
            if (10 == i)
            {
                break;
            }
        }
    }
    else if (SIGTSTP == sig)
    {
        printf("ctrl+z pressed ...\n");
    
    }
    else if (SIGQUIT == sig)
    {
        printf("ctrl+\\ pressed ...\n");
    
    }
    else if (SIGALRM == sig)
    {
        printf("闹钟，叮铃铃 ...\n");
    }
}

int main(int argc, char *argv[])
{
    //关联信号和信号的处理函数，不会调用handle
    //当发生了信号时，则自动去调用关联的handle信号处理函数    
    sighandler_t ret = signal(SIGINT, handle);
    if (SIG_ERR == ret)
    {
        perror("signal");
        exit(EXIT_FAILURE);
    }
    signal(SIGTSTP, handle);
    signal(SIGQUIT, handle);
    //signal(SIGALRM, handle);
    signal(SIGALRM, SIG_IGN);  //忽略信号

    int i = 0;
    while (1)
    {
        printf("in main while pid = %d --> %d\n", getpid(), ++i);
        sleep(1);
        if (20 == i)
        {
            signal(SIGALRM, SIG_DFL);  //恢复信号的默认处理方式
        }
    }
    return 0;
}

②信号中断处理方式：信号屏蔽（阻塞）

if (SIGINT == sig)
    {
        sigset_t  set, old;
        sigemptyset(&set);   //清空信号集
        sigfillset(&set);     //将系统的所有信号填充到集合中
        //sigdelset(&set, SIGALRM);  //删除集合中的某个信号

        //阻塞set集合中的信号，通过old集合保留这些信号阻塞前的状态
        //若不想保留，则参数三写NULL
        //亦将set称之为信号屏蔽集
        //sigprocmask(SIG_BLOCK, &set, NULL);

        //信号屏蔽(阻塞)，并不是把收到的信号扔掉，而是暂时不处理，解除阻塞之后再处理
        //若阻塞的过程中同一个信号到达多次，则在解除阻塞后只会对该信号处理一次
        sigprocmask(SIG_BLOCK, &set, &old);
        printf("ctrl+c pressed ...\n");
        int i = 0;
        while (1)
        {
            printf("in hanlde ctrl+c while --> %d\n", ++i);
            sleep(1);
            if (10 == i)
            {
                break;
            }
        }
        //将set集合中的信号全部设置为非阻塞
        sigprocmask(SIG_UNBLOCK, &set, NULL);
       // sigprocmask(SIG_STEMASK, &old, NULL);   //恢复之前的状态
    }

或者在main函数中采用sigaction进行处理

    struct sigaction act, oldact;
    act.sa_handler = handle;
    sigemptyset(&act.sa_mask);
    sigfillset(&act.sa_mask);

    //oldact用来保存信号之前的处理方式
    //假如不想保存之前的状态，参数3设置为NULL

    //后面SIGIN信号到来的时候，就会自动调用handle函数处理
    //并且在处理过程中，会自动将sa_mask集合中的信号屏蔽
    //处理完之后，自动解除信号屏蔽
    sigaction(SIGINT, &act, &oldact);

    signal(SIGTSTP, handle);
    signal(SIGQUIT, handle);

5、原子操作

signal(SIGALRM, handle);
//希望5s之后通过SIGALRM信号打断pause的挂起
alarm(5);
//有可能在pause之前SIGALRM信号就到达，并处理了
pause();

 //若alarm(5);pause();两个语句设置为了原子操作，则可以避免上述情况的发生
 //原子操作，要么都执行，要么都不执行，中间不能被打断

解决方法：

signal(SIGALRM, handle);

 sigset_t set;
 sigemptyset(&set);
 sigaddset(&set, SIGALRM);
 sigprocmask(SIG_BLOCK, &set, NULL);

 alarm(5);  

 sigset_t mask;
 sigemptyset(&mask);
 sigaddset(&mask, SIGINT);

 //原子操作：1,使用mask集合代替set集合中的信号阻塞，则set集合中的信号就变成了非阻塞
 //即SIGALRM信号就变成了非阻塞
 //2,挂起程序
 //第一步和第二步是一个原子操作，执行的时候不能被打断    
 sigsuspend(&mask);