创建子进程

写在前面

本文主要介绍一些Linux系统编程中进程控制的一些函数

fork

作用:用于从一个已存在的进程中创建一个新进程,新进程称为子进程,原进程称为父进程。
函数原型:pid_t fork(void);

需要的头文件:

  • #include <unistd.h>
  • #include <sys/types.h>

返回值:

  • 成功:
    • 在子进程中返回 0
    • 在父进程中返回创建的子进程的pid
  • 失败:返回-1,并设置errno
    • 当前的进程数已经达到了系统规定的上限,这时 errno 的值被设置为 EAGAIN
    • 系统内存不足,这时 errno 的值被设置为 ENOMEM

案例

#include<stdio.h>
#include <unistd.h>
#include <error.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <sys/types.h>
#include <stdlib.h>

int main(int argc, char *argv[]){
    pid_t pid;
    pid = fork();
    if(pid < 0){ 
        perror("fork error");
        exit(1);
    } else if(pid == 0){ 
        printf("I am child my pid is %d\n", getpid()); //getpid函数用于获取当前进程的pid
    } else {
        printf("I am parent my pid is %d\n", getpid());
    }   
    return 0;
}

程序运行结果如下
image.png

从运行结果,我们可以看出,fork() 之后的打印函数打印了两次,而且打印了两个进程号,这说明,fork() 之后确实创建了一个新的进程,新进程为子进程,原来的进程为父进程。

那子进程长什么样的呢?

使用 fork() 函数得到的子进程是父进程的一个复制品,它从父进程处继承了整个进程的地址空间:包括进程上下文(进程执行活动全过程的静态描述)、进程堆栈、打开的文件描述符、信号控制设定、进程优先级、进程组号等。子进程所独有的只有它的进程号,计时器等(只有小量信息)。因此,使用 fork() 函数的代价是很大的。

简单来说, 一个进程调用 fork() 函数后,系统先给新的进程分配资源,例如存储数据和代码的空间。然后把原来的进程的所有值都复制到新的新进程中,只有少数值与原来的进程的值不同。相当于克隆了一个自己。
实际上,更准确来说,Linuxfork() 使用是通过写时拷贝 (copy- on-write) 实现。写时拷贝是一种可以推迟甚至避免拷贝数据的技术。内核此时并不复制整个进程的地址空间,而是让父子进程共享同一个地址空间。只用在需要写入的时候才会复制地址空间,从而使各个进行拥有各自的地址空间。也就是说,资源的复制是在需要写入的时候才会进行,在此之前,只有以只读方式共享,读时共享,写时复制

  • 父子进程相同:刚fork后父子 data段、text段、堆、栈、环境变量、全局变量、宿主目录位置、进程工作目录位置、信号处理方式
  • 父子进程不同:
    进程id、返回值、各自的父进程、进程创建时间、闹钟、未决信号集
  • 父子进程共享:读时共享、写时复制。———————— 全局变量。
    • 文件描述符
    • mmap映射区

获得进程号

函数:

  • pid_t getpid(void);
    • 作用: 获取本进程号(PID)
  • pid_t getppid(void);
    • 作用:获取调用此函数的进程的父进程号(PPID)
  • pid_t getpgid(pid_t pid);
    • 作用:获取进程组号(PGID)
    • 参数:参数为 0 时返回当前进程组号,否则返回参数指定的进程的进程组号

头文件:

  • #include <sys/types.h>
  • #include <unistd.h>

案例

循环创建子进程。在前面提到过,创建子进程的过程是一个树型的过程,如果单单使用循环去创建的话,过程大概如下
image.png
从上图可以看出,当n=2时,创建了 $2^n - 1$个子进程,而不是 $n$ 个子进程,所以循环创建子进程的代码如下

#include<stdio.h>
#include <unistd.h>
#include <error.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <sys/types.h>
#include <stdlib.h>

int main(int argc, char *argv[]){
    pid_t pid;
    int i = 0;
    for(i = 0;i < 5;i++){
        pid = fork();
        if(pid == 0)
            break;
    }   
    
    if(pid < 0){ 
        perror("fork error");
        exit(1);
    } else if(pid == 0){ 
        printf("I am %dth child my pid is %d\n",i+1, getpid());
    } else {
        printf("I am parent\n");
    }   
    return 0;
}

image.png

执行结果如下,因为在CPU看来所有进程都是同时产生的,所以进程的调度是随机的,谁先抢到CPU的资源谁就先打印自己的pid

vfork

作用:vfork() 函数和 fork() 函数一样都是在已有的进程中创建一个新的进程,但它们创建的子进程是有区别的

返回值:

  • 成功:子进程中返回 0,父进程中返回子进程 ID。pid_t,为无符号整型。
  • 失败:返回 -1,设置errno

fork() 与 vfock() 都是创建一个进程,那它们有什么区别呢?

  1. 父子执行程序的顺序,通过fork()出来的子进程与父进程执行的顺序由CPU随机决定,而通过vfork出来的保证子进程先运行,在它调用exec族函数与exit之后父进程才可能被调度运行。
  2. fork(): 子进程拷贝父进程的地址空间,子进程是父进程的一个复制品。
    vfork():子进程共享父进程的地址空间(准确来说,在调用 exec(进程替换) 或 exit(退出进程) 之前与父进程数据是共享的)

案例

#include<stdio.h>
#include <unistd.h>
#include <error.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <sys/types.h>
#include <stdlib.h>

int a = 20; 
int main(int argc, char *argv[]){
    pid_t pid;
    int b = 50;  //在父进程中创建两个变量
    pid = vfork();
    
    if(pid < 0){ 
        perror("fork error");
        exit(1);
    } else if(pid == 0){ 
        sleep(3);//让子进程睡三秒
        a = 200;
        b = 500;
        printf("I am child a = %d b = %d\n",a, b); 
        exit(1);
    } else {
        printf("I am parent a = %d b = %d\n", a, b); 
    }   
    return 0;
}

image.png
从程序的执行结果来看,子进程在没调用exit以前,即使睡眠父进程仍然要等子进程结束才能运行,且当变量在子进程内更改,父进程内变量的地址也被更改。
vfork() 保证子进程先运行,在它调用 exec(进程替换) 或 exit(退出进程)之后父进程才可能被调度运行。如果子进程没有调用 exec, exit, 程序则会导致死锁,程序是有问题的程序,没有意义,所以用 vfork() 创建进程,子进程里一定要调用 exec(进程替换) 或 exit(退出进程)

父子进程的调试

父子进程的GDB调试

设置父进程调试路径:set follow-fork-mode parent (默认)
设置子进程调试路径:set follow-fork-mode child