实操（不可重入函数、volatile、SIGCHLD、线程）Linux
1 不可重入函数
为什么会导致节点丢失内存泄露？main函数在执行insert，但是没执行完就被信号中断了，又进了这个函数里，所以这个insert函数在不同的执行流中，同一个函数被重复进入，如果没有问题，该函数被称为可重入函数，如果有问题，该函数被称为不可重入函数
如果一个函数符合以下条件之一则是不可重入的:
- 调用了malloc或free,因为malloc也是用全局链表来管理堆的。
- 调用了标准I/0库函数。标准I/0库的很多实现都以不可重入的方式使用全局数据结构。
2 volatile
一开始程序疯狂的卡在while循环，如果收到了2号信号（ctrl+c），quit由0变1，逻辑反条件就不满足，输出正常退出结果
makefile
mysignal:signal.c
gcc -o $@ $^
.PHONY:clean
clean:
rm -f mysignalsignal.c
#include <stdio.h>
#include <signal.h>
int quit = 0;
void handler(int signo)
{
printf("change quit from 0 to 1\n");
quit = 1;
printf("quit=%d\n", quit);
}
int main()
{
signal(2, handler);
while(!quit); //注意这里故意没有携带while的代码块，故意让编译器认为在main中，quit只会被检测
printf("main 正常退出\n");
return 0;
}
- 无论你在进程里面定义多少变量，最终想能够被访问，必须要加载到物理内存里，只不过是通过虚拟地址空间让我们找到它而已，定义的全局quit变量，当二进制程序开始执行，一定要在内存里把数据（代码）开辟好，所以quit毫无疑问在内存当中；循环判断的时候是一种计算，cpu匹配运算的种类，一种是算术运算（加减乘除取模、各种浮点数运算），一种是逻辑运算（真假判断、逻辑与、逻辑取反），while（!quit）是在CPU上跑，现在的问题是你要检测的数据开始的时候是在内存里，要计算的时候是在CPU内部，所以如果你想要计算，第一件事情是将内存中的数据通过某种方式load到CPU内，cpu中有对应的寄存器、pc指针，把quit=0放进寄存器，它才会对quit做真假判断，PC指针表征当前的进程执行到哪里，如果条件满足，pc指针继续执行while（!quit）代码，如果当前条件不满足，它会让PC指针向下移动，指向下一条语句，开始向后执行，整个逻辑就是这样子的，总结一下就三步，第一要把数据从内存加载到CPU里的寄存器，第二做判断运算，第三判断完成后更改PC指针（继续执行当前语句还是下一条语句）
- 后面加了信号的捕捉，2号信号到来的时候调用handler方法，将quit改成1，后面的逻辑依旧是要做判断，CPU从内存里读取qiit=1，逻辑反之后判断条件满不满足，更改PC指针，这是我们之前退出的原因，数据一旦被修改就可以被while循环检测到，条件不满足就退出了
实际上c++在编译的时候是有优化级别的，查看man手册（man gcc），找到优化选项（/Optimization Options）
按了2号信号，quit改成1了却还不退出的现象，退出指令（ctrl+\）
makefile（在第二行加一个 O2选项）
mysignal:signal.c
gcc -o $@ $^ -O2
.PHONY:clean
clean:
rm -f mysignal 显示
- 在刚刚的过程中，让计算机执行while循环，每一次都要尝试着把数据从内存加载到CPU，在main函数里，我发现quit是没有被修改的，只是在被检测，编译器编译的时候发现，quit变量没有被修改，为什么要重复做把数据加载到cpu里的动作呢，只需要在代码编译形成汇编代码时，把数据加载到CPU里的寄存器，往后循环检测时直接检测寄存器里的就行了，不用再去内存里面查quit，因为每次找结果都是一样的，好比你问某个人问了好几次不同的问题，他都说不知道，那你下次再想问他问题的时候，本来要张口的，心里想着说算了，反正他也不知道，那你对这个人的判断就是以后问他什么问题他都不知道，同样的，编译器就不需要在内存里找了，直接检测寄存器里的数据就可以了，编译器就这么认为的，它会将quit变量直接优化到CPU里的寄存器当中，只有第一次会将quit加载到寄存器里，往后判断时候只检测寄存器是否为真还是假，再决策对应的指针，相当于CPU遵循就近原则，只查寄存器的值而不查内存的值，叫做内存位置不可见了，这就是为什么加了优化，quit=1也执行了，最终这个循环却不退出的原因
所以为了解决这个问题，要告诉编译器保证每次检测都要尝试着从内存中进行数据读取，不要用寄存器中的数据，让内存数据可见！就有了volatile关键字，他的作用就是杜绝对quit变量做寄存器级别的优化，保证内存可见性
加volatile关键字，让main正常退出
volatile int quit = 0;显示
3 SIGCHLD
子进程退出的时候会向父进程发SIGCHLD信号，但是父进程默认处理动作是忽略的，所以我们为了证明它会发，我们可以自定义捕捉SIGCHLD信号（现象是子进程被创建出来，先正常运行5秒，期间父进程持续做自己的事情，当信号到来的时候会等待5秒钟，但是在等期间这个子进程已经退了，且会处于僵尸状态，因为父进程还没回收它，5秒之后wait它的时候，最终我们就会看到打印等待成功，僵尸状态也会随着消失）
makefile
mysignal:signal.c
gcc -o $@ $^ #-O2
.PHONY:clean
clean:
rm -f mysignal 查看waitpid第一个参数说明（man waipid）
pid_t waitpid(pid_t pid, int *wstatus, int options);
- 大于0代表你传的参数就是你要等的进程的id，-1代表等待任意一个子进程
signal.c
#include <stdio.h>
#include <signal.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>
//id暂时定义成全局的，一会方便做对比，因为信号和main函数是两个执行流
pid_t id;
void handler(int signo)
{
sleep(5);
printf("捕捉到一个信号：%d，who：%d\n", signo, getpid());
//-1表示等待任意一个子进程，退出结果不关心，阻塞式等待
//虽然写了0，阻塞式等待，我们绝对不会被阻塞，因为我已经收到信号了
//就证明当前的子进程肯定有退的，waitpid就可以返回了
pid_t res = waitpid(-1, NULL, 0);
if (res > 0)
{
//等待成功返回子进程的pid
//id 在父进程中存储的是子进程的 PID
printf("wait success, res: %d, id: %d\n", res, id);
}
}
int main()
{
signal(SIGCHLD, handler);
id = fork();
if (id == 0)
{
int cnt = 5;
while(cnt--)
{
printf("我是子进程，我的pid：%d, ppid: %d\n", getpid(), getppid());
sleep(1);
}
exit(1);
}
while(1)
{
sleep(1);
}
return 0;
}显示（while :; do ps axj | head -1&&ps axj | grep mysignal | grep -v grep; echo "---------------"; sleep 1; done）
现在来了一大堆的信号，pending位图比特位只有一个，比如第一个子进程退了，pending位设置1，第二个子进程来了，无非就是把1再置为1，此时信号不就相当于丢失了吗，相当于子进程退出发了10个信号，可能导致最终只回收了两三个子进程
signal.c
int main()
{
signal(SIGCHLD, handler);
int i = 1;
for(; i <= 10; ++i)
{
id = fork();
if (id == 0)
{
int cnt = 5;
while(cnt--)
{
printf("我是子进程，我的pid：%d, ppid: %d\n", getpid(), getppid());
sleep(1);
}
exit(1);
}
}
while(1)
{
sleep(1);
}
return 0;
}显示
- 只回收了两个子进程
所以要while式的循环回收，你有几个进程我就回收几个进程
signal.c
void handler(int signo)
{
printf("捕捉到一个信号：%d，who：%d\n", signo, getpid());
sleep(5);
while(1)
{
//-1表示等待任意一个子进程，退出结果不关心，阻塞式等待
//虽然写了0，阻塞式等待，我们绝对不会被阻塞，因为我已经收到信号了
//就证明当前的子进程肯定有退的，waitpid就可以返回了
pid_t res = waitpid(-1, NULL, 0);
if (res > 0)
{
//等待成功返回子进程的pid, id 在父进程中存储的是子进程的 PID
printf("wait success, res: %d, id: %d\n", res, id);
}
else break; //如果没有子进程了
}
printf("handler done...\n");
}显示
假如有五个子进程退出五个子进程没退出，waitpid一直循环回收，它总会碰到没有退出的子进程，就会一直处于阻塞状态，导致handler无法返回，代码没办法再向后运行，所以要将它改成非阻塞等待，pid_t res = waitpid(-1, NULL, WNOHANG);完整代码
#include <stdio.h>
#include <signal.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>
//id暂时定义成全局的，一会方便做对比，因为信号和main函数是两个执行流
pid_t id;
void waitProcess(int signo)
{
printf("捕捉到一个信号：%d，who：%d\n", signo, getpid());
sleep(5);
while(1)
{
//-1表示等待任意一个子进程，退出结果不关心，阻塞式等待
//虽然写了0，阻塞式等待，我们绝对不会被阻塞，因为我已经收到信号了
//就证明当前的子进程肯定有退的，waitpid就可以返回了
//pid_t res = waitpid(-1, NULL, 0);
//非阻塞等待，有就回收，没有就出错返回
pid_t res = waitpid(-1, NULL, WNOHANG);
if (res > 0)
{
//等待成功返回子进程的pid, id 在父进程中存储的是子进程的 PID
printf("wait success, res: %d, id: %d\n", res, id);
}
else break; //如果没有子进程了
}
printf("handler done...\n");
}
int main()
{
signal(SIGCHLD, waitProcess);
int i = 1;
for(; i <= 10; ++i)
{
id = fork();
if (id == 0)
{
int cnt = 5;
while(cnt--)
{
printf("我是子进程，我的pid：%d, ppid: %d\n", getpid(), getppid());
sleep(1);
}
exit(1);
}
}
while(1)
{
sleep(1);
}
return 0;
}- 一个基于信号版的回收子进程的代码
显示
要想不产生僵尸进程，还有另一种办法，父进程调用sigaction将SIGCHLD的处理动作置为SIG_IGN，往后创建的子进程在退出时就会被操作系统自动清理，不会产生僵尸进程，也不会通知父进程
signal.c（signal(SIGCHLD, waitProcess);）改成
signal(SIGCHLD, SIG_IGN);显示
子进程退了，会给父进程发信号，父进程默认对该信号的处理动作是忽略，为什么还要再调一下这个signal函数呢
这其实是一种特殊情况，可以理解成在signal方法里，父进程调用signal的时候，如果他检测到你是SIGCHLD, SIG_IGN这种组合，除了设置SIGCHLD信号为忽略之外，他还会修改父进程PCB的状态位，因为子进程的状态是按父进程来的，父进程相当于可以给自己打一个标签，假设我创建的子进程以后就不要僵尸，这个标志位就会在fork的时候被子进程继承下去，所当子进程退出的时候，操作系统发现子进程退了，检测标志时发现这个进程早就设置过了标志位，你退了就直接把你释放掉了，相当于在信号handler表当中，默认是SIG_IGN，他就执行默认动作，如果你自己手动调了signal或sigaction，它是系统调用，会修改未来创建子进程的一些状态位，方便操作系统识别进而直接回收它；也可以这样理解，以前对子进程退出信号的默认动作是SIG_DFL，什么都不做，现在设置成SIG_IGN，操作系统就把它回收掉了
4 线程（看看现象）
makefile
mysignal:signal.c
gcc -o $@ $^ -lpthread
.PHONY:clean
clean:
rm -f mysignal signal.c
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
void *thread1_run(void *args)
{
while(1)
{
printf("我是线程1，我正在运行\n");
sleep(1);
}
}
void *thread2_run(void *args)
{
while(1)
{
printf("我是线程2，我正在运行\n");
sleep(1);
}
}
void *thread3_run(void *args)
{
while(1)
{
printf("我是线程3，我正在运行\n");
sleep(1);
}
}
int main()
{
pthread_t t1, t2, t3;
pthread_create(&t1, NULL, thread1_run, NULL);
pthread_create(&t2, NULL, thread2_run, NULL);
pthread_create(&t3, NULL, thread3_run, NULL);
while(1)
{
printf("我是主线程，我正在运行\n");
sleep(1);
}
}查看线程（ps -aL | head -1&&ps -aL | grep mysignal）
- 可以看出他们是属于同一个进程的，因为他们的PID都是一样的，LWP叫做轻量级进程，第一行执行流他的PID和LWP数字是一样的，那操作系统调度的时候如何区分呢，所以真正意义上，操作系统调度的时候，看的是LWP，所以CPU调度的时候，根据LWP，调度不同的线程去运行，以前我们说根据PID也没有错，因为当你的进程当中只有一个执行流时，PID和LWP数字是一样的，看哪个都行