1、信号就算没有产生，进程也必须识别和能够处理信号，要具备处理信号的能力，信号的处理能力，属于进程内置功能的一部分
2、当进程收到一个具体的信号时，进程可能并不会立即处理这个信号，在合适的时候处理信号

3、当信号产生，到信号开始被处理，这段时间，哪些信号已经产生，进程必须知道

信号处理方式（信号递达）

信号处理方式：
1、进程内置了对信号的处理，默认动作
2、进程可以忽略信号
3、自定义动作，会更改进程内置的默认动作，比如：信号的捕捉

信号捕捉 ，会将信号的默认处理方式修改,比如一个信号本来默认处理方式是终止进程并退出进程，信号捕捉之后该信号的默认处理方式被修改，会出现只捕捉而不退出进程了

signal,修改特定进程对于信号的处理动作的

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

handler这个参数是自定义的动作

前后台进程

关于前后台进程：
前台进程：能获取键盘输入

后台进程：不能获取键盘输入

./myprocess & ，加了& ,就变成后台进程了

[cxq@iZwz9fjj2ssnshikw14avaZ lesson31]$ ll
total 36
-rw-rw-r-- 1 cxq cxq    90 Jul 15 22:41 Makefile
-rwxrwxr-x 1 cxq cxq 26440 Jul 15 15:31 myprocess
-rw-rw-r-- 1 cxq cxq   443 Jul 15 22:41 mysignal.cc
-rw-rw-r-- 1 cxq cxq     0 Jul 14 16:59 test.c
[cxq@iZwz9fjj2ssnshikw14avaZ lesson31]$ ./myprocess &

Linux中，一次登陆中，一个终端，一般会配上一个bash，每一个登陆，只允讲一个进程是前台进程，但是可以允许多个进程是后台进程

终端按键产生信号

ctrl +c为什么能够杀掉我们前台进程？

ctrl +c产生的信号只能发给前台进程， ctrl +c本质是被进程解释成为收到了信号，2号信号

信号是进程之间事件异步通知的一种方式，属于软中断

信号的产生和我们自己的代码的运行时异步的 ,
异步：代码在运行时，信号什么时候产生是不清楚的，代码不用管信息什么时候产生，代码继续运行就可以了

ctrl +c : 2号信号

#include<iostream>
#include<stdio.h>
 #include <signal.h>
 #include<unistd.h>
using namespace std ;


void myhandler(int signo)
{
    cout << "process get a signal: " << signo <<endl;
    // exit(1);
}
int main()
{
//捕捉 2号信号
   signal(2 , myhandler);//myhandler是函数指针
   //signal只需要设置一次，往后都有效
   //信号的产生和我们自己的代码的运行时异步的 ,异步：代码在运行时，信号什么时候产生是不清楚的，代码不用管信息什么时候产生，代码继续运行就可以了
 while(true)
    {
        cout << "I am a crazy process : " << getpid() << endl;
        sleep(1);
    }
    return 0 ;
}

ctrl + : 3号信号
不是所有的信号都是可以被signal捕捉的，比如:19 （暂停进程）， 9（杀死进程）

kill系统调用接口向进程发信号

kill给pid进程发sig信号

int kill(pid_t pid, int sig);

#include<iostream>
#include<stdio.h>
 #include <signal.h>
 #include<unistd.h>
  #include <stdlib.h>
  #include<string>
using namespace std ;
void Usage(string proc)
{
    cout << "Usage:\n\t" << proc << " signum pid\n\n";
}


//   mykill signum pid


int main(int argc ,char* argv[]) //命令行参数
{
   //告诉用户如何使用
  if(argc !=3)
  {
     Usage(argv[0]);
         exit(1);
  }
 string signumStr(argv[1]);
    string pidStr(argv[2]);

   int signum = stoi(signumStr); 
   pid_t pid = stoi(pidStr);

     int n =kill(pid,signum); 
    if(n == -1)
    {   
        perror("kill");
        exit(2);
    }
    return 0 ;
}

raise：发送一个信号给调用者

  int raise(int sig);

举例：

#include<iostream>
#include<stdio.h>
 #include <signal.h>
 #include<unistd.h>
  #include <stdlib.h>
  #include<string>
using namespace std ;
void myhandler(int signo)
{
    cout << "process get a signal: " << signo <<endl;
  //   exit(1);
}
int main()
{
    int cnt =5 ;
    signal(2,myhandler); //捕捉2号信号
     while (true)
    {
        cout << "I am a process, pid: " << getpid() << endl;
        sleep(1);
        cnt--;
        if(cnt== 0) 
        {
            raise(2);  //等价于 kill(getpid() , 2) 
        }
    }
    return 0 ;
}

abort 发送6号信号和终止进程

       void abort(void);

信号产生的方式，但是无论信号如何产生，最终操作系统发送给进程，因为操作系统是进程的管理者

alarm ，设置一个闹钟

 unsigned int alarm(unsigned int seconds);

return val:
alarm 函数返回的是之前设置的定时器的剩余时间。如果之前没有设置定时器，或者定时器已经到期，返回 0。
返回的剩余时间是指在调用新的 alarm 之前，定时器还有多少秒才会发送 SIGALRM 信号。

#include <iostream>
 #include <unistd.h>
  #include <signal.h>

using namespace std;
void myhandler(int signo)
{
    
    cout<<"xxxxxxxxxx"<<signo<<endl;

    //理解alarm的返回值
     int n = alarm(3);
     cout<<"剩余时间："<<n<<endl;
    //exit(1);
}


int main()
{
    int n = alarm(50);//alarm发送的是14号信号
    signal(14,myhandler);//myha ndler是一个函数指针
     while(1)
    {
        cout << "proc is running  pid :%d" <<" "<<getpid()<< endl;
        sleep(1);
    }
    return 0 ;
}

打开系统的core dump （核心转储）功能，一旦进程出异常，操作系统会将进程在内存中的运行信息，给转诸到进程的当前目录，并形成core.pid文件

ulimit ：显示和设置用户可以启动的进程的资源限制

[cxq@iZwz9fjj2ssnshikw14avaZ output]$ ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 6943
max locked memory       (kbytes, -l) 64
max memory size         (kbytes, -m) unlimited
open files                      (-n) 65535
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 4096
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited

打开系统的core dump （核心转储）功能，将core file size 设置为10240

[cxq@iZwz9fjj2ssnshikw14avaZ output]$ ulimit -c 10240
[cxq@iZwz9fjj2ssnshikw14avaZ output]$ ulimit -a
core file size          (blocks, -c) 10240
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 6943
max locked memory       (kbytes, -l) 64
max memory size         (kbytes, -m) unlimited
open files                      (-n) 65535
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 4096
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited

测试 core dump功能

#include <iostream>
 #include <unistd.h>
  #include <signal.h>
 #include <sys/types.h>
       #include <sys/wait.h>
using namespace std;
int main()
{

    //测试  core dump功能


    cout << " a = " << a << endl;
    pid_t id = fork();
        if(id==0)
        {
            //child
              int cnt = 500;
        while(cnt)
        {
            cout << "i am a child process, pid: " << getpid() << "cnt: " << cnt << endl;
            sleep(1);
            cnt--;
        }
        exit(0);
        }
        //father 
        //进程等待
        int status =0 ;
        pid_t rid=waitpid(id,&status,0);//阻塞等待

        if(rid==id)
        {
                 cout << "child quit info, rid: " << rid << " exit code: " << 
            ((status>>8)&0xFF) << " exit signal: " << (status&0x7F) <<
                " core dump: " << ((status>>7)&1) << endl; //  (0000 0000 ... 0001)
        }
    return 0 ;
}

生成的core.pid文件，可以通过gdb直接定位到出错行

阻塞信号

信号常见概念
1、实际执行信号的处理动作，称为信号递达（Delivery）。
例：进程内置了对信号处理的默认动作、进程可以忽略信号、还是自定义动作 这些都是信号的处理动作，都是信号递达

2、信号从产生到递达之间的状态，称为信号未决（pending）。
信号从产生到递达之前，此时信号处于位图中，此时信号处于保存状态 ，这种状态称为信号未决

3、进程可以选择阻塞（Block）某个信号。这里的阻塞可以理解为屏蔽

• 默认情况下，所有信号都是没有被屏蔽的 ， 进程可以屏蔽某些信号，在解除屏蔽之前，信号 也不会被操作系统进行递达

• 如果进程没有收到某一个信号，也可以屏蔽这个信号

4、被阻塞的信号产生时将保持在未决状态，直到进程解除对此信号的阻塞，才执行递达的动作。

• 一个信息如果被阻塞了（屏蔽），如果此时用户向进程发送了指定的信号，该信号不会被递达，直到解除了阻塞 ，也就是说阻塞了还是可以给进程发送信号，只不过信号暂时被屏蔽罢了

5阻塞和忽略是完全不同的，只要信号被阻塞就不会递达，而忽略是在递达之后的一种处理动作

• 只要信号被阻塞就不会递达，即不会被处理，屏蔽和解决屏蔽一定是在递达之前做的
• 忽略的本质是处理信号，忽略是信号递达的三种方式之一，忽略是在递达之后的一种处理动作
• 阻塞可以理解为未读，忽略可以理解为已读不回

block表：.比特位的内容是1还是0，表明是否屏蔽信号
比特位的位置(第几个)，表示信号的编号

pending表：
比特位的内容是1还是0，表明是否收到信号
比特位的位置(第几个)，表示信号的编号
handler表：
handler表本质上是一个函数指针数组，数组的下标代表某一个信号，数组的内容代表该信号递达时的处理动作，处理动作包括默认、忽略以及自定义
block、pending和handler这三张表的每一个位置是一一对应的

• 每个信号都有两个标志位分别表示阻塞（block）和未决（pending），还有一个函数指针表示处理动作。信号产生时，内核在进程控制块中设置该信号的未决标志，直到信号递达才清除该标志。在上图中，SIGHUP信号未阻塞也未产生过，当它递达时执行默认处理动作。
• SIGINT信号产生过，但正在被阻塞，所以暂时不能递达。虽然它的处理动作是忽略，但在没有解除阻塞之前不能忽略这个信号，因为进程仍有机会在改变处理动作之后再接触阻塞。
• SIGQUIT信号未产生过，但一旦产生SIGQUIT信号，该信号将被阻塞，它的处理动作是用户自定义函数sighandler。如果在进程解除对某信号的阻塞之前，这种信号产生过多次，POSIX.1允许系统递达该信号一次或多次。Linux是这样实现的：普通信号在递达之前产生多次只计一次，而实时信号在递达之前产生多次可以依次放在一个队列里，这里只讨论普通信号

#include <iostream>
 #include <unistd.h>
  #include <signal.h>
 #include <sys/types.h>
  #include <sys/wait.h>
using namespace std;
int main()
{
	//理解handler表的SIG_IGN，SIG_DFL
  //signal(2,SIG_IGN);//忽略2号信号
  signal(2,SIG_DFL);//使用2号信号的默认处理方法

    while(1)
    {
        cout << "hello signal" << endl;
        sleep(1);
    }

  return  0; 
}

sigset_t

根据信号在内核中的表示方法，每个信号的未决标志只有一个比特位，非0即1，如果不记录该信号产生了多少次，那么阻塞标志也只有一个比特位。因此，未决和阻塞标志可以用相同的数据类型sigset_t来存储

在我当前的云服务器中，sigset_t类型的定义如下：（不同操作系统实现sigset_t的方案可能不同）

typedef __sigset_t sigset_t;

# define _SIGSET_NWORDS	(1024 / (8 * sizeof (unsigned long int)))
typedef struct
  {
    unsigned long int __val[_SIGSET_NWORDS];
  } __sigset_t;

sigset_t称为信号集，这个类型可以表示每个信号的“有效”或“无效”状态。

• 在阻塞信号集中“有效”和“无效”的含义是该信号是否被阻塞。
• 在未决信号集中“有效”和“无效”的含义是该信号是否处于未决状态。

阻塞信号集也叫做当前进程的信号屏蔽字（Signal Mask），这里的“屏蔽”应该理解为阻塞而不是忽略

#include <signal.h>

//sigemptyset、sigfillset、sigaddset和sigdelset函数都是成功返回0，出错返回-1。

int sigemptyset(sigset_t *set);//初始化set所指向的信号集，使其中所有信号的对应bit清零，表示该信号集不包含任何有效信号

int sigfillset(sigset_t *set);//始化set所指向的信号集，使其中所有信号的对应bit置位，表示该信号集的有效信号包括系统支持的所有信号。

int sigaddset(sigset_t *set, int signum);//在set所指向的信号集中添加某种有效信号。

int sigdelset(sigset_t *set, int signum);//在set所指向的信号集中删除某种有效信号。

int sigismember(const sigset_t *set, int signum);  //判断在set所指向的信号集中是否包含某种信号，若包含则返回1，不包含则返回0，调用失败返回-1。

sigprocmask

sigprocmask ：用于读取或更改进程的信号屏蔽字（阻塞信号集）

int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

1、如果oldset是非空指针，则读取进程当前的信号屏蔽字通过oldset参数传出。
2、如果set是非空指针，则更改进程的信号屏蔽字，参数how指示如何更改。
3、如果oldset和set都是非空指针，则先将原来的信号屏蔽字备份到oldset里，然后根据set和how参数更改信号屏蔽字

how参数的可选值及其含义: 以下三个只能选一个作为how参数

• SIG_BLOCK set包含了我们希望添加到当前信号屏蔽字的信号，相当于mask=mask|set
• SIG_UNBLOCK set包含了我们希望从当前信号屏蔽字中解除阻塞的信号，相当于mask=mask|~set
• SIG_SETMASK 覆盖式的设置当前信号屏蔽字为set所指向的值，相当于mask=set

return val: sigprocmask函数调用成功返回0，出错返回-1。

如果调用sigprocmask解除了对当前若干个未决信号的阻塞，则在sigprocmask函数返回前，至少将其中一个信号递达

sigpending

sigpending：用于读取进程的未决信号集，

int sigpending(sigset_t *set);

sigpending函数读取当前进程的未决信号集，并通过set参数传出。
return val :该函数调用成功返回0，出错返回-1。

1、将2号信号进行屏蔽（阻塞）。

2、使用kill命令或组合按键向进程发送2号信号。
3、此时2号信号会一直被阻塞，并一直处于pending（未决）状态。
4、使用sigpending函数获取当前进程的pending信号集进行验证
测试代码：

#include<iostream>
  #include <signal.h>
#include<unistd.h>
using namespace std ;

void PrintPending(sigset_t & pending)
{
    for(int signo = 31 ;   signo>=1 ; signo--)
    {
        if(sigismember(&pending , signo)  ==1)//判断在set所指向的信号集中是否包含某种信号
        {
            //存在
             cout << "1";
        }
           else
        {
            //不存在
            cout << "0";
        }
    }
        // cout << "\n\n";//将光标从当前位置向下移动两行
        cout<<endl;
        cout<<endl;

}
int main()
{
    //将2号信号进行屏蔽（阻塞）。
// 使用kill命令或组合按键向进程发送2号信号。
// 此时2号信号会一直被阻塞，并一直处于pending（未决）状态。
// 使用sigpending函数获取当前进程的pending信号集进行验证
sigset_t  bset,oset ;
sigemptyset(&bset);//使bset其中所有信号的对应bit清零
sigemptyset(&oset);//使oset其中所有信号的对应bit清零

sigaddset(&bset,2);//在set所指向的信号集中添加2号信号。
sigprocmask(SIG_SETMASK ,&bset, &oset);//把bset覆盖式的设置到进程的block位图中

//代码走到这里，已经屏蔽2号信号了

//重复打印当前进程的pending

sigset_t pending ;
int cnt =0 ;
while(true)
{
      // 2.1 获取
    int n = sigpending(&pending);
       if (n < 0)
             continue;
   // 2.2 打印
    PrintPending(pending);
     sleep(1);
    // 2.3 解除阻塞
  cnt ++;
  if(cnt ==20)
  {
        cout << "unblock 2 signo" << endl;
        sigprocmask(SIG_SETMASK ,&oset,nullptr);//更改进程的信号屏蔽字,覆盖式的设置当前信号屏蔽字为bset所指向的值
  }
}
    return 0 ; 
}

内核态与用户态：

• 内核态：允许访问操作系统的代码和数据，是一种权限非常高的状态。
• 用户态：只能访问用户自己的代码和数据，是一种受监管的普通状态。

当进程从内核态返回到用户态时，进行信号的检测和处理

调用系统调用时，操作系统是自动会"身份"切换的 ，从用户身份变成内核身份，或者从内核身份变成用户身份

用户态切换为内核态我们称之为陷入内核。每当我们需要陷入内核的时，本质上是因为我们需要执行操作系统的代码，比如系统调用函数是由操作系统实现的，我们要进行系统调用就必须先由用户态切换为内核态

内核空间与用户空间

每一个进程都有自己的进程地址空间，该进程地址空间由内核空间和用户空间组成：

用户所写的代码和数据位于用户空间，通过用户级页表与物理内存之间建立映射关系。
内核空间存储的实际上是操作系统代码和数据，通过内核级页表与物理内存之间建立映射关系

CR3 寄存器存储了页表的起始物理地址，这个地址指向了页全局目录的起始位置

用户页表有几份?
有几个进程，就有几份用户级页表 , 进程具有独立性

内核页表有几份?
1份

内核级页表是一个全局的页表，它用来维护操作系统的代码与进程之间的关系。因此，在每个进程的进程地址空间中，用户空间是属于当前进程的，每个进程看到的代码和数据是完全不同的，但内核空间所存放的都是操作系统的代码和数据，所有进程看到的都是一样的内容

总结：

• 每一个进程看到的3到4GB的东西都是一样的
• 整个系统中，进程再怎么切换，3到4GB的空间的内容是不变的

进程视角:我们调用系统中的方法，就是在我自己的地址空间中进行执行的。

操作系统视角:任何一个时刻，都有有进程执行。我们想执行操作系统的代码，就可以随时执行

操作系统的本质:基于时钟中断的一个死循环

计算机硬件中，有一个时钟芯片，每个很短的时间，向计算机发送时钟中断

如何理解进程切换？
1、在当前进程的进程地址空间中的内核空间，找到操作系统的代码和数据。
2、执行操作系统的代码，将当前进程的代码和数据剥离下来，并换上另一个进程的代码和数据。
当你访问用户空间时你必须处于用户态，当你访问内核空间时你必须处于内核态

内核如何实现信号的捕捉

当我们在执行主控制流程的时候，可能因为某些情况而陷入内核，当内核处理完毕准备返回用户态时，就需要进行信号pending的检查。（此时仍处于内核态，有权力查看当前进程的pending位图）

在查看pending位图时，如果发现有未决信号，并且该信号没有被阻塞，那么此时就需要该信号进行处理。

如果待处理信号的处理动作是默认或者忽略，则执行该信号的处理动作后清除对应的pending标志位，如果没有新的信号要递达，就直接返回用户态，从主控制流程中上次被中断的地方继续向下执行即可

但如果待处理信号是自定义捕捉的，即该信号的处理动作是由用户提供的，那么处理该信号时就需要先返回用户态执行对应的自定义处理动作，执行完后再通过特殊的系统调用sigreturn再次陷入内核并清除对应的pending标志位，如果没有新的信号要递达，就直接返回用户态，继续执行主控制流程的代码。

sighandler和main函数使用不同的堆栈空间，它们之间不存在调用和被调用的关系，是两个独立的控制流程