Linux进程控制：从基础概念到实践应用-代码聚汇网

Linux进程控制：从基础概念到实践应用

孙煜征

1. Linux进程控制基础概念

在Linux系统中，进程是程序执行的基本单位，也是资源分配的最小实体。理解进程控制是掌握Linux系统编程的关键基础。我们先来看一个简单的例子：

c复制#include <stdio.h>
#include <unistd.h>

int main() {
    printf("当前进程PID: %d\n", getpid());
    return 0;
}

这个程序会输出当前进程的PID（进程标识符）。在Linux中，每个进程都有唯一的PID，范围从1到32768（可通过/proc/sys/kernel/pid_max查看最大值）。

1.1 进程的基本状态

Linux进程主要有以下几种状态：

运行态(R)：进程正在执行或准备执行（就绪状态）
可中断睡眠(S)：进程在等待某个事件完成，可以被信号唤醒
不可中断睡眠(D)：进程在等待I/O操作完成，不会被信号唤醒
停止态(T)：进程被信号暂停执行
僵尸态(Z)：进程已终止但父进程尚未回收

可以通过ps aux命令查看进程状态，第二列就是进程状态标识。

1.2 进程控制块(PCB)

Linux内核通过进程控制块（PCB）来管理进程，PCB实际上就是task_struct结构体，包含以下重要信息：

进程标识符（PID、PPID）
进程状态
程序计数器（下一条指令地址）
CPU寄存器值
内存管理信息
文件描述符表
信号处理信息
进程优先级

提示：可以通过/proc/[pid]/目录查看进程的详细信息，例如/proc/self/表示当前进程。

2. 进程创建：fork()系统调用

2.1 fork()的基本用法

fork()是Linux中创建新进程的主要方式：

c复制#include <unistd.h>

pid_t fork(void);

fork()调用一次但返回两次：

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

典型用法：

c复制#include <stdio.h>
#include <unistd.h>

int main() {
    pid_t pid = fork();
    
    if (pid < 0) {
        perror("fork失败");
        return 1;
    } else if (pid == 0) {
        printf("这是子进程，PID=%d\n", getpid());
    } else {
        printf("这是父进程，子进程PID=%d\n", pid);
    }
    
    return 0;
}

2.2 写时复制(Copy-On-Write)

Linux采用写时复制技术优化fork()性能：

fork()时并不立即复制整个地址空间
父子进程共享同一物理内存
当任一进程尝试写入时，内核才复制被修改的页面

这种机制大大减少了进程创建的开销，特别是对于大型程序。

2.3 fork()的常见问题

问题1：文件描述符的继承

子进程会继承父进程的所有打开文件描述符，包括：

普通文件
套接字
管道

这可能导致意外的文件共享，需要注意正确处理。

问题2：缓冲区重复输出

c复制#include <stdio.h>
#include <unistd.h>

int main() {
    printf("Hello");  // 注意没有换行
    fork();
    return 0;
}

这个程序会输出两个"Hello"，因为fork()时缓冲区内容也被复制了。解决方法：

在fork()前调用fflush(stdout)
使用setbuf(stdout, NULL)禁用缓冲
确保printf包含换行符

3. 进程终止

3.1 进程终止的几种方式

从main()函数返回
调用exit()函数
调用_exit()或_Exit()函数
收到终止信号（如SIGKILL）

3.2 exit()与_exit()的区别

函数	刷新缓冲区	调用atexit函数	关闭文件描述符
exit()	是	是	是
_exit()	否	否	是

示例：

c复制#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
    printf("使用exit:\n");
    printf("这行会被输出");
    exit(0);
    
    // 下面的代码不会执行
    printf("这行不会输出");
    return 0;
}

对比：

c复制#include <stdio.h>
#include <unistd.h>

int main() {
    printf("使用_exit:\n");
    printf("这行不会被输出");
    _exit(0);
    
    return 0;
}

3.3 进程退出状态

进程退出时会返回一个状态码，父进程可以通过wait()系列函数获取：

0表示成功
1-255表示错误（具体含义由程序定义）
其他值可能表示被信号终止

在shell中可以通过$?获取上一个命令的退出状态：

bash复制$ ./myprogram
$ echo $?

4. 进程等待

4.1 为什么需要等待子进程

避免僵尸进程：已终止但未被回收的进程会占用系统资源
获取子进程执行结果
同步父子进程的执行顺序

4.2 wait()函数

c复制#include <sys/wait.h>

pid_t wait(int *status);

阻塞调用，直到任一子进程终止
返回终止子进程的PID
status参数用于获取子进程退出状态

示例：

c复制#include <sys/wait.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int main() {
    pid_t pid = fork();
    
    if (pid == 0) {
        // 子进程
        printf("子进程开始\n");
        sleep(2);
        printf("子进程结束\n");
        exit(123);
    } else {
        // 父进程
        printf("父进程等待子进程...\n");
        int status;
        pid_t child_pid = wait(&status);
        
        if (WIFEXITED(status)) {
            printf("子进程%d正常退出，状态码：%d\n", 
                   child_pid, WEXITSTATUS(status));
        }
    }
    
    return 0;
}

4.3 waitpid()函数

waitpid()提供了更多控制选项：

c复制pid_t waitpid(pid_t pid, int *status, int options);

参数说明：

pid：指定要等待的子进程
- 0：等待特定PID的子进程
- -1：等待任一子进程（同wait）
- 0：等待同进程组的任一子进程
- <-1：等待进程组ID等于pid绝对值的任一子进程
options：
- WNOHANG：非阻塞模式
- WUNTRACED：也返回停止的子进程状态
- WCONTINUED：也返回继续执行的子进程状态

非阻塞等待示例：

c复制#include <sys/wait.h>
#include <stdio.h>
#include <unistd.h>

int main() {
    pid_t pid = fork();
    
    if (pid == 0) {
        // 子进程
        sleep(5);
        exit(0);
    } else {
        // 父进程
        int status;
        while (1) {
            pid_t ret = waitpid(pid, &status, WNOHANG);
            if (ret == 0) {
                printf("子进程还未结束，父进程可以做其他事情...\n");
                sleep(1);
            } else if (ret == pid) {
                printf("子进程已结束\n");
                break;
            } else {
                perror("waitpid错误");
                break;
            }
        }
    }
    
    return 0;
}

4.4 处理子进程状态的宏

Linux提供了一组宏来处理wait()获取的状态信息：

宏	描述
WIFEXITED(status)	子进程正常退出为真
WEXITSTATUS(status)	获取子进程退出码
WIFSIGNALED(status)	子进程被信号终止为真
WTERMSIG(status)	获取终止子进程的信号编号
WIFSTOPPED(status)	子进程当前停止为真
WSTOPSIG(status)	获取停止子进程的信号编号
WIFCONTINUED(status)	子进程已继续执行为真

示例：

c复制if (WIFEXITED(status)) {
    printf("正常退出，退出码：%d\n", WEXITSTATUS(status));
} else if (WIFSIGNALED(status)) {
    printf("被信号终止，信号：%d\n", WTERMSIG(status));
}

5. 高级话题与常见问题

5.1 僵尸进程处理

僵尸进程是已经终止但父进程尚未调用wait()回收的进程。它们会占用系统资源，应该避免。

处理方法：

父进程调用wait()或waitpid()
如果父进程不关心子进程状态，可以设置SIGCHLD信号处理为SIG_IGN
如果父进程先终止，子进程会被init进程(PID=1)接管并回收

5.2 孤儿进程

当父进程先于子进程终止时，子进程成为孤儿进程，会被init进程收养。孤儿进程不会成为僵尸进程，因为init会自动回收它们。

5.3 进程组和会话

进程组：一组相关进程的集合，有相同的PGID
会话：一个或多个进程组的集合，与终端关联

5.4 守护进程的创建

守护进程是在后台运行的进程，通常遵循以下步骤：

调用fork()创建子进程，父进程退出
子进程调用setsid()创建新会话
改变工作目录到根目录
重设文件权限掩码
关闭不需要的文件描述符
重定向标准I/O到/dev/null或日志文件

示例：

c复制#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

int main() {
    pid_t pid = fork();
    
    if (pid < 0) {
        perror("fork失败");
        exit(1);
    } else if (pid > 0) {
        // 父进程退出
        exit(0);
    }
    
    // 子进程继续
    setsid();  // 创建新会话
    
    chdir("/");  // 改变工作目录
    
    umask(0);  // 重设文件权限掩码
    
    // 关闭标准文件描述符
    close(STDIN_FILENO);
    close(STDOUT_FILENO);
    close(STDERR_FILENO);
    
    // 守护进程的主要工作
    while (1) {
        // 在这里执行守护进程的任务
        sleep(10);
    }
    
    return 0;
}

6. 实际应用案例

6.1 简单的shell实现

下面是一个极简的shell实现，演示进程控制的实际应用：

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

#define MAX_LINE 1024

int main() {
    char line[MAX_LINE];
    
    while (1) {
        printf("myshell> ");
        if (!fgets(line, MAX_LINE, stdin)) {
            break;  // 读取失败或EOF
        }
        
        // 去掉换行符
        line[strcspn(line, "\n")] = 0;
        
        if (strcmp(line, "exit") == 0) {
            break;
        }
        
        pid_t pid = fork();
        
        if (pid < 0) {
            perror("fork失败");
            continue;
        } else if (pid == 0) {
            // 子进程执行命令
            execlp(line, line, (char *)NULL);
            perror("exec失败");
            exit(1);
        } else {
            // 父进程等待子进程
            int status;
            waitpid(pid, &status, 0);
            
            if (WIFEXITED(status)) {
                printf("命令退出状态：%d\n", WEXITSTATUS(status));
            }
        }
    }
    
    return 0;
}

6.2 多进程任务处理

利用多进程并行处理任务的示例：

c复制#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

#define NUM_WORKERS 4

void worker(int id) {
    printf("Worker %d (PID=%d) 开始工作\n", id, getpid());
    sleep(id * 2);  // 模拟工作
    printf("Worker %d 完成工作\n", id);
    exit(0);
}

int main() {
    int i;
    pid_t pids[NUM_WORKERS];
    
    // 创建多个工作进程
    for (i = 0; i < NUM_WORKERS; i++) {
        pids[i] = fork();
        
        if (pids[i] == 0) {
            worker(i + 1);
        } else if (pids[i] < 0) {
            perror("fork失败");
            exit(1);
        }
    }
    
    // 等待所有子进程完成
    int status;
    pid_t pid;
    int n = NUM_WORKERS;
    
    while (n > 0) {
        pid = wait(&status);
        printf("子进程 %d 已完成\n", pid);
        n--;
    }
    
    printf("所有工作进程已完成\n");
    return 0;
}

7. 性能考虑与最佳实践

7.1 fork()的性能开销

虽然写时复制减少了内存复制开销，但fork()仍然有以下开销：

复制页表
创建新的PCB
维护进程关系
设置新的文件描述符表

对于需要频繁创建进程的场景，考虑：

使用线程（pthread）
使用进程池技术
考虑更轻量的vfork()（但有使用限制）

7.2 避免进程创建瓶颈

预创建进程（进程池）
重用进程而不是频繁创建/销毁
最小化fork()后的地址空间修改（减少写时复制触发）

7.3 信号处理注意事项

fork()后子进程继承父进程的信号处理设置
注意信号处理函数中不要调用非异步信号安全函数
在多进程程序中谨慎使用信号

7.4 资源清理

确保进程退出时：

关闭所有打开的文件描述符
释放动态分配的内存
删除临时文件
释放锁和其他系统资源

8. 调试与问题排查

8.1 常用调试工具

strace：跟踪系统调用

bash复制strace -f ./myprogram  # 跟踪所有进程

gdb：调试多进程程序

bash复制gdb --args ./myprogram
(gdb) set follow-fork-mode child  # 跟踪子进程

ps：查看进程状态

bash复制ps aux | grep myprogram
ps -ef --forest  # 显示进程树

8.2 常见问题与解决方案

问题1：僵尸进程堆积

现象：ps输出中有大量<defunct>进程

解决方案：

父进程正确处理SIGCHLD信号
设置SIGCHLD处理为SIG_IGN（Linux特有）
确保父进程调用wait()系列函数

问题2：文件描述符泄漏

现象：程序运行一段时间后无法打开新文件