---

📝信号快速认识

📶⽣活⻆度的信号

• 你在⽹上买了很多件商品，再等待不同商品快递的到来。但即便快递没有到来，你也知道快递来临时，你该怎么处理快递。也就是你能“识别快递”
• 当快递员到了你楼下，你也收到快递到来的通知，但是你正在打游戏，需5min之后才能去取快递。那么在在这5min之内，你并没有下去去取快递，但是你是知道有快递到来了。也就是取快递的⾏为并不是⼀定要⽴即执⾏，可以理解成“在合适的时候去取”。
• 在收到通知，再到你拿到快递期间，是有⼀个时间窗⼝的，在这段时间，你并没有拿到快递，但是你知道有⼀个快递已经来了。本质上是你“记住了有⼀个快递要去取”
• 当你时间合适，顺利拿到快递之后，就要开始处理快递了。⽽处理快递⼀般⽅式有三种：
• 1.执⾏默认动作（幸福的打开快递，使⽤商品）
• 2.执⾏⾃定义动作（快递是零⻝，你要送给你你的⼥朋友）
• 3. 忽略快递（快递拿上来之后，扔掉床头，继续开⼀把游戏）

快递到来的整个过程，对你来讲是异步的，你不能准确断定快递员什么时候给你打电话

基本结论：

1. 你怎么能识别信号呢？识别信号是内置的，进程识别信号，是内核程序员写的内置特性。
2. 信号产⽣之后，你知道怎么处理吗？知道。如果信号没有产⽣，你知道怎么处理信号吗？知道。所以，信号的处理⽅法，在信号产⽣之前，已经准备好了。
3. 处理信号，⽴即处理吗？我可能正在做优先级更⾼的事情，不会⽴即处理？什么时候？合适的时候。
4. 信号到来|信号保存 |信号处理
5. 怎么进⾏信号处理啊？a.默认b.忽略c.⾃定义，后续都叫做信号捕捉。
   

📶 技术应⽤⻆度的信号

🌉 前台进程（键盘）

样例：
sig.cc:

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

int main()
{
    while(true)
    {
        std::cout<< "I am a process, I am wiat signal!" <<std::endl;
        sleep(1);
    }
    return 0;
}

Makefile:

BIN=sig
OBJS=$(SRCS:.cc=.o)
SRCS=$(shell ls *.cc)
CC=g++

$(BIN):$(OBJS)
	$(CC) -o $@ $^ -std=c++11

%.o:%.cc
	$(CC) -c $< -std=c++11

.PHONY:clean
clean:
	rm -f $(BIN) $(OBJS)

⽤⼾输⼊命令,在Shell下启动⼀个前台进程
⽤⼾按下程Ctrl+C
,这个键盘输⼊产⽣⼀个硬件中断，被OS获取，解释成信号，发送给⽬标前台进
前台进程因为收到信号，进⽽引起进程退出

🌉⼀个系统函数

指令：

man signal

而其实，ctrl+C的本质是向前台进程发送|SIGINT|即2号信号，我们证明一下，这里需要引入一个系统调用函数

NAME
       signal - ANSI C signal handling

SYNOPSIS
       #include <signal.h>

       typedef void (*sighandler_t)(int);

       sighandler_t signal(int signum, sighandler_t handler);

参数说明：
signum：信号编号[后⾯解释，只需要知道是数字即可]
handler：函数指针，表⽰更改信号的处理动作，当收到对应的信号，就回调执⾏handler⽅法

代码：

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

void handler(int signumber)
{
    std::cout<<"我是："<<getpid() <<",我获得一个信号："<< signumber <<std::endl;
}

int main()
{
    std::cout<<"我是进程: "<<getpid() <<std::endl;
    signal(SIGINT/*2*/, handler);
    while(true)
    {
        std::cout<<"I am a process, I am waiting signal!"<< std::endl;
        sleep(1);
    }
    return 0;
}

思考:

• 这⾥进程为什么不退出？
• 这个例⼦能说明哪些问题？信号处理，是⾃⼰处理
• 请将⽣活例⼦和Ctrl-C 信号处理过程相结合，解释⼀下信号处理过程？进程就是你，
  操作系统就是快递员，信号就是快递，发信号的过程就类似给你打电

注意：

1. 要注意的是，signal函数仅仅是设置了特定信号的捕捉⾏为处理⽅式，并不是直接调⽤处理动作。如果后续特定信号没有产⽣，设置的捕捉函数永远也不会被调⽤！！
2. Ctrl-C 产⽣的信号只能发给前台进程。⼀个命令后⾯加个&可以放到后台运⾏,这样Shell不必等待进程结束就可以接受新的命令,启动新的进程。
3. Shell可以同时运⾏⼀个前台进程和任意多个后台进程,只有前台进程才能接到像Ctrl-C这种控制键产⽣的信号。
4. 前台进程在运⾏过程中⽤⼾随时可能按下Ctrl-C⽽产⽣⼀个信号,也就是说该进程的⽤⼾空间代码执⾏到任何地⽅都有可能收到SIGINT 信号⽽终⽌,所以信号相对于进程的控制流程来说是异步(Asynchronous)的。
5. 可以渗透&和nohup

📶信号概念

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

📶查看信号

每个信号都有⼀个编号和⼀个宏定义名称,这些宏定义可以在signal.h中找到,例如其中有定义

#define SIGINT 2

编号34以上的是实时信号,本章只讨论编号34以下的信号,不讨论实时信号。这些信号各⾃在什么条件下产⽣,默认的处理动作是什么,在signal(7)中都有详细说明:

 man 7 signal

🌠 信号处理

(sigaction 函数稍后详细介绍),可选的处理动作有以下三种:

🌉 忽略此信号

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

void handler(int signumber)
{
    std::cout<<"我是："<<getpid() <<",我获得一个信号："<< signumber <<std::endl;
}

int main()
{
    std::cout<<"我是进程: "<<getpid() <<std::endl;
    signal(SIGINT/*2*/, SIG_IGN);// 设置忽略信号的宏
 
    while(true)
    {
        std::cout<<"I am a process, I am waiting signal!"<< std::endl;
        sleep(1);
    }
    return 0;
}

🌉 执⾏该信号的默认处理动作。

default默认行为SIG_DFL

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

void handler(int signumber)
{
    std::cout<<"我是："<<getpid() <<",我获得一个信号："<< signumber <<std::endl;
}

int main()
{
    std::cout<<"我是进程: "<<getpid() <<std::endl;
    // signal(SIGINT/*2*/, SIG_IGN);// 设置忽略信号的宏
    signal(SIGINT/*2*/, SIG_DFL);// 输⼊ctrl+c,进程退出，就是默认动作
 
 
    while(true)
    {
        std::cout<<"I am a process, I am waiting signal!"<< std::endl;
        sleep(1);
    }
    return 0;
}

🌉 切换状态函数

其实这里就是转到用户自定义的handler函数

提供⼀个信号处理函数,要求内核在处理该信号时切换到⽤⼾态执⾏这个处理函数,这种⽅式称为⾃定义捕捉(Catch)⼀个信号。

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

void signal_handler(int signum) {  
    // 自定义的信号处理函数  
    printf("Caught signal %d\n", signum);  
    // 在这里执行需要在用户态下运行的代码  
    // ...  
}  

int main() {  
    // 注册信号处理函数  
    signal(SIGINT, signal_handler);  

    printf("Press Ctrl+C to send SIGINT signal...\n");  
    while (1) {  
        // 等待信号到来  
        pause();  
    }  

    return 0;  
}

注意看源码：

/* Fake signal functions.  */

#define	SIG_ERR	 ((__sighandler_t) -1)	/* Error return.  */
#define	SIG_DFL	 ((__sighandler_t)  0)	/* Default action.  */
#define	SIG_IGN	 ((__sighandler_t)  1)	/* Ignore signal.  */
/* Type of a signal handler.  */
typedef void (*__sighandler_t) (int);

让我们来逐一分析:

1. #define SIG_ERR ((__sighandler_t) -1): 这个宏定义了 SIG_ERR，它被赋值为 -1，类型为 __sighandler_t。这通常用作 signal() 函数的返回值,表示发生错误。

2. #define SIG_DFL ((__sighandler_t) 0): 这个宏定义了 SIG_DFL，它被赋值为 0，类型为 __sighandler_t。这用于指定使用默认的信号处理函数。

3. #define SIG_IGN ((__sighandler_t) 1): 这个宏定义了 SIG_IGN，它被赋值为 1，类型为 __sighandler_t。这用于指定忽略该信号。

其实SIG_DFL和SIG_IGN就是把0,1强转为函数指针类型

---

🚩总结