Linux编程：2、进程基础知识-EW帮帮网

一、进程基本概念

1、进程与程序的区别

程序：静态的可执行文件（如电脑中的vs2022安装程序）。
进程：程序的动态执行过程（如启动后的vs2022实例），是操作系统分配资源的单位（如 CPU 时间、内存）。
特点：同一程序可启动多个进程（如多个 vs2022 窗口），进程关闭后程序仍存在。

2、进程的组成

进程控制块（PCB）：操作系统为每个进程创建的唯一标识，包含进程状态、资源信息等。
程序段（代码）：进程执行的代码逻辑。
数据集（数据）：进程操作的数据。

二、进程控制块（PCB）

1、核心字段

进程号（PID）：32 位无符号整数（Linux 最大为 32767），通过getpid()获取当前进程号。
进程状态：
- R：可执行状态。
- S：可中断睡眠。
- D：不可中断睡眠。
- T：暂停或跟踪状态。
- Z：僵尸进程（已退出但未释放资源）。
- X：即将销毁的进程。
查看命令：ps -eo stat,pid,user,cmd（显示状态、PID、用户、命令）。

2、其他字段

优先级：决定 CPU 调度顺序。
CPU 现场信息：保存进程暂停时的 CPU 状态，以便恢复。
资源清单：内存、I/O 设备等分配情况。
队列指针：链接同一状态的进程（如就绪队列、等待队列）。

三、进程 PID 文件

1、存储位置：

位于/var/run目录，文件名通常为进程名.pid，内容为单行的进程号。
注意：需程序自行创建，系统不会自动生成。

2、作用：

防止程序重复启动（通过文件锁机制实现）。

示例代码：通过fcntl加锁判断进程是否已运行。

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

// PID文件路径，用于存储当前运行实例的进程ID
#define PID_FILE "/var/run/test.pid"

/**
 * 检查程序是否已在运行，确保只有一个实例
 *
 * 返回值：
 *   0 - 程序未运行，当前是第一个实例
 *  -1 - 程序已在运行，当前实例退出
 */
int checkAlone(void)
{
    int  fd;       // 文件描述符
    char buf[16];  // 存储PID的缓冲区

    // 打开或创建PID文件，使用O_CREAT标志确保文件存在
    fd = open(PID_FILE, O_RDWR | O_CREAT, 0666);
    if (fd < 0) {
        perror("open pid failed");  // 打印错误信息
        exit(1);                    // 打开失败时终止程序
    }

    // 定义文件锁结构，准备加写锁
    struct flock fl;
    fl.l_type   = F_WRLCK;   // 写锁类型
    fl.l_start  = 0;         // 从文件开始位置
    fl.l_whence = SEEK_SET;  // 以文件起始为基准
    fl.l_len    = 0;         // 锁定整个文件

    // 尝试加非阻塞写锁
    // 返回值：0-成功，-1-失败（文件已被锁定）
    int ret = fcntl(fd, F_SETLK, &fl);
    if (ret < 0) {
        close(fd);             // 关闭文件描述符
        printf("Had run.\n");  // 提示已有实例在运行
        return -1;             // 返回错误码
    }

    // 将当前进程ID写入PID文件
    sprintf(buf, "%ld", (long)getpid());
    write(fd, buf, strlen(buf) + 1);

    printf("first running.\n");  // 提示首次运行
    return 0;                    // 返回成功
}

int main(void)
{
    // 检查程序是否已在运行
    if (checkAlone() < 0) {
        return -1;  // 已有实例在运行，退出当前进程
    }

    // 主程序逻辑：循环执行任务
    while (1) {
        printf("working...\n");   // 输出工作状态
        sleep(1);                // 休眠1秒
    }

    return 0;
}

3、开启两个终端：

第一次运行程序（第一个终端）：

第二次运行程序（第二个终端）：

四、进程的创建

1、fork () 函数

功能：创建子进程，返回两次（父进程返回子进程 PID，子进程返回 0）。
特点：子进程复制父进程的内存空间（不共享内存），继承打开的文件描述符等资源。

示例1：

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

int main()
{
    int count = 0;  // 用于父子进程各自计数的变量
    printf("准备创建子进程...\n");
    
    // 创建子进程：fork调用会返回两次
    // 父进程返回子进程的PID(正值)
    // 子进程返回0
    // 返回负值表示创建失败
    pid_t pid = fork();
    
    // 错误处理：创建子进程失败
    if (pid < 0) {
        printf("创建子进程失败");
        exit(1);  // 终止程序并返回错误码1
    }
    
    // 子进程执行分支
    else if (pid == 0) {
        // 子进程中fork返回0
        // getpid()返回子进程自身的PID
        printf("我是子进程，pid=%d, 进程号=%d\n", pid, getpid());
        count++;  // 子进程的count加1
    }
    
    // 父进程执行分支
    else {
        // 父进程中fork返回子进程的PID
        // getpid()返回父进程自身的PID
        printf("我是父进程, pid=%d, 进程号=%d\n", pid, getpid());
        count++;  // 父进程的count加1
    }
    
    // 父子进程都会执行此语句
    // 通过判断pid值区分当前是哪个进程
    printf("我是%s, count=%d\n", pid == 0 ? "子进程" : "父进程", count);
    
    return 0;
}

说明1：
由 fork 创建的新进程被称为子进程，原来的进程，称为“父进程”

该函数被调用一次，但返回两次（在父进程中返回 1 次，子进程中返回 1 次）
1）子进程的返回值是 0
2）而父进程的返回值是子进程的 PID

fork 执行完之后，子进程和父进程继续执行 fork 之后的指令。
父进程和子进程几乎是等同的，它们具有相同的变量值(但变量内存并不共享),
打开的文件也都相同，还有其他一些相同属性。
如果父进程改变了变量的值，子进程将不会看到这个变化。
实际上，子进程是父进程的一个复制（拷贝），但它们并不共享内存。
父进程改变了变量的值，子进程中对应的变量不会有任何影响。

示例2：

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

int main()
{
    int count = 0;  // 父子进程各自的计数器
    printf("准备创建子进程...\n");

    pid_t pid;
    // 循环两次创建子进程，每次fork会产生父子两个分支
    for (int i = 0; i < 2; i++) {
        pid = fork();  // 关键系统调用：创建新进程

        if (pid < 0) {
            perror("fork失败");  // 输出系统错误信息
            exit(1);             // 异常退出
        }
        else if (pid == 0) {
            // 子进程分支：pid为0，getpid()返回子进程ID
            printf("[新的子进程]我是子进程，pid=%d, 进程号=%d\n", pid,
                   getpid());
            count++;  // 子进程计数器加1
        }
        else {
            // 父进程分支：pid为子进程ID，getpid()返回父进程ID
            printf("我是父进程, pid=%d, 进程号=%d\n", pid, getpid());
            count++;  // 父进程计数器加1
        }
    }

    // 父子进程最终都会执行此语句
    // 通过最后一次fork的返回值判断当前是父进程还是子进程
    printf("我是%s, count=%d\n", pid == 0 ? "子进程" : "父进程", count);

    return 0;
}

for 循环了 2 次，实际上创建了 3 个子进程，而不是两个。

2、exec 系列函数

功能：用指定程序替换当前进程（成功后原进程代码不再执行）。
接口差异：
- l：参数以列表形式传递（如execl）。
- p：从 PATH 环境变量查找程序（如execlp）。
- v：参数通过指针数组传递（如execv）。
- e：传递自定义环境变量（如execle）。

示例：
无参的：

#include <cstdio>
#include <unistd.h>

int main(int argc, char* argv[])
{
    // 使用execl函数执行外部程序，替换当前进程映像
    // 参数1: 要执行的程序路径
    // 参数2开始: 传递给程序的命令行参数，必须以NULL结尾
    execl("/bin/pwd",         // 指定要执行的程序路径(绝对路径)
          "pwd",              // 命令行参数列表的第一个参数，通常是程序名(可自定义)
          NULL);              // 参数列表结束标记，必须为NULL


    // 如果execl调用成功，当前进程会被完全替换，不会执行到这里
    // 如果执行到这里，说明execl调用失败
    perror("execl failed");  // 打印系统错误信息
    return 1;                // 返回错误退出码
}

带参的：

#include <unistd.h>
int main(int argc, char* argv[])
{
    // 相当于执行： ls -l /tmp
    execl("/bin/ls", "ls", "-l", "/tmp", NULL);
    return 0;
}

3、fork 与 exec 结合

场景：父进程创建子进程后，子进程执行新程序（如 Shell 命令解析）。

示例逻辑：

pid_t pid = fork();
if (pid == 0) { execv("/path/to/program", argv); } // 子进程执行新程序

五、进程的分类

1、前台进程

定义：需与用户交互的进程（如终端运行的程序），默认启动即为前台。
查看命令：ps -e | grep 进程名。

2、后台进程

定义：无需交互，在后台运行（如服务器程序）。
启动方式：命令后加&（如./a.out &）。
终止命令：killall 进程名。

3、守护进程

定义：特殊后台进程，独立于终端（如sshd、httpd），用于长期运行任务。
特点：
- 不依附终端，终端关闭后仍运行。
- 父进程通常为systemd（PID 1）。
创建步骤：
1. fork后退出父进程，子进程成为孤儿进程。
2. setsid创建新会话，脱离原终端。
3. chdir("/")切换工作目录至根目录。
4. umask(0)清除文件权限掩码。
5. 关闭默认文件描述符（0、1、2）。
示例代码：通过信号处理实现日志写入的守护进程。
查看命令：ps axj（显示 PPID、会话信息等）。

Linux编程：2、进程基础知识