（C++通讯架构学习笔记）：fork函数详解、范例演示_c++ fork

目录

fork()函数简单认识

僵尸进程的产生、解决，SIGCHLD

fork()函数进一步认识

完善一下fork()代码

fork()失败的可能性

fork()函数简单认识

• 创建进程
• 进程的概念：一个可执行程序，执行起来就是一个进程，再执行起来一次，它就又是一个进程（多个进程可以共享同一个可执行文件）。
  • 文雅说法：进程 定义为程序执行的一个实例。
• 在一个进程（程序）中，可以用fork()创建一个子进程，当该子进程创建时，它从fork()指令的下一条(或者说从fork()的返回处)开始执行与父进程相同的代码。
• fork()函数产生了一个和当前进程完全一样的新进程，并和当前进程一样从fork()函数里返回。
  • 原来一条执行通路（父进程），现在变成两条（父进程+子进程）

【fork()函数简单范例】

• fork()：一分二

#include <stdio.h>
#include <stdlib.h>  //malloc,exit
#include <unistd.h>  //fork
#include <signal.h>
 
//信号处理函数
void sig_usr(int signo)
{
    printf("收到了SIGUSR1信号，进程id=%d!\n",getpid());    
}
 
int main(int argc, char *const *argv)
{
    pid_t  pid;
 
    printf("进程开始执行!\n");
 
    //先简单处理一个信号
    if(signal(SIGUSR1,sig_usr) == SIG_ERR)  //系统函数，参数1：是个信号，参数2：是个函数指针，代表一个针对该信号的捕捉处理函数
    {
        printf("无法捕捉SIGUSR1信号!\n");
        exit(1);
    }
 
    //---------------------------------
    pid = fork();  //创建一个子进程
 
    //要判断子进程是否创建成功
    if(pid < 0)
    {
        printf("子进程创建失败，很遗憾!\n");
        exit(1);
    }
 
    //现在，父进程和子进程同时开始 运行了 
    for(;;)
    {        
        sleep(1); //休息1秒
        printf("休息1秒，进程id=%d!\n",getpid());
    }
    printf("再见了!\n");
    return 0;
}

• 执行程序:

ps -eo pid,ppid,sid,tty,pgrp,comm,stat | grep -E 'bash|PID|nginx'

• fork()之后，是父进程fork()之后的代码先执行还是子进程fork()之后的代码先执行是不一定的，这个跟内核调度算法有关。

【发送信号进行测试】

• 向父进程发送信号

• 程序收到信号

• 向子进程发送信号

• 程序收到信号

【僵尸进程的产生测试】

• 追踪父进程

• kill子进程，观察父进程收到什么信号

• 观察父进程信息

• 子进程向父进程发送SIGCHLD信号 ，子进程变成了僵尸进程Z

僵尸进程的产生、解决，SIGCHLD

【僵尸进程的产生】

• 在Unix系统中，一个子进程结束了，但是他的父进程还活着，但该父进程没有调用(wait/waitpid)函数来进行额外的处置，那么这个子进程就会变成一个僵尸进程。
• 僵尸进程：已经被终止，不干活了，但是依旧没有被内核丢弃掉，因为内核认为父进程可能还需要该子进程的一些信息。
• 作为开发者，坚决不允许僵尸进程的存在。
• 如何干掉僵尸进程：
  • 重启电脑
  • 手工的把僵尸进程的父进程kill掉，僵尸进程就会自动消失；
  • waitpid()：SIGCHLD信号，一个进程被终止或者停止时，这个信号会被发送给父进程。
    • 所以，对于源码中有fork()行为的进程，我们 应该拦截并处理SIGCHLD信号。

#include <stdio.h>
#include <stdlib.h>  //malloc,exit
#include <unistd.h>  //fork
#include <signal.h>
#include <sys/wait.h>  //waitpid
 
//信号处理函数
void sig_usr(int signo)
{
    int  status;
 
    switch(signo)
    {
    case SIGUSR1:
        printf("收到了SIGUSR1信号，进程id=%d!\n",getpid());    
        break;
    
    case SIGCHLD:        
        printf("收到了SIGCHLD信号，进程id=%d!\n",getpid());    
        //这里大家学了一个新函数waitpid，有人也用wait,掌握和使用waitpid即可；
        //这个waitpid说白了获取子进程的终止状态，这样，子进程就不会成为僵尸进程了；
        pid_t pid = waitpid(-1, &status, WNOHANG); 
							//第一个参数为-1，表示等待任何子进程，
							//第二个参数：保存子进程的状态信息(大家如果想详细了解，可以百度一下)。
							//第三个参数：提供额外选项，WNOHANG表示不要阻塞，让这个waitpid()立即返回
        if(pid == 0)        //子进程没结束，会立即返回这个数字，但这里应该不是这个数字                        
            return;
        if(pid == -1)       //这表示这个waitpid调用有错误，有错误也理解返回出去，我们管不了这么多
            return;
        //走到这里，表示  成功，那也return吧
        return;   
        break;    
    } //end switch
}
 
int main(int argc, char *const *argv)
{
    pid_t  pid;
 
    printf("进程开始执行!\n");
 
    //先简单处理一个信号
    if(signal(SIGUSR1,sig_usr) == SIG_ERR)  //系统函数，参数1：是个信号，参数2：是个函数指针，代表一个针对该信号的捕捉处理函数
    {
        printf("无法捕捉SIGUSR1信号!\n");
        exit(1);
    }
 
    if(signal(SIGCHLD,sig_usr) == SIG_ERR) 
    {
        printf("无法捕捉SIGCHLD信号!\n");
        exit(1);
    }
 
    //---------------------------------
    pid = fork();  //创建一个子进程
 
    //要判断子进程是否创建成功
    if(pid < 0)
    {
        printf("子进程创建失败，很遗憾!\n");
        exit(1);
    }
 
    //现在，父进程和子进程同时开始 运行了 
    for(;;)
    {        
        sleep(1); //休息1秒
        printf("休息1秒，进程id=%d!\n",getpid());
    }
    printf("再见了!\n");
    return 0;
}

• kill子进程

• 父进程收到信号

fork()函数进一步认识

• fork()产生新进程的速度非常快，fork()产生的新进程并不复制原进程的内存空间，而是和原进程（父进程)一起共享一个内存空间，但这个内存空间的特性是“写时复制”
  • 原来的进程和fork()出来的子进程可以同时、自由的读取内存，但如果子进程（父进程）对内存进行修改的话，那么这个内存就会复制一份给该进程单独使用，以免影响到共享这个内存空间的其他进程使用。

#include <stdio.h>
#include <stdlib.h>  //malloc,exit
#include <unistd.h>  //fork
#include <signal.h>
 
int main(int argc, char *const *argv)
{   
    fork();  //一般fork都会成功所以不判断返回值了,我们假定成功
    fork();
   
    for(;;)
    {        
        sleep(1); //休息1秒
        printf("休息1秒，进程id=%d!\n",getpid());
    }
    printf("再见了!\n");
    return 0;
}

• 连续两个fork()形成4个进程

完善一下fork()代码

• fork()返回两次：父进程中返回一次，子进程中返回一次，而且，fork()在父进程中返回的值和在子进程中返回的值是不同的。
  • 子进程的fork()返回值是0。
  • 父进程的fork()返回值是新建立的子进程的ID。

#include <stdio.h>
#include <stdlib.h>  //malloc,exit
#include <unistd.h>  //fork
#include <signal.h>
 
int g_mygbltest = 0;
int main(int argc, char *const *argv)
{
    pid_t  pid;
    printf("进程开始执行!\n");   
    //---------------------------------
    pid = fork();  //创建一个子进程
 
    //要判断子进程是否创建成功
    if(pid < 0)
    {
        printf("子进程创建失败，很遗憾!\n");
        exit(1);
    }
 
    //走到这里，fork()成功，执行后续代码的可能是父进程，也可能是子进程
    if(pid == 0)
    {
        //子进程，因为子进程的fork()返回值会是0；
        //这里专门针对子进程的处理代码
        while(1)
        {
            g_mygbltest++;  //写时复制，开辟新的内存空间
            sleep(1); //休息1秒
            printf("真是太高兴了，我是子进程的，我的进程id=%d,g_mygbltest=%d!\n",getpid(),g_mygbltest);
        }
    }
    else
    {
        //这里就是父进程，因为父进程的fork()返回值会 > 0（实际返回的是子进id程）
        //这是专门针对父进程的处理代码
        while(1)
        {
            g_mygbltest++;
            sleep(5); //休息5秒
            printf("........，我是父进程的，我的进程id=%d,g_mygbltest=%d!\n",getpid(),g_mygbltest);
        }
    }
 
    return 0;
}

• 因为全局量g_mygbltest的值发生改变，导致主，子进程内存被单独的分开（写时复制），所以每个的g_mygbltest值也不同。

【一个和fork()执行有关的逻辑判断（短路求值）】

• ||或：有1出1，全0出0
• &&与：全1出1，有0出0

((fork() && fork()) || (fork() && fork()));

fork()失败的可能性

• 系统中进程太多
  • 缺省情况，最大的pid：32767
• b)每个用户有个允许开启的进程总数

printf("每个实际用户ID的最大进程数=%ld\n",sysconf(_SC_CHILD_MAX));  

• 输出：7788