目录
什么是信号？
信号的产生
信号产生方式1：键盘
前台进程
后台进程
查看信号
signal系统调用
案例
理解进程记录信号
软件层面
硬件层面
信号产生方式2:指令
信号产生方式3:系统调用
kill系统调用
案例
其他产生信号的函数调用
1.raise
2.abort
信号产生方式4:软件条件
什么是软件条件？
alarm系统调用
使用
1.
2.
3.
信号的产生5:异常
示例1：
示例2：
那么os如何知道进程内部错误？
理解一下野指针的异常
Term和Core的区别
什么是信号？
信号！=信号量
信号：是一种用户,OS,其他进程，向目标进程发送异步事件的一种方式。
同步和异步：
1.怎么识别信号？
识别信号是内置的。即进程识别信号时程序的内置属性。可以类比一下语言的内置数据类型（int，double）
2.信号产生后，进程知道怎么处理吗？知道 。如果没产生，进程知道怎么处理吗？也知道，因为信号的处理方法在产生之前就已经准备好了。
3.信号会被进程立即处理吗？
不一定，如果不，那么什么时候处理呢？进程会在一个合适的时候处理。
信号到来 --> <进程不立即处理，记录信号> --> 合适的时候处理信号
4.处理信号的方法： 1.默认行为 2.忽略信号3.自定义动作
信号的产生
信号产生方式1：键盘
这有一段死循环的程序
#include <iostream>
#include <unistd.h>
int main()
{while (true){std::cout << "hello world" << std::endl;sleep(1);}return 0;
}从键盘中输入 ctrl+c 可以前台进程杀掉前台进程。
前台进程
命令 ： ./程序名
运行起来的是前台进程也可以用ctrl+c杀掉进程
后台进程
命令 ： ./进程名&
后台进程无法用 ctrl+c 杀死
杀掉后台进程的方法：1. fg命令将后台进程切换到前台，在ctrl+c杀掉进程。
2. kill -9 pid(对应进程的pid）
方法一：
方法二：
查看信号
kill -l 
man 7 signal//中可以找到相应信号的描述
signal系统调用
信号的自定义捕捉
signal的作用是捕捉signum号信号，捕捉之后，执行handler指向的函数
signum： 要捕捉的信号
#define SIGQUIT 3
handler：处理函数
案例
ctrl+\ 默认终止进程
#include <iostream>
#include <unistd.h>
#include <signal.h>
void handler(int signo)
{std::cout << "signo: " << signo << std::endl;
}
int main()
{//捕捉 3)SIGQUIT信号signal(SIGQUIT, handler);while (true){std::cout << "hello world" << std::endl;sleep(1);}return 0;
} 
ctrl+\，被捕捉不再执行默认行为（默认终止），而是将这个信号传给signo并调用自定义函数
根据上面的案例是不是我们捕捉所有信号，那么这个死循环程序就不会被杀死了呢？
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <functional>
using func_t = std::function<void(int)>;
void handler(int signo)
{std::cout << "signo: " << signo << std::endl;
}
int main()
{//signal(SIGQUIT, handler);//捕捉信号for(int i = 1;i<=31;i++){func_t f = signal(i,handler);std::cout<<"捕捉:"<<i<<std::endl;}while (true){std::cout << "hello world" << std::endl;sleep(1);}return 0;
}
从结果上可以知道ctrl+c ctrl+\因为被捕捉了，所以杀不掉进程，但kill -9 可以 杀掉进程，也就说明了，9）SIGKILL 不能被捕捉。
理解进程记录信号
软件层面
键盘（比如ctrl+c） -> os -> 进程 --> 记录信号
因为os管理外设，所以键盘将信号传给os，os也管理进程，os在将信号传给进程，之后进程记录信号。
进程如何记录信号？
总结：
发送流程：键盘中的信号发送给os，os在发送给进程，修改进程对应的信号位图和其维护处理方法的函数指针数组。
无论什么信号都是由os发送的。
os是task_struct的唯一管理者，所以只有 os有权利修改信号位图。
硬件层面
os是如何知道键盘上有数据？
轮徇（不可以，os的任务太多了）
硬件中断
冯诺依曼体系结构
在数据层面上，我们知道cpu不与外设直接打交道。而是通过存储器
但在cpu和键盘是连接的，键盘可以直接将数据交给cpu
硬件中断 --> cpu告诉os，键盘上有数据 --> 这样硬件和os就可以并行执行了
信号vs信号中断
信号是纯软甲的
信号中断是纯硬件的
信号产生方式2:指令
指令：
kill -信号 相应进程的pid信号产生方式3:系统调用
kill系统调用
kill的作用：就是OS向（pid)进程 发送sig信号
使用代码：
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <functional>
#include <sys/types.h>
int main()
{int cnt= 5;while(true){std::cout<<cnt<<std::endl;if(cnt<=0)kill(getpid(),SIGQUIT);sleep(1);cnt--;}return 0;
}执行结果：
kill()系统调用与kill命令的关系
kill命令行就是封装的kill()系统调用。
案例
简单实现下自己的kill
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <functional>
#include <sys/types.h>void Usage(char* argv)
{std::cout<<"Usage error: "<<argv<<" signo"<<" pid"<<std::endl;exit(1);
}
//./kill 9 pidint main(int argc,char* argv[])
{if(argc!=3){//正确使用提醒Usage(argv[0]);}int signo = std::stoi(argv[1]);pid_t pid = std::stoi(argv[2]);int ret = kill(pid,signo);if(ret<0){perror("kill");exit(2);}return 0;}执行结果：
其他产生信号的函数调用
1.raise
作用：让OS向调用该函数的进程返送sig信号
2.abort
作用：让OS向调用该函数的进程返送6号信号（该进程被干掉）
这两个函数比较简单
这两个函数都是由kill封装的,libc库函数
kill(getpid(),sig);//raise
kill(getpid(),6);//abort信号产生方式4:软件条件
什么是软件条件？
由软件条件产生信号，通常指的是在软件应用程序中，根据某些特定的条件或逻辑判断来触发或生成信号
比如：管道中，读端关闭，但写端没有关闭 这时，os回想进程发送 13）SIGPIPE信号
alarm系统调用
作用：设置一个seconds秒的闹钟，时间一到就会给调用闹钟的进程发送 14）SIGALRM信号
alarm(条件)；
里面设置的时间就相当于条件，满足条件就发送信号。
OS中维护的定时器的大概内核数据结构
使用
1.
#include <iostream>
#include <unistd.h>int main()
{alarm(1);int cnt = 0;while(true){//一秒打印多少次std::cout<<cnt<<std::endl;cnt++;}return 0;
}结果：
打印了11万多次，快只能说很慢。
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <functional>
#include <sys/types.h>int cnt = 0;
void handler(int signo)
{std::cout<<cnt<<std::endl;exit(0);
}
int main()
{alarm(1);signal(SIGALRM,handler);while(true){//std::cout<<cnt<<std::endl;cnt++;}return 0;
}结果：计算了将近16亿次
从上面两个程序可以看出，IO影响计算速度。
2.
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <functional>
#include <sys/types.h>int main()
{alarm(5);sleep(1);int n = alarm(0);//alarm(0)取消闹钟 n上一个闹钟剩余的时间std::cout<<n<<std::endl;return 0;
}
3.
pause
作用：等待信号
闹钟是一次性的发送完信号后就被取消。
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <functional>
#include <sys/types.h>
#include <vector>
using func_t = std::function<void()>;int cnt = 0;
std::vector<func_t> v;//任务void handler(int signo)
{for (auto &e : v){e();}alarm(2);cnt++;
}
int main()
{v.push_back([](){ std::cout << "我是一个日志任务" << std::endl; });v.push_back([](){ std::cout << "我是一个下载任务" << std::endl; });v.push_back([](){ std::cout << "我是一个mysql任务" << std::endl; });alarm(2);//一次性闹钟，超时后就会被取消signal(SIGALRM, handler);while (true){pause();//等待信号std::cout << "我醒来了..." << std::endl;std::cout << "cnt: " << cnt << std::endl;}
}运行结果：
将上述逻辑中的信号变为硬件中断，就是OS的运行逻辑。
OS本质上就是一个中断处理程序
信号的产生5:异常
示例1：
野指针
int main()
{int *p = nullptr;*p = 0;//野指针return 0;
}
Segmentation fault 段错误
11)SIGEGV
示例2：
int main()
{int a = 10;a/=0;return 0;
}
Floating point exception 浮点异常
8）SIGFPE
现在我们可以理解一下为什么程序会崩溃？
出现错误时，OS会向进程发送相应的信号，从而进程被干掉。
那么os如何知道进程内部错误？
比如：div 0
cpu中有状态寄存器 Eflag，Eflag中有个core dump（溢出标记为）标记为，1.cpu计算错误
0.无错误
验证：
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <functional>
#include <sys/types.h>
#include <wait.h>int main()
{pid_t pid = fork();if(pid==0){//子进程int a = 10;a/=0;}else{int status;waitpid(pid,&status,0);std::cout<<"core dump: "<<((status>>7)&1)<<std::endl;std::cout<<"signo: "<<(status&0x7F)<<std::endl;}
}结果：
正如所料：core dump被设为1，并向子进程发送8）SIGFPE信号
--------------------------------------------------------------------------------------------------------------------------------
void handler(int signo)
{std::cout<<"signo: "<<signo<<std::endl;
}
int main()
{pid_t pid = fork();if(pid==0){//子进程int a = 10;a/=0;}else{int status;waitpid(pid,&status,0);std::cout<<"core dump: "<<((status>>7)&1)<<std::endl;std::cout<<"signo: "<<(status&0x7F)<<std::endl;}
}差不多的程序如果捕获了8号信号，
结果：
os一直发送8号信号。
总结：
cpu错误 --> 谁弄坏了cpu，os发送信号杀死进程 （--> 如果捕捉了8号信号--->进程没退出--->还要调度-->还要切换执行等 --> os不会修复Eflag中core dump（1）-->一直触发信号）
理解一下野指针的异常
野指针的错误是由cpu中MMU错误引起的
Term和Core的区别
Trem：正常终止，不需要debug
Core：核心转储--->在当前目录下形成core文件-->进程崩溃，将进程在内存中的部分信息保存起来，方便以后调试-->一般被云服务器关闭（如果崩溃一次形成一个新的core，那么就可能把磁盘空间占满）
但当前目录下没有啊
如何打开？
ulimit -a//查看
可以看到core file size为0；
ulimit -c 大小//改变core file size 
readelf -S ./sig //查看程序elf格式 
运行程序就可已生成core.pid的文件
如果无法生成core文件的话
在root下，输入下面的命令就可以了
echo core > /proc/sys/kernel/core_patterncore-file core.pid//方便调试 
如果是子进程异常呢？core的生成条件？
core dump--> 退出信号的终止动作是core && 云服务器开启core
