基本概念

程序和进程的区别

程序是平台相关的二进制文件，只占用磁盘空间。编写完程序代码后，编译为可执行的二进制文件即可。

进程是运行中的程序，占用 CPU、内存等系统资源。

通过 Shell 命令，可以在终端启动进程，例如执行 ls 命令：

找到命令对应的二进制文件
使用 fork() 函数创建新的进程
在新创建的进程中调用 exec 函数组，加载命令对应的二进制文件，并从 main 函数开始执行

并发和并行

并发 concurrent：在一个时间段内，处理的请求总数。个数越多，并发越大。

并行 parallel：任意时刻能够同时处理的请求数。通常跟 CPU 内核数量相关。

Linux 进程的状态

Linux 的进程有以下 6 种状态：

D：深度睡眠状态，不可中断，处于这种状态的进程不能响应异步信号
R：进程处于运行态或就绪状态，只有在该状态的进程才可能在 CPU 上运行
S：可中断的睡眠状态，处于这个状态的进程因为等待某种事件的发生而被挂起
T：暂停状态或跟踪状态
X：退出状态，进程即将被销毁
Z：退出状态，进程成为僵尸进程

命令行控制进程

ps 命令

通过 ps aux 可以查看当前机器上的进程，其中 STAT 列的第一个字符就是进程的状态：

# ps aux

USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND

root         1  0.0  0.2 190764  2140 ?        Ss    2018  12:35 /usr/lib/systemd/systemd --system --deserialize 20

root         2  0.0  0.0      0     0 ?        S     2018   0:00 [kthreadd]

root         3  0.0  0.0      0     0 ?        S     2018   1:24 [ksoftirqd/0]

kill 命令

kill 命令用于结束进程，语法如下：

kill [-s signal|-p] [-q sigval] [-a] [--] pid...

kill -l [signal]

执行 kill 命令，系统会发送一个 SIGTERM 信号给对应的进程，请求进程正常关闭。SIGTERM 是有可能会被阻塞的。kill -9 命令用于强制杀死进程，系统给对应程序发送的信号是 SIGKILL，即 exit。exit 信号不会被系统阻塞。

示例：

kill -9 11235

PID

每个进程在创建的时候，内核都会为之分配一个全局唯一的进程号。

getpid 和 getppid 函数

通过 getpid 函数可以获取当前进程的 PID。getppid 函数可以获取父进程的 PID。

通过 ps aux 可以查看进程的 PID，资源消耗情况，通过 ps -ef 可以查看当前进程及其父进程的 PID。通过 pstree 命令可以以树状关系查看所有进程。

函数原型：

#include <sys/types.h>

#include <unistd.h>

pid_t getpid(void);

pid_t getppid(void);

环境变量

除了通过 main 函数的第三个参数获取环境变量，还可以通过 environ 全局变量或 getenv() 函数来获取。

getenv 函数原型：

#include <stdlib.h>

char *getenv(const char *name);

char *secure_getenv(const char *name);

环境变量示例

#include <stdio.h>

#include <stdlib.h>

extern char** environ;

int main(int argc, char* argv[], char* env[])

{

    int i = 0;

    char* myenv = NULL;

    while(env[i])

    {

        printf("env[%d] is: %s\n", i, env[i++]);

    }

    i = 0;

    while(environ[i])

        puts(environ[i++]);

    myenv = getenv("PATH");

    puts(myenv);

    return 0;

}

孤儿进程和僵尸进程

PCB（Process Control Block，进程控制块）是每个进程都有的数据结构，用于保存进程运行所需的信息，例如文件描述符表。

wait() 函数用来帮助父进程获取其子进程的退出状态。当进程退出时，内核为每一个进

程保存了退出状态信息。如果父进程未调用 wait() 函数，则子进程的退出信息将一直保存在内存中。

孤儿进程

Linux 中，每个进程在退出的时候，可以释放用户区空间，但是无法释放进程本身的 PCB 所占用的内存资源。PCB 必须由父进程释放。

父进程在创建子进程后退出，子进程变成孤儿进程。为防止内存泄漏，孤儿进程被 init 进程领养，init 进程变成孤儿进程的父进程。

下面示例中，父进程先退出：

#include <unistd.h>

#include <stdlib.h>

#include <stdio.h>

#include <sys/types.h>

#include <sys/stat.h>

int main()

{

	pid_t pid = fork();

	if (pid == 0)

	{

		printf("child pid is: %d, ppid is: %d\n", getpid(), getppid());

		sleep(1);

		printf("child pid is: %d, ppid is: %d\n", getpid(), getppid());

	}

	else if (pid > 0)

	{

		sleep(0.5);

		printf("parent pid is: %d, ppid is: %d\n", getpid(), getppid());

		printf("parent exit\n");

	}

	return 0;

}

输出：

parent pid is: 3348, ppid is: 713

parent exit

child pid is: 3349, ppid is: 1

child pid is: 3349, ppid is: 1

僵尸进程

子进程退出了，父进程一直未调用 wait 或 waitpid 函数，子进程就变成了僵尸进程。

代码控制进程

进程入口函数 main

可执行的二进制文件，都是从 main 函数开始执行的。main 函数有 3 种原型定义：

int main();

int main(int argc, char *argv[]);

int main(int argc, char *argv[], char *env[]);

参数：

argc：参数个数
argv：参数数组，每个参数都是字符串
env：环境变量数组，每个环境变量都是字符串

进程基本操作

注意，Shell 终端无法检测进程是否创建了子进程。在进程执行完毕后，Shell 会立即回到交互状态，此时如果子进程还在输出数据，会打印在 Shell 的命令提示符之后。可以在父进程中 sleep 一下。

创建进程

Linux 中用 fork() 函数创建新进程，函数原型如下：

#include<unistd.h>

pid_t fork(void);

返回值：

成功创建进程时，会对父子进程各返回一次，对父进程返回子进程的 PID，对子进程返回 0。通过条件分支语句可以分别进行不同处理。失败则返回小于 1 的错误码。

fork 函数执行的时候，会将当前正在运行的进程完整的复制一份，提供给子进程。子进程从 fork 函数之后开始执行。

创建多个子进程

通过 for 循环，可以创建多个子进程，只需要在每次 fork 之后判断如果是子进程则结束循环即可。通过循环下标可以判断当前子进程是第几次创建的：

#include <stdio.h>

#include <unistd.h>

#include <stdlib.h>

int main()

{

	int i = 0;

	int number = 5;

	pid_t pid;

	for (i = 0; i < number; i++)

	{

		pid = fork();

		if (pid == 0) break;

	}

	// 子进程

	if (i == 0) printf("first process, pid = %d\n", getpid());

	if (i == 1) printf("second process, pid = %d\n", getpid());

	//...

	// 父进程

	if (i == number) printf("parent process, pid = %d\n", getpid());

	return 0;

}

终止进程

进程的终止分为两种：

正常终止：
- 从 main() 函数中 return 返回，实际上也是调用的 exit() 函数
- 调用 exit() 类函数
异常终止：
- 调用 abort() 函数
- 接收到终止信号

exit 函数原型如下：

#include <stdlib.h>

void exit(int status);

exit(0) 等价于 return 0。

exec 函数组

fork 函数可以复制一份父进程，得到的子进程跟父进程有完全一样的代码跟数据。之后两个进程各自执行，互不影响。

实际上我们通常需要子进程执行不同的代码，这时就需要通过 exec 函数加载代码段，并跳转到新代码段的 main 入口执行。

函数原型：

#include <unistd.h>

extern char **environ;

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[]);

int execvpe(const char *file, char *const argv[], char *const envp[]);

exec 函数组是在 exec 上加 l、v、p、e 四个后缀形成的，这些函数作用相同，只是在参数列表上存在差别。

后缀 p：用文件名做参数，如果文件名中不含路径则会去 PATH 环境变量所指定的各个目录中搜索可执行文件。无后缀 p 则使用绝对路径名来指定可执行文件的位置。
后缀 e：表示可以传递一个指向环境字符串指针数组的指针，环境数组需要以 NULL 结束。而无此后缀的函数则使用调用进程中 environ 变量为新程序复制现有的环境。
后缀 l：用 list 形式来传递新程序的参数，传给新程序的所有参数以可变参数的形式传递，最后一个参数必须是 NULL。
后缀 v：用 vector 形式来传递新程序的参数，传给新程序的所有参数放入一个字

符串数组中，数组以 NULL 结束。

返回值：exec 族函数报错时才有返回值 -1，否则无返回值。如果执行到后面的代码，就是出错了。

示例：

char* myenv[] = {"TEST=666", "HOME=/home/kika", NULL};

execle("home/kika/test", "hello", "world", myenv);

完整示例：

#include <stdio.h>

#include <unistd.h>

#include <stdlib.h>

int main()

{

	int pid = fork();

	if (pid > 0) {

		exit(0);

	} else if (pid == 0) {

		execle("home/kika/test", "hello", "world", myenv);

		perror("execle error");

		exit(-1);

	} else {

		perror("fork error");

	}

	return -1;

}

wait 和 waitpid 函数

通常，在父进程中调用 wait 函数，可以查看子进程的退出信息，让子进程撤单结束。wait 函数是阻塞式的，waitpid 可以设置为非阻塞的。父进程根据创建的子进程个数，在循环中通过 wait 函数逐个回收子进程。而 waitpid 函数则可以通过 PID 等待指定的子进程退出。

wait 函数调用一次只会回收一个子进程。多个子进程需要调用多次 wait。

函数原型：

#include <sys/types.h>

#include <sys/wait.h>

pid_t wait(int *status);

pid_t waitpid(pid_t pid, int *status, int options);

wait 参数：

status：进程退出的原因。可以通过预定义的宏来检查：
- WIFEXITED(status)：若为正常终止子进程返回状态，则为真
- WEXITSTATUS(status)：获取子进程传给 exit 或 return 的参数
- WIFSIGNALED(status)：若为异常终止子进程返回状态，则为真
- WTERMSIG(status)：获取使子进程退出的信号

waitpid 参数：

pid：用于设置 waitpid 工作方式。
- -1：等价于 wait，等待任意子进程退出
- 0：等待组 ID 等于调用进程的组 ID 的任一子进程退出
- > 0：等待 PID 等于该数值的进程退出
- < -1：等待其组 ID 等于该数值的任一子进程退出
options：用于设置 waitpid 是否阻塞执行。0 则阻塞，设为 WNOHANG 则非阻塞。

返回值：成功时返回退出子进程的 PID，没有子进程时返回 -1.

综合示例

创建三个子进程，分别运行自定义程序，shell 程序，未定义程序（段错误）。然后在父进程中通过 wait 回收所有子进程，并分别判断退出原因：

#include <unistd.h>

#include <stdio.h>

#include <fcntl.h>

#include <stdlib.h>

#include <sys/types.h>

#include <sys/wait.h>

#include <sys/stat.h>

#include <errno.h>

int main(int argc, char* argv[])

{

    int num = 3;

    int i;

    pid_t pid;

    for (i = 0; i < 3; i++) {

        pid = fork();

        if (pid == 0) break;

    }

    if (i == 0) {

        execlp("ps", "ps", "aux", NULL);

        perror("execlp ps error");

        exit(1);

    } else if (i == 1) {

        execl("/root/test/api/process/myls", "", NULL);

        perror("execl myls error");

        exit(1);

    } else if (i == 2) {

        execl("./error", "", NULL);

        perror("execl ./error");

        exit(1);

    } else {

        int status;

        pid_t pid;

        while (pid = wait(&status) != -1) {

            printf("children PID is: %d\n", pid);

            if (WIFEXITED(status)) {

                printf("return value is: %d\n", WEXITSTATUS(status));

            } else if (WIFSIGNALED(status)) {

                printf("died by signal: %d\n", WTERMSIG(status));

            }

        }

    }

    return 0;

}

巴特西

【Linux 应用编程】进程管理 - 进程、线程和程序

基本概念

程序和进程的区别

并发和并行

Linux 进程的状态

命令行控制进程

ps 命令

kill 命令

PID

getpid 和 getppid 函数

环境变量

环境变量示例

孤儿进程和僵尸进程

孤儿进程

僵尸进程

代码控制进程

进程入口函数 main

进程基本操作

创建进程

创建多个子进程

终止进程

exec 函数组

wait 和 waitpid 函数

综合示例

最新文章

热门文章