进程控制
目录
1. 程序和进程
什么是程序？什么是进程？
- 程序是计算机存储系统中的数据文件，如源代码程序和可执行程序
- 进程是程序关于某个数据集合的一次运行活动，是程序执行后得到的一个实体
- 在当代操作系统中，进程是资源分配的基本单位
程序和进程有什么联系？
- 没有程序就没有进程；但有了程序，未必就会有进程，如程序不运行、程序本身是动态库等
- 一个程序可能对应多个进程，如记事本程序多次运行，产生多个记事本进程
- 一个进程可能包含多个程序，如一个程序依赖多个动态库，每个动态库都是一个程序
2. 进程状态
进程三态模型：就绪、阻塞、运行。
- 就绪：进程已经做好了一切准备，一旦得到CPU，就会开始运行
- 阻塞：进程正在等待某一事件发生（如共享资源被释放、IO完成）而停止运行，在事件发生前，即使得到CPU也无法运行
- 运行：进程拥有CPU控制权，并正在运行
进程五态模型：与三态模型相比，多了新建、终止两种状态。
- 新建：进程还未创建完毕，不能被系统调度
- 终止：进程已结束运行，正在回收系统资源
3. 进程标识
每个进程都有一个非负整数的进程ID（pid），作为识别不同进程的唯一标识。
此外，每个进程还有一些其他标识符，包括父进程ID（ppid）、实际用户ID（uid）、有效用户ID（euid）、实际组ID（gid）、有效组ID（egid）。
#include <unistd>
pid_t getpid(); //返回值：调用进程的进程ID
pid_t getppid(); //返回值：调用进程的父进程ID
uid_t getuid(); //返回值：调用进程的实际用户ID
uid_t geteuid(); //返回值：调用进程的有效用户ID
uid_t getgid(); //返回值：调用进程的实际组ID
uid_t getegid(); //返回值：调用进程的有效组ID
4. 进程创建
一个现有的进程可以调用fork函数创建一个新进程，这个新进程叫做子进程，调用fork的进程叫做父进程。
- 子进程获得父进程数据空间、堆、栈的副本
- 父进程和子进程共享代码段、文件描述符和文件偏移量
#include <unistd.h>
pid_t fork(); //若成功：子进程返回0，父进程返回子进程ID；若出错，返回-1
fork的特点为：一次调用，两次返回。
- 父进程返回子进程ID的原因：父进程可以有多个子进程，但父进程不能通过函数获得其所有子进程的ID，因为没有这样的函数
- 子进程返回0的原因：一个进程只会有一个父进程，并且子进程还可以调用getppid获得其父进程ID
fork有以下两种用法：
- 父进程和子进程同时执行不同的代码段
- 子进程从fork返回后立即调用exec，执行另一个不同的程序
fork成功返回后，父进程和子进程继续执行后面的代码，但父子进程谁先执行，这点是不确定的。
#include <stdio.h>
#include <unistd.h>
int globvar = 10;
int main()
{
int var = 5;
pid_t pid = fork();
if (pid > 0)
{
sleep(2); //父进程休眠2秒，让子进程先运行
}
else if (pid == 0)
{
globvar++;
var++;
}
printf("pid = %d, globvar = %d, var = %d\n", getpid(), globvar, var);
return 0;
}
5. 进程终止
正常终止方式：
- 从main函数return
- 调用exit()、_Exit()、_exit()（对于linux，后两个函数是同义的）
- 进程的最后一个线程在其启动例程中调用return或pthread_exit()
异常终止方式：
- 调用abort()以产生SIGABRT信号
- 进程接收到某些信号
- 进程的最后一个线程对pthread_cancel()请求做出响应
6. 避免僵尸进程
僵尸进程的产生与危害
- 一个已经终止、但是其父进程尚未对其进行善后处理的进程，称为僵尸进程
- 子进程退出时，内核会释放它占用的内存等资源，但是仍然保留了一些信息，如进程ID
- 内核为终止子进程保留的信息直到父进程调用wait或waitpid时才会释放
- 如果父进程没有调用wait或waitpid，那么已经终止的子进程就会变成僵尸进程，其占用的进程ID会无法释放
- 大量的僵尸进程可能会使系统没有可用的进程ID，从而导致系统无法创建新进程
wait函数
#include <sys/types.h>
#include <sys/wait.h>
pid_t wait(int *status); //成功返回终止子进程ID，失败返回-1
当在父进程中调用了wait时：
- 如果所有子进程都还在运行，则父进程阻塞
- 如果有任意子进程终止，则取得其终止状态并立即返回
- 如果父进程没有子进程，则立即出错返回
如果wait的参数status不为NULL，那么子进程的终止状态就存放在它指向的内存中，如果不关心终止状态，可以将status指定为NULL。
waitpid函数
#include <sys/types.h>
#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *status, int options); //成功返回终止子进程ID，失败返回-1或0
waitpid的第二个参数status用法和wait一样，但waitpid相比于wait的不同之处在于：
- 当
pid > 0时，waitpid可以等待由pid指定的特定子进程 - 当
options == WNOHANG时，若pid指定的子进程尚未终止，waitpid不会阻塞，而是立即返回0 - 当
pid == -1 && options == 0时，waitpid等价于wait
虽然waitpid可以实现非阻塞版本的wait，但也存在一个缺陷：如果子进程在父进程waitpid(pid, NULL, WNOHANGE)之后才终止，那么即使父进程尚未结束，也不会给子进程收尸，也就是说，终止的子进程会一直处于僵尸进程状态，直到父进程退出。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
pid_t pid = fork();
if (pid == 0)
{
sleep(2); //确保父进程执行waitpid时子进程还在休眠
printf("child %d exit\n", getpid());
exit(0);
}
if (waitpid(pid, NULL, WNOHANG) == 0)
{
printf("waitpid return before child exit\n");
}
sleep(300); //虽然waitpid不阻塞，但在父进程终止前，子进程pid会一直是僵尸进程
return 0;
}
如果既要保证父进程不阻塞等待子进程终止，也不希望子进程处于僵尸状态直到父进程终止，可以采用调用两次fork的诀窍，其核心思路为：
- 进程A调用fork产生子进程B，然后立即调用
waitpid(pid, NULL, 0)，等待进程B终止 - 进程B再次调用fork产生子进程C，然后立即调用
exit(0)终止（必须确保进程B在进程C之前终止） - 进程A随即解除waitpid阻塞，对进程B收尸处理
- 由于父进程提前终止，进程C由init收养，其终止时也会由init收尸
- 此时，进程A和进程C就成为相互独立、互不干扰的两个进程，两者各司其职，分别执行不同的处理
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
int main()
{
pid_t pid = fork();
if (pid == 0)
{
if ((pid = fork()) > 0)
{
exit(0); //子进程B再次调用fork后立即终止，只留下孙子进程C
}
/*孙子进程C由init进程收养*/
sleep(2);
printf("I'm second child %d, my parent bacomes %d\n", getpid(), getppid());
exit(0);
}
printf("I'm parent %d\n", getpid());
if (waitpid(pid, NULL, 0) == pid) //父进程A立即调用waitpid等待子进程B终止
{
printf("first child %d exit\n", pid);
}
/*此时，进程A和进程C之间就没有了继承关系，两者相互独立，互不干扰，各司其职*/
sleep(300);
return 0;
}
从上图执行结果可以看出：
- 进程B（pid=9293）已经在进程列表中找不到了，说明已经被收尸处理了，没有产生僵尸进程
- 进程C（pid=9294）也不在进程列表中了，说明其终止后由init收尸处理了，也没有产生僵尸进程
7. exec函数族
exec函数及使用规则
上面提到过fork的两种用法，其中一种是“子进程从fork返回后立即调用exec，执行另一个不同的程序”。
- 当进程调用exec函数时，其执行的程序将完全替换为exec指定的新程序，而新程序则从其main()开始执行。
- 因为exec并不创建新进程，所以替换前后的进程ID不会改变，exec只是用磁盘上的一个新程序替换了调用进程的代码段、数据段和堆栈。
有7个不同的exec函数可供使用，它们统称为exec函数族，可以根据需要调用这7个函数中的任意一个。
#include <unistd.h>
/*7个函数返回值均为：若成功，不返回；若失败，返回-1*/
//以路径名为参数
int execl(const char *path, const char *arg0, ... /*, (char *)0 */);
int execv(const char *path, char *const argv[]);
int execle(const char *path, const char *arg0, ... /*, (char *)0, char *const envp[]*/);
int execve(const char *path, char *const argv[], char *const envp[]);
//以文件名为参数
int execlp(const char *file, const char *arg0, ... /*, (char *)0 */);
int execvp(const char *file, char *const argv[]);
//以文件描述符为参数
int fexecve(int fd, char *const argv[], char *const envp[]);
这些函数的命名是有规律的：exec[必选：l or v][可选：p or e]（fexecve作为特例单独拎出来）
这些函数的参数用于指定新程序的相关信息，分为3部分：可执行程序、命令行参数、环境变量，具体使用规则为：
【必选项l or v】
- 带l，各个命令行参数必须以','间隔，最后一个命令行参数必须是NULL
- 带v，需要将l后续的各个命令行参数（包括最后的NULL）构造成一个指针数组，然后以该指针数组作为参数
【可选项p】
- 不带p，以可执行程序的路径名path作为参数
- 带p，以可执行程序的文件名file作为参数，如果file中包含/，则视作路径名，否则从PATH环境变量指定的目录中搜索可执行程序
【可选项e】
- 不带e，复制调用进程的环境变量给新程序使用
- 带e，需要传递环境变量给新程序使用
【fexecve特例】
- 后缀ve含义和上面一样
- 前缀f代表新程序由文件描述符fd指定
exec函数使用示例
/* filename - execl.c */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
int main()
{
pid_t pid = fork();
if (pid == 0)
{
execl("/bin/echo", "echo", "executed by execl", NULL);
}
waitpid(pid, NULL, 0);
return 0;
}
/* filename - execv.c */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
char *execv_argv[] =
{
"echo",
"executed by execv",
NULL
};
int main()
{
pid_t pid = fork();
if (pid == 0)
{
execv("/bin/echo", execv_argv);
}
waitpid(pid, NULL, 0);
return 0;
}
/* filename - execlp.c */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
int main()
{
pid_t pid = fork();
if (pid == 0)
{
execlp("echo", "echo", "executed by execlp", NULL);
}
waitpid(pid, NULL, 0);
return 0;
}
/* filename - execvp.c */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
char *execvp_argv[] =
{
"echo",
"executed by execvp",
NULL
};
int main()
{
pid_t pid = fork();
if (pid == 0)
{
execvp("echo", execvp_argv);
}
waitpid(pid, NULL, 0);
return 0;
}
/* filename - execle.c */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
char *env[] =
{
"PATH=/home/delphi",
"USER=execle",
NULL
};
int main()
{
pid_t pid = fork();
if (pid == 0)
{
execle("/usr/bin/env", "env", NULL, env);
}
waitpid(pid, NULL, 0);
return 0;
}
/* filename - execve.c */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
char *execve_argv[] =
{
"env",
NULL
};
char *env[] =
{
"PATH=/home/delphi",
"USER=execve",
NULL
};
int main()
{
pid_t pid = fork();
if (pid == 0)
{
execve("/usr/bin/env", execve_argv, env);
}
waitpid(pid, NULL, 0);
return 0;
}
8. system函数
#include <stdlib.h>
int system(const char *command);
system返回值
在Unix系统中，system在其内部实现调用了fork、exec和waitpid，因此有3种返回值。
- 如果fork失败，或者waitpid返回除EINTR之外的错误，则system返回-1，并且设置errno以指示错误类型
- 如果exec失败，比如被信号中断，或者command命令不存在，system返回127
- 如果fork、exec和waitpid都成功，system的返回值是shell的终止状态，即command通过exit或return返回的值
下面通过一个system的简易实现，来帮助理解该函数的返回值。
int system(const char * cmdstring)
{
pid_t pid;
int status;
if (cmdstring == NULL)
{
return (1); //如果cmdstring为空，返回非零值，一般为1
}
if ((pid = fork()) < 0)
{
status = -1; //fork失败，返回-1
}
else if (pid == 0)
{
execl("/bin/sh", "sh", "-c", cmdstring, (char *)0);
_exit(127); // exec执行失败返回127，注意exec只在失败时才返回现在的进程，成功的话现在的进程就不存在啦~~
}
else //父进程
{
while (waitpid(pid, &status, 0) < 0)
{
if (errno != EINTR)
{
status = -1; //如果waitpid被信号中断，则返回-1
break;
}
}
}
return status; //如果waitpid成功，则返回子进程的返回状态
}
仔细看完这个system函数的简单实现，该函数的返回值就清晰了吧，那么什么时候system()返回0呢？答案是只在command命令返回0时。
system使用示例
#include <stdlib.h>
int main()
{
system("ls -l");
system("cat func.c");
system("gcc -o func.out func.c");
system("ls -l");
system("echo main.out begin system func.out");
system("./func.out");
return 0;
}
