Linux进程信号（三）之信号产生2

4. 由软件条件产生信号

SIGPIPE是一种由软件条件产生的信号,在“管道”中已经介绍过了。

软件条件不就绪，很明显这个软件条件没有直接报错，而是通过返回值来反映。

#include <iostream>
#include <signal.h>
#include<unistd.h>using namespace std;int main()
{char buffer[1024];int n=1024;n=read(4,buffer,sizeof(buffer));printf("n=%d\n",n);perror("read");return 0;
}

软件条件可能会产生信号也可能不会，取决于操作系统本身。

操作系统是由对软件检测的能力的，所以能通过软件条件产生信号。

本节主要介绍alarm函数 和SIGALRM信号。

#include <unistd.h>
unsigned int alarm(unsigned int seconds);
调用alarm函数可以设定一个闹钟,
也就是告诉内核在seconds秒之后给当前进程发SIGALRM信号, 
该信号的默认处理动作是终止当前进程。

这个函数的返回值是0或者是以前设定的闹钟时间还余下的秒数。

打个比方:

某人要小睡一觉,设定闹钟为30分钟之后响,

20分钟后被人吵醒了,还想多睡一会儿,

于是重新设定闹钟为15分钟之后响,“以前设定的闹钟时间还余下的时间”就是10分钟。

如果seconds值为0,表示取消以前设定的闹钟,

函数的返回值仍然是以前设定的闹钟时间还余下的秒数

例 alarm

#include <iostream>
#include <signal.h>
#include<unistd.h>using namespace std;
int main()
{alarm(5);while(1){cout<<"proc is running"<<endl;sleep(1);}return 0;
}

验证：收到了14号信号

#include <iostream>
#include <signal.h>
#include<unistd.h>using namespace std;void handler(int signum)
{cout<<"get a sig,num: "<<signum<<endl;
}int main()
{signal(14,handler);alarm(5);while(1){cout<<"proc is running"<<endl;sleep(1);}return 0;
}

因为只设置一次，闹钟只响了一次（因为不是异常）

如果想让闹钟每隔5秒响一次

（收到了14号信号，就去调用处理方法，

在调用方法里，又设置了一个闹钟，5秒之后，又收到了14号信号，继续调用处理方法……）

void handler(int signum)
{cout<<"get a sig,num: "<<signum<<endl;alarm(5);
}

查看剩余时间

收到了14号信号，那么调用处理方法，闹钟将会重新设置，alarm(5)

#include <iostream>
#include <signal.h>
#include<unistd.h>using namespace std;void handler(int signum)
{cout<<"get a sig,num: "<<signum<<endl;int n=alarm(5);cout<<"time: "<<n<<endl;
}int main()
{signal(14,handler);int n=alarm(50);while(1){cout<<"proc is running,pid: "<<getpid()<<endl;sleep(1);}return 0;
}

操作系统内部会有很多闹钟，所以OS要管理闹钟，

先描述再组织，对闹钟的管理就变成了对链表的增删查改。

闹钟的描述：有指向进程的指针，有时间（使用时间戳）

时间戳+设定的时间=未来时间

如果现在时间大于等于这个未来时间就表示超时了。

遍历链表对比时间，如果时间到了就发送信号，该节点就可以从链表里删除了。

提高效率：

使用优先级队列或者堆等数据结构。

最小堆，将数据结构都放进最小堆，

堆顶数据没有超时，那么整个堆都没有超时。

堆顶超时了，只要将堆顶处理，就可以移除堆顶元素。

5. 硬件异常产生信号

硬件异常被硬件以某种方式被硬件检测到并通知内核,

然后内核向当前进程发送适当的信号。

例如当前进程执行了除以0的指令,

CPU的运算单元会产生异常，

内核将这个异常解释 为SIGFPE信号发送给进程。

再比如当前进程访问了非法内存地址,

MMU会产生异常,内核将这个异常解释为SIGSEGV信号发送给进程。

捕捉信号，不是为了解决出现的问题，

而是为了让用户知道进程为什么挂了。（做做收尾工作）

模拟一下除0错误和野指针异常

makefile

mysignal:mysignal.ccg++ -o $@ $^ -std=c++11
.PHONY:clean
clean:rm -rf mysignal

除0错误

mysignal.cc

#include <iostream>
#include <signal.h>
#include<unistd.h>using namespace std;int main()
{cout<<"div before"<<endl;sleep(1);int a=10;a/=0;cout<<"div after"<<endl;sleep(1);return 0;
}

证明收到了8号信号

mysignal.cc

#include <iostream>
#include <signal.h>
#include<unistd.h>using namespace std;void handler(int signum)
{cout<<"get a sig,num: "<<signum<<endl;//只是打印了一行信息，其他什么都没干
}int main()
{signal(8,handler);cout<<"div before"<<endl;// sleep(1);int a=10;a/=0;cout<<"div after"<<endl;// sleep(1);return 0;
}

代码为什么一直都不退出呢？

因为8号信号的默认动作是退出，但是现在改成了自定义动作，

自定义动作只有打印信息没有设置退出，所以进程不会退出。

野指针错误

mysignal.cc

#include <iostream>
#include <signal.h>
#include<unistd.h>using namespace std;int main()
{cout<<"point error before"<<endl;int *p=nullptr;//p指向0号地址*p=100;//没有资格访问0号地址（权限问题/野指针问题）cout<<"point error after"<<endl;return 0;
}

验证收到11号信号

mysignal.cc

#include <iostream>
#include <signal.h>
#include<unistd.h>using namespace std;void handler(int signum)
{cout<<"get a sig,num: "<<signum<<endl;//只是打印了一行信息，其他什么都没干
}int main()
{signal(11,handler);cout<<"point error before"<<endl;int *p=nullptr;//p指向0号地址*p=100;//没有资格访问0号地址（权限问题/野指针问题）cout<<"point error after"<<endl;return 0;
}

以上证明，进程出了异常不一定会退出，只要捕捉信号即可。

（但是不退出意义不大了，还占用着CPU的资源）

不退出就会一直被调度运行，硬件异常没有被修正，

然后运行又有硬件报错，然后OS一直发信号，

进程收到信号继续被捕捉……如此循环。

由此可以确认，我们在C/C++当中除零，内存越界等异常，

在系统层面上，是被当成信号处理的。

---

为什么除0和野指针会让进程崩溃呢？

因为收到了信号，该信号的默认处理动作是终止进程自己。

为什么除0和野指针会给进程发信号呢？

因为硬件发生了报错，OS检测到了，所以给进程发信号。

OS怎么知道发生了除0和野指针？

除0：

所以，除0错误最终会被转化成硬件问题，

OS识别到了硬件报错，

所以OS要给进程发信号，

所以进程收到信号会自己终止（崩溃）。

野指针：

CPU内部不同的寄存器的报错代表不同的信号。

总结思考一下

上面所说的所有信号产生，最终都要有OS来进行执行，为什么？

因为OS是进程的管理者！

OS是进程的管理者信号的处理是否是立即处理的？

不是立即处理。进程可能正在做更重要的事。

在合适的时候，信号如果不是被立即处理，那么信号是否需要暂时被进程记录下来？记录在哪里最合适呢？

一个进程在没有收到信号的时候，能否能知道，自己应该对合法信号作何处理呢？

如何理解OS向进程发送信号？能否描述一下完整的发送处理过程？