进程状态 进程创建 父子进程 进程退出 孤儿进程、僵尸进程 wait | waitpid
1. 进程概述
- 程序和进程
进程是正在运行的程序的实例。
- 是一个具有一定独立功能的程序关于某个数据集合的一次运行活动 。它是操作系统动态执行的 基本单元 ，在传统的操作系统中，进程既是 基本的分配单元 ，也是 基本的执行单元 。
-
可以用一个程序来创建多个进程， 进程是由内核定义的抽象实体，并为该实体分配用以执行程序的各项系统资源 。
从内核的角度看，进程由用户内存空间和一系列内核数据结构组成，其中用户内存空间包含了程序代码及代码所使用的变量，而内核数据结构则用于维护进程状态信息。记录在内核数据结构中的信息包括许多与进程相关的标识号（IDs）、虚拟内存表、打开文件的描述符表、信号传递及处理的有关信息、进程资源使用及限制、当前工作目录和大量的其他信息。
-
单道、多道程序设计
- 单道程序，即在计算机内存中只允许一个的程序运行。
- 多道程序设计技术是在计算机内存中同时存放几道相互独立的程序，使它们在管理程序控制下，相互穿插运行，两个或两个以上程序在计算机系统中同处于开始到结束之间的状态, 这些程序共享计算机系统资源。引入多道程序设计技术的根本目的是为了提高 cpu 的利用率。
- 对于一个单 cpu 系统来说，程序同时处于运行状态只是一种宏观上的概念，他们虽然都已经开始运行，但就微观而言，任意时刻，cpu 上运行的程序只有一个。
-
在多道程序设计模型中，多个进程轮流使用 cpu。而当下常见 cpu 为纳秒级，1秒可以执行大约 10 亿条指令。由于人眼的反应速度是毫秒级，所以看似同时在运行。
-
时间片
- 时间片（timeslice）又称为"量子（quantum）"或"处理器片（processor slice）"是操作系统分配给每个正在运行的进程微观上的一段 cpu 时间。事实上，虽然一台计算机通常可能有多个 cpu，但是同一个 cpu 永远不可能真正地同时运行多个任务。在只考虑一个 cpu 的情况下，这些进程"看起来像"同时运行的，实则是轮番穿插地运行，由于时间片通常很短（在 Linux 上为 5ms－800ms），用户不会感觉到。
- 时间片由操作系统内核的调度程序分配给每个进程。首先，内核会给每个进程分配相等的初始时间片，然后每个进程轮番地执行相应的时间，当所有进程都处于时间片耗尽的状态时，内核会重新为每个进程计算并分配时间片，如此往复。
-
并行和并发
- 并行(parallel)：指在 同一时刻 ，有 多条指令 在 多个处理器 上 同时执行 。
-
并发(concurrency)：指在 同一时刻只能 有 一条指令 执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。
- 并发是两个队列交替使用一台咖啡机。
-
并行是两个队列同时使用两台咖啡机。
- 检测控制块PCB
2. 进程状态转换
-
进程的状态
进程状态反映进程执行过程的变化。这些状态随着进程的执行和外界条件的变化而转换。
在三态模型中，进程状态分为三个基本状态，即 就绪态，运行态，阻塞态 。
在五态模型中，进程分为 新建态、就绪态，运行态，阻塞态，终止态 。
-
进程相关命令
- 查看进程
|
ps aux / ajx |
u:显示进程的详细信息
x:显示没有控制终端的进程
j:列出与作业控制相关的信息
-
进程号和相关函数
-
每个进程都由进程号来标识，其类型为 pid_t（整型），进程号的范围 0~32767 。
进程号总是 唯一 的，但可以 重用 。当一个进程终止后，其进程号就可以再次使用。
-
任何进程（除 init 进程）都是由另一个进程创建，该进程称为被创建进程的父进程，
对应的进程号称为父进程号（ PPID ）。
-
任何进程（除 init 进程）都是由另一个进程创建，该进程称为被创建进程的父进程，
-
进程组是一个或多个进程的集合。他们之间相互关联，进程组可以接收同一终端的各
种信号，关联的进程有一个进程组号（ PGID ）。默认情况下，当前的进程号会当做当
前的进程组号。
-
进程号和进程组相关函数：
pid_t getpid(void);
pid_t getppid(void);
pid_t getpgid(pid_t pid);
-
每个进程都由进程号来标识，其类型为 pid_t（整型），进程号的范围 0~32767 。
3. 进程创建
-
系统允许一个进程创建新进程，新进程即为子进程，子进程还可以创建新的子进程，形成进程树结构模型。
|
fork.c文件 fork函数的作用：用于创建子进程。 |
|
/* #include <sys/types.h> #include <unistd.h>
pid_t fork(void); 函数的作用：用于创建子进程。 返回值： fork()的返回值会返回两次。一次是在父进程中，一次是在子进程中。 1在父进程中返回创建的子进程的ID, 2在子进程中返回0 如何区分父进程和子进程：通过fork的返回值。 在父进程中返回-1，表示创建子进程失败，并且设置errno
父子进程之间的关系： 区别： 父进程中: >0 返回的子进程的ID 子进程中: =0 2.pcb中的一些数据 当前的进程的id pid 当前的进程的父进程的id ppid 信号集
共同点： 某些状态下：子进程刚被创建出来，还没有执行任何的写数据的操作 - 用户区的数据 - 文件描述符表
父子进程对变量是不是共享的？ - 刚开始的时候，是一样的，共享的。如果修改了数据，不共享了。 - 读时共享（子进程被创建，两个进程没有做任何的写的操作），写时拷贝。
*/
#include <sys/types.h> #include <unistd.h> #include <stdio.h>
int main() {
int num = 10;
// 创建子进程 pid_t pid = fork();
// 判断是父进程还是子进程 if(pid > 0) { // printf("pid : %d\n", pid); // 如果大于0，返回的是创建的子进程的进程号，当前是父进程 printf("i am parent process, pid : %d, ppid : %d\n", getpid(), getppid());
printf("parent num : %d\n", num); num += 10; printf("parent num += 10 : %d\n", num);
} else if(pid == 0) { // 当前是子进程 printf("i am child process, pid : %d, ppid : %d\n", getpid(),getppid());
printf("child num : %d\n", num); num += 100; printf("child num += 100 : %d\n", num); }
// for循环 for(int i = 0; i < 3; i++) { printf("i : %d , pid : %d\n", i , getpid()); sleep(1); }
return 0; }
/* 实际上，更准确来说，Linux 的 fork() 使用是通过写时拷贝 (copy- on-write) 实现。 写时拷贝是一种可以推迟甚至避免拷贝数据的技术。 内核此时并不复制整个进程的地址空间，而是让父子进程共享同一个地址空间。 只用在需要写入的时候才会复制地址空间，从而使各个进行拥有各自的地址空间。 也就是说，资源的复制是在需要写入的时候才会进行，在此之前，只有以只读方式共享。 注意：fork之后父子进程共享文件， fork产生的子进程与父进程相同的文件文件描述符指向相同的文件表，引用计数增加，共享文件偏移指针。 */ |
4. 父子进程虚拟地址空间情况
- 方框内的代码表示会运行
-
程序的栈空间存了fork()函数要返回的pid值。父程序的栈空间存的pid值是子程序真正的在系统中的pid值（大于0），
子程序的栈空间存的pid值是0；所以上面fork.c代码可以通过是否大于0或等于0来判断进程类型。
-
另外程序栈空间存的同名变量值，父、子程序是互相不影响的
-
实际上，更准确来说，Linux 的 fork() 使用是通过 写时拷贝 (copy- on-write) 实现。
写时拷贝是一种可以推迟甚至避免拷贝数据的技术。
内核此时并不复制整个进程的地址空间，而是让父子进程共享同一个地址空间。
只用在需要写入的时候才会复制地址空间，从而使各个进行拥有各自的地址空间。
也就是说，资源的复制是在需要写入的时候才会进行，在此之前，只有以只读方式共享。
注意：fork之后父子进程共享文件，
- 父子进程之间的关系
5. GDB多进程调试
- 设置调试父进程或者子进程：
|
set follow fork mode [parent(默认) | child] |
- 设置调试模式：是否脱离
|
set detach onset detach on fork [on | off] |
默认为on ，表示调试当前进程的时候，其它的进程继续运行，
如果为 off ，调试当前进程的时候，其它进程被 GDB 挂起。
|
查看调试的进程： |
info inferiors |
|
切换当前调试的进程： |
inferior id |
|
使进程脱离GDB 调试： |
detach inferiors id |
|
hello.c文件 |
|
#include <stdio.h> #include <unistd.h>
int main() { printf("begin\n");
if(fork() > 0) { printf("我是父进程：pid = %d, ppid = %d\n", getpid(), getppid());
int i; for(i = 0; i < 10; i++) { printf("i = %d\n", i); sleep(1); } } else { printf("我是子进程：pid = %d, ppid = %d\n", getpid(), getppid());
int j; for(j = 0; j < 10; j++) { printf("j = %d\n", j); sleep(1); } } return 0; } |
6. exec函数族
exec 函数族的函数执行成功后不会返回，因为调用进程的实体，包括代码段，数据
段和堆栈等都已经被新的内容取代，只留下进程ID 等一些表面上的信息仍保持原样，
颇有些神似"三十六计"中的"金蝉脱壳"。看上去还是旧的躯壳，却已经注入了新的灵
魂。
只有调用失败了，它们才会返回-1，从原程序的调用点接着往下执行。
- exec函数族
|
◼ int execl(const char *path, const char *arg, .../* (char *) NULL */); ◼ int execlp(const char *file, const char *arg, ... /* (char *) NULL */); ◼ int execle(const char *path, const char *arg, .../*, (char *) NULL, 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[]); ◼ int execve(const char *filename, char *const argv[], char *const envp[]);
l(list) 参数地址列表，以空指针结尾 v(vector) 存有各参数地址的指针数组的地址 p(path) 按PATH 环境变量指定的目录搜索可执行文件 e(environment) 存有环境变量字符串地址的指针数组的地址 |
|
execl.c文件 |
|
/* #include <unistd.h> int execl(const char *path, const char *arg, ...); - 参数： a.out /home/Nowcoder/a.out 推荐使用绝对路径 ./a.out hello world
- arg:是执行可执行文件所需要的参数列表 第一个参数一般没有什么作用，为了方便，一般写的是执行的程序的名称 从第二个参数开始往后，就是程序执行所需要的的参数列表。 参数最后需要以NULL结束（哨兵）
- 返回值： 只有当调用失败，才会有返回值，返回-1，并且设置errno 如果调用成功，没有返回值。
*/ #include <unistd.h> #include <stdio.h>
int main() {
pid_t pid = fork();
if(pid > 0) { // 父进程 printf("i am parent process, pid : %d\n",getpid()); sleep(1); }else if(pid == 0) { // 子进程 // execl("hello","hello",NULL);
execl("/bin/ps", "ps", "aux", NULL); perror("execl"); printf("i am child process, pid : %d\n", getpid());
}
for(int i = 0; i < 3; i++) { printf("i = %d, pid = %d\n", i, getpid()); }
return 0; } |
|
execlp.c文件 |
|
/* #include <unistd.h> int execlp(const char *file, const char *arg, ... ); - 会到环境变量中查找指定的可执行文件，如果找到了就执行，找不到就执行不成功。 - 参数： - <a href="file://需要执行的可执行文件的文件名">file:需要执行的可执行文件的文件名</a> a.out ps
- arg:是执行可执行文件所需要的参数列表 第一个参数一般没有什么作用，为了方便，一般写的是执行的程序的名称 从第二个参数开始往后，就是程序执行所需要的的参数列表。 参数最后需要以NULL结束（哨兵）
- 返回值： 只有当调用失败，才会有返回值，返回-1，并且设置errno 如果调用成功，没有返回值。
int execv(const char *path, char *const argv[]); argv是需要的参数的一个字符串数组 char * argv[] = {"ps", "aux", NULL}; execv("/bin/ps", argv);
int execve(const char *filename, char *const argv[], char *const envp[]); char * envp[] = {"/home/Nowcoder", "/home/bbb", "/home/aaa"};
*/ #include <unistd.h> #include <stdio.h>
int main() {
pid_t pid = fork();
if(pid > 0) { // 父进程 printf("i am parent process, pid : %d\n",getpid()); sleep(1); }else if(pid == 0) { // 子进程 execlp("ps", "ps", "aux", NULL);
printf("i am child process, pid : %d\n", getpid());
}
for(int i = 0; i < 3; i++) { printf("i = %d, pid = %d\n", i, getpid()); }
return 0; } |
7. 进程控制 （进程退出、孤儿进程与僵尸进程、进程回收）
|
exit.c文件 |
|
|
|
/* #include <stdlib.h> void exit(int status);
#include <unistd.h> void _exit(int status);
status参数：是进程退出时的一个状态信息。父进程回收子进程资源的时候可以获取到。 */ #include <stdio.h> #include <stdlib.h> #include <unistd.h>
int main() {
printf("hello\n"); printf("world");
// exit(0); _exit(0);
return 0; } |
区别：
如果使用exit(0)，上面代码 第一行显示hello，第二行显示word
因为第一行有"\n"，强制刷新了缓存区，使得正常输出；而第二行的内容还在缓存区，直接被系统库函数_exit(0)结束了
（看上面的图右边 两者区别：exit()还会调用退出处理函数，刷新IO缓存、关闭文件描述符）
-
孤儿进程
父进程运行结束，但子进程还在运行（未运行结束），这样的子进程就称为孤儿进程（Orphan Process ）。
每当出现一个孤儿进程的时候，内核就把孤儿进程的父进程设置为 init，而 init进程会循环地 wait() 它的已经退出的子进程。
这样，当一个孤儿进程凄凉地结束了其生命周期的时候， init 进程就会代表党和政府出面处理它的一切善后工作。
因此孤儿进程并不会有什么危害。
|
orphan.c文件 |
|
#include <sys/types.h> #include <unistd.h> #include <stdio.h>
int main() { // 创建子进程 pid_t pid = fork();
// 判断是父进程还是子进程 if(pid > 0) { printf("i am parent process, pid : %d, ppid : %d\n", getpid(), getppid()); } else if(pid == 0) { sleep(1); // 当前是子进程 printf("i am child process, pid : %d, ppid : %d\n", getpid(),getppid()); }
// for循环 for(int i = 0; i < 3; i++) { printf("i : %d , pid : %d\n", i , getpid()); } return 0; } |
-
僵尸进程
每个进程结束之后 , 都会释放自己地址空间中的用户区数据，内核区的 PCB 没有办法自己释放掉，需要父进程去释放。
进程终止时，父进程尚未回收，子进程残留资源（ PCB ）存放于内核中，变成僵尸（Zombie ）进程。
僵尸进程不能被 kill -9 杀死，这样就会导致一个问题，如果父进程不调用wait()或 waitpid() 的话，那么保留的那段信息就不会释放，
其进程号就会一直被占用，但是系统所能使用的进程号是有限的，如果大量的产生僵尸进程，
将因为没有可用的进程号而导致系统不能产生新的进程，此即为僵尸进程的危害，应当避免。
|
zombie.c文件 |
|
#include <sys/types.h> #include <unistd.h> #include <stdio.h>
int main() { // 创建子进程 pid_t pid = fork();
// 判断是父进程还是子进程 if(pid > 0) { while(1) { printf("i am parent process, pid : %d, ppid : %d\n", getpid(), getppid()); sleep(1); } } else if(pid == 0) { // 当前是子进程 printf("i am child process, pid : %d, ppid : %d\n", getpid(),getppid()); }
// for循环 for(int i = 0; i < 3; i++) { printf("i : %d , pid : %d\n", i , getpid()); } return 0; } |
- 进程回收
- wait()函数
|
wait.c文件 功能：等待任意一个子进程结束，如果任意一个子进程结束了，此函数会回收子进程的资源。
调用wait函数的进程会被挂起（阻塞），直到它的一个子进程退出或者收到一个不能被忽略的信号时才被唤醒（相当于继续往下执行） 如果没有子进程了，函数立刻返回，返回-1；如果子进程都已经结束了，也会立即返回，返回-1. |
|
/* #include <sys/types.h> #include <sys/wait.h> pid_t wait(int *wstatus); 功能：等待任意一个子进程结束，如果任意一个子进程结束了，此函数会回收子进程的资源。 参数：int *wstatus 进程退出时的状态信息，传入的是一个int类型的地址，传出参数。 返回值： - 成功：返回被回收的子进程的id
调用wait函数的进程会被挂起（阻塞），直到它的一个子进程退出或者收到一个不能被忽略的信号时才被唤醒（相当于继续往下执行） 如果没有子进程了，函数立刻返回，返回-1；如果子进程都已经结束了，也会立即返回，返回-1.
*/ #include <sys/types.h> #include <sys/wait.h> #include <stdio.h> #include <unistd.h> #include <stdlib.h>
int main() {
// 有一个父进程，创建5个子进程（兄弟） pid_t pid;
// 创建5个子进程 for(int i = 0; i < 5; i++) { pid = fork(); if(pid == 0) { break; } }
if(pid > 0) { // 父进程 while(1) { printf("parent, pid = %d\n", getpid());
// int ret = wait(NULL); int st; int ret = wait(&st);
if(ret == -1) { break; }
if(WIFEXITED(st)) { // 是不是正常退出 printf("退出的状态码：%d\n", WEXITSTATUS(st)); } if(WIFSIGNALED(st)) { // 是不是异常终止 printf("被哪个信号干掉了：%d\n", WTERMSIG(st)); }
printf("child die, pid = %d\n", ret);
sleep(1); }
} else if (pid == 0){ // 子进程 while(1) { printf("child, pid = %d\n",getpid()); sleep(1); }
exit(0); }
return 0; // exit(0) } |
|
WIFEXITED(status) 非 0 ，进程正常退出
WEXITSTATUS(status) 如果上宏为真，获取进程退出的状态（ exit 的参数）
WIFSIGNALED(status) 非 0 ，进程异常终止
WTERMSIG(status) 如果上宏为真，获取使进程终止的信号编号
WIFSTOPPED(status) 非 0 ，进程处于暂停状态
WSTOPSIG(status) 如果上宏为真，获取使进程暂停的信号的编号
WIFCONTINUED(status) 非 0 ，进程暂停后已经继续运行 |
- waitpid()函数
|
waitpid.c文件 功能：回收指定进程号的子进程，可以设置是否阻塞。 |
|
/* #include <sys/types.h> #include <sys/wait.h> pid_t waitpid(pid_t pid, int *wstatus, int options); 功能：回收指定进程号的子进程，可以设置是否阻塞。 参数： - pid: pid > 0 : 某个子进程的pid pid = 0 : 回收当前进程组的所有子进程 pid = -1 : 回收所有的子进程，相当于 wait() （最常用） pid < -1 : 某个进程组的组id的绝对值，回收指定进程组中的子进程 - options：设置阻塞或者非阻塞 0 : 阻塞 WNOHANG : 非阻塞 - 返回值： > 0 : 返回子进程的id = 0 : options=WNOHANG, 表示还有子进程活着 = -1 ：错误，或者没有子进程了 */ #include <sys/types.h> #include <sys/wait.h> #include <stdio.h> #include <unistd.h> #include <stdlib.h>
int main() {
// 有一个父进程，创建5个子进程（兄弟） pid_t pid;
// 创建5个子进程 for(int i = 0; i < 5; i++) { pid = fork(); if(pid == 0) { break; } }
if(pid > 0) { // 父进程 while(1) { printf("parent, pid = %d\n", getpid()); sleep(1);
int st; // int ret = waitpid(-1, &st, 0); int ret = waitpid(-1, &st, WNOHANG);
if(ret == -1) { break; } else if(ret == 0) { // 说明还有子进程存在 continue; } else if(ret > 0) { if(WIFEXITED(st)) { // 是不是正常退出 printf("退出的状态码：%d\n", WEXITSTATUS(st)); } if(WIFSIGNALED(st)) { // 是不是异常终止 printf("被哪个信号干掉了：%d\n", WTERMSIG(st)); } printf("child die, pid = %d\n", ret); } } } else if (pid == 0){ // 子进程 while(1) { printf("child, pid = %d\n",getpid()); sleep(1); } exit(0); }
return 0; } |
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。
