【Linux操作系统】进程的创建与替换

前言：

学习了Linux操作系统我们可以知道，进程是系统分配资源的基本单位，也是CPU调度的一个实体，它是程序执行的一个实例，Linux中提供了多种机制来创建进程，一般常用的是通过fork0()、clone()等系统调用，以及更高级的封装exec()系列函数()。

一、进程创建

1.fork();

1.1 fork基本介绍

在linux中fork函数时非常重要的函数，也是是最常用的创建新进程的系统调用

#include <unistd.h>
pid_t fork(void);
返回值：自进程中返回0，父进程返回子进程id，出错返回-1

当一个进程调用fork()时，系统会创建一个与当前进程几乎完全相同的子进程。这个子进程被称为当前进程的子进程，而当前进程是子进程的父进程。

fork()调用完成后，在父进程中返回新创建的子进程的PID（进程ID），而在子进程中返回0。

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

int main() {
    pid_t pid = fork();
    if (pid == -1)
    {
        // 创建失败  
        perror("fork failed");
        return 1;
    }
    else if (pid > 0)
    {
        // 父进程  
        printf("I am the parent. My PID is %d. Child's PID is %d.\n", getpid(), pid);
    }
    else {
        // 子进程  
        printf("I am the child. My PID is %d.\n", getpid());
    }
    return 0;
}

1.2 fork的原理

当我们的进程调用fork后，当控制转移到内核中的fork代码后，内核会做一下处理：

• 分配新的内存块和内核数据结构给子进程
• 将父进程部分数据结构内容拷贝至子进程，即子进程是一父进程为模板的
• 添加子进程到系统进程列表当中
• fork返回，开始调度器调度

当一个进程fork之后，我们的系统就有两个二进制代码相同的进程。而且此刻它们都运行到相同的地方。但每个进程都是独立的

fork之前，父进程独立执行，fork之后，父子两个执行流分别执行。

不过fork之后，父子进程谁先执行就完全右调度器执行了

1.3 写时拷贝

传统我们在创建父子进程时，父进程的所有资源（数据、堆栈等）都会完整的复制到子进程中，但如果父进程的数据量资源过于庞大时，这种方法效率十分底下，因此为了解决这种问题，Linux采用了写时拷贝的技术。

在写实拷贝的存在下，现在我们的父子进程通常是共享一块物理内存的，也就是说父子进程代码资源在内存中是共享的，这样就减少的拷贝的消耗

但当父子进程的任意一方试图写入修改内容时，那一方便会再用写时拷贝的方式各自产生一份代码副本

具体来说，当fork被调用时，内核并不会立即复制父进程的整个地址空间到子进程，而是让父子进程共享相同的物理页面。这些页面被标记为只读。当父子进程中的任何一个试图修改这些共享页面时，内核会拦截写操作，并为该页面分配一个新的物理页面，将旧页面的内容复制到新页面中，然后修改该进程的页表，使其指向新的页面。这样，每个进程就有了自己独立的内存副本，可以安全地进行修改而不会影响到对方。

如下图所示：

写时拷贝的优势：

• 节省内存：在不需要写入时，父子进程共享同一块物理内存，从而节省了内存资源
• 提高效率：只有在真正需要写入时才会进行复制，减少了不必要的内存复制操作，提高了系统效率
• 简化编程：对于程序员来说，写时拷贝是透明的，他们不需要关心内存复制的细节，可以像使用普通进程一样使用fork创建的子进程。

1.4 fork的使用场景

• 一个父进程希望复制自己，使父子进程同时执行不同的代码段。
  例如，父进程等待客户端请求，生成子进程来处理请求。

• 一个进程要执行一个不同的程序。例如子进程从fork返回后，调用exec函数

1.5 fork调用失败的原因

• 系统中有太多的进程
• 实际用户的进程数超过了限制

2.clone()

clone()系统调用提供了比fork()更灵活的进程创建方式。

它允许调用者指定哪些资源（如内存空间、文件系统资源等）应该被子进程共享。

clone()是Linux特有的，并且提供了线程（轻量级进程）的创建能力

#include <sched.h>  
#include <stdio.h>  
#include <sys/types.h>  
#include <unistd.h>  
  
int child_func(void *arg) {  
    printf("Hello from child\n");  
    return 0;  
}  
  
int main() {  
    int pid = clone(child_func, (char *) 0, CLONE_VM | CLONE_FS | CLONE_FILES, NULL);  
    if (pid == -1) {  
        perror("clone failed");  
        return 1;  
    }  
  
    printf("Hello from parent\n");  
    wait(NULL); // 等待子进程结束  
    return 0;  
}

二、进程替换(exec)

1.替换原理

我们用fork创建的子进程执行的都是和父进程相同的代码（不过执行的分支可能不同），若是我们想要让创建的子进程执行另一个程序呢？

这时子进程就要调用一种exec函数来执行另一个程序，使得该进程的用户空间和数据完全被新程序替换，程序替换一旦成功，原代码后续代码不在执行，所以execl只有失败返回值，没有成功返回值，因为已经替换成新的程序了

对于进程来说，创建一个进程，是先创建PCB，地址空间，页表等，再把程序加载到内存中
程序替换的本质工作是加载，将磁盘中的代码拷贝一份到内存中去，原来有程序叫替换，没有叫加载

替换完成的新程序会从启动例程开始执行，调用exec并不创建新进程，所以调用exec前后该进程的id并未改变

例如我们的xshell的运行逻辑,shel创建子进程，shell 去wait pid等待子进程，子进程会继承shell的代码，子进程直接进行程序替换，替换你所输入的指令，执行完成

2.替换函数

有六种以exec开头的函数，统称exec函数

#include<unistd>

int execl(const char* path, const char* arg, ...);
int execlp(const char* file, const char* arg, ...);
int execle(const char* path, const char* arg, ..., char* const envp[]);
int execv(const char* path, char* const argv[]);
int execvp(const char* file, char* const argv[]);

3.函数解释

• 这些函数如果调用成功则加载新的程序从启动代码开始执行，不再返回
• 如果函数调用出错则返回-1
• 所以exec函数只有出错的返回值，没有成功的返回值

4.函数理解

上述六个函数是不是看起来特别不好记，但其实只要我们掌握了规律就会很好理解

• l(list) : 表示参数采用列表
• v(vector) :参数用数组
• p(path) :有p自动搜索环境变量PATH
• e(env) :表示自己维护环境变量

举例：

#include <unistd.h>
int main()
{
    char* const argv[] = { "ps", "-ef", NULL };
    char* const envp[] = { "PATH=/bin:/usr/bin", "TERM=console", NULL };
    execl("/bin/ps", "ps", "-ef", NULL);
    // 带p的，可以使用环境变量PATH，无需写全路径
    execlp("ps", "ps", "-ef", NULL);
    // 带e的，需要自己组装环境变量
    execle("ps", "ps", "-ef", NULL, envp);
    execv("/bin/ps", argv);

    // 带p的，可以使用环境变量PATH，无需写全路径
    execvp("ps", argv);
    // 带e的，需要自己组装环境变量
    execve("/bin/ps", argv, envp);
    exit(0);
}

不过根本上只有execve是真正的系统调用，其他五个函数最终都调用execve，所以execve在man手册第二节，其他函数在man手册第三节

函数关系如下图；