怎么用Linux fork创建子进程

发布时间：2022-01-26 16:28:03 作者：iii
来源：亿速云阅读：201

# 怎么用Linux fork创建子进程

## 1. 进程基础概念

### 1.1 什么是进程
进程是操作系统中最基本的概念之一，它是程序的一次执行过程，是系统进行资源分配和调度的基本单位。每个进程都有自己独立的地址空间，包括代码段、数据段和堆栈段。

在Linux系统中，进程具有以下关键特征：
- 独立性：每个进程拥有独立的虚拟地址空间
- 动态性：进程是程序的执行过程，有生命周期
- 并发性：多个进程可以并发执行
- 结构性：进程由PCB（进程控制块）描述

### 1.2 进程标识
每个Linux进程都有唯一的标识：
- PID（Process ID）：进程ID，唯一正整数
- PPID（Parent Process ID）：父进程ID
- UID/GID：用户和组标识

可以通过`ps`命令查看系统中的进程信息：
```bash
ps -ef

2. fork系统调用详解

2.1 fork的基本原理

fork()是Linux中创建新进程的系统调用，它通过复制当前进程来创建一个新进程。调用fork的进程称为父进程，新创建的进程称为子进程。

fork的特点： - 调用一次，返回两次 - 子进程是父进程的副本 - 子进程从fork返回处开始执行

2.2 fork函数原型

#include <unistd.h>

pid_t fork(void);

返回值： - 父进程中返回子进程的PID - 子进程中返回0 - 出错时返回-1

2.3 fork的执行流程

父进程调用fork()
内核为新进程分配资源（PCB、地址空间等）
复制父进程的地址空间内容到子进程
向父进程返回子进程PID
向子进程返回0

3. 使用fork创建子进程

3.1 基本示例代码

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

int main() {
    pid_t pid = fork();
    
    if (pid < 0) {
        // fork失败
        perror("fork failed");
        return 1;
    } else if (pid == 0) {
        // 子进程代码
        printf("Child process: PID=%d, PPID=%d\n", getpid(), getppid());
    } else {
        // 父进程代码
        printf("Parent process: PID=%d, Child PID=%d\n", getpid(), pid);
    }
    
    return 0;
}

3.2 代码执行分析

当运行上述程序时，输出可能如下：

Parent process: PID=1234, Child PID=1235
Child process: PID=1235, PPID=1234

注意：父进程和子进程的执行顺序是不确定的，取决于系统的调度策略。

3.3 父子进程的区别

虽然子进程是父进程的副本，但两者有以下区别： 1. 不同的PID和PPID 2. fork的返回值不同 3. 子进程不继承父进程的： - 进程锁 - 未处理的信号 - 定时器 4. 资源利用统计清零

4. fork的高级用法

4.1 多级进程创建

可以通过多次调用fork创建多级进程树：

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

int main() {
    printf("Level 1 (PID=%d)\n", getpid());
    
    if (fork() == 0) {
        // 子进程1
        printf("Level 2 (PID=%d, PPID=%d)\n", getpid(), getppid());
        
        if (fork() == 0) {
            // 子进程2
            printf("Level 3 (PID=%d, PPID=%d)\n", getpid(), getppid());
        }
    }
    
    return 0;
}

4.2 进程链与进程扇

进程链：每个进程只创建一个子进程

if (fork() == 0) {
    if (fork() == 0) {
        // 三级进程链
    }
}

进程扇：一个进程创建多个子进程

for (int i = 0; i < 3; i++) {
    if (fork() == 0) {
        // 子进程
        break;
    }
}

4.3 结合exec函数族

通常fork后会调用exec系列函数执行新程序：

pid_t pid = fork();
if (pid == 0) {
    execl("/bin/ls", "ls", "-l", NULL);
    perror("execl failed");
    exit(1);
}

5. fork的注意事项

5.1 资源复制问题

fork采用写时复制（Copy-On-Write）技术优化性能： - 初始时父子进程共享物理内存 - 只有当一个进程尝试修改内存时，才会复制该内存页

5.2 文件描述符继承

子进程会继承父进程的所有打开文件描述符，包括： - 相同的文件偏移量 - 相同的文件状态标志 - 相同的文件描述符标志

5.3 僵尸进程与孤儿进程

僵尸进程：子进程退出但父进程未调用wait
孤儿进程：父进程先于子进程退出

解决方法：

// 父进程中等待子进程退出
if (pid > 0) {
    wait(NULL);
}

6. 实际应用案例

6.1 简单shell实现

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>

#define MAX_LINE 80

int main() {
    char line[MAX_LINE];
    
    while (1) {
        printf("mysh> ");
        fflush(stdout);
        
        if (!fgets(line, MAX_LINE, stdin)) {
            break;
        }
        
        line[strlen(line)-1] = '\0'; // 去掉换行符
        
        pid_t pid = fork();
        if (pid < 0) {
            perror("fork failed");
            continue;
        } else if (pid == 0) {
            // 子进程执行命令
            execlp(line, line, NULL);
            perror("exec failed");
            exit(1);
        } else {
            // 父进程等待子进程
            wait(NULL);
        }
    }
    
    return 0;
}

6.2 并发服务器模型

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>

void handle_client(int client_fd) {
    // 处理客户端请求
    char buffer[1024];
    read(client_fd, buffer, sizeof(buffer));
    // 处理逻辑...
    close(client_fd);
    exit(0);
}

int main() {
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    // 绑定、监听等操作...
    
    while (1) {
        int client_fd = accept(server_fd, NULL, NULL);
        if (fork() == 0) {
            close(server_fd);  // 子进程关闭监听套接字
            handle_client(client_fd);
        }
        close(client_fd);  // 父进程关闭客户端套接字
    }
    
    return 0;
}

7. 性能考虑与替代方案

7.1 fork的性能开销

虽然COW技术减少了内存复制开销，但fork仍然有以下开销： 1. 页表复制 2. 文件描述符表复制 3. 信号处理程序继承 4. 命名空间复制

7.2 vfork与clone

vfork：创建子进程但不复制地址空间

pid_t pid = vfork();
if (pid == 0) {
    execl("/bin/ls", "ls", NULL);
    _exit(1);  // 必须使用_exit而不是exit
}

clone：更灵活的进程创建方式，可以控制共享哪些资源

7.3 线程替代方案

对于需要共享内存的并发任务，可以考虑使用pthread线程：

#include <pthread.h>

void *thread_func(void *arg) {
    // 线程函数
    return NULL;
}

pthread_t tid;
pthread_create(&tid, NULL, thread_func, NULL);

8. 常见问题解答

Q1: fork后父子进程谁先执行？

A: 顺序不确定，取决于系统调度。可以使用信号或进程间通信来同步。

Q2: 如何避免僵尸进程？

A: 有以下几种方法： 1. 父进程调用wait/waitpid 2. 忽略SIGCHLD信号：signal(SIGCHLD, SIG_IGN); 3. 使用两次fork技巧

Q3: fork失败的原因有哪些？

A: 常见原因包括： 1. 系统进程数达到上限 2. 用户进程数达到限制 3. 内存不足 4. 资源限制（RLIMIT_NPROC）

9. 总结

fork是Linux系统中创建进程的基本方法，理解其工作原理对于系统编程至关重要。关键点总结： 1. fork创建当前进程的副本 2. 父子进程在fork后独立运行 3. 合理管理进程生命周期避免资源泄漏 4. 结合exec实现灵活的程序执行 5. 考虑性能时可使用vfork或线程替代

通过掌握fork的使用，可以构建复杂的多进程应用，如服务器、shell等系统程序。 “`