1.概念
进程是一个具有一定独立功能的程序的一次运行活动，同时也是资源分配的最小单元；
进程的状态：
进程正在占用CPU：执行状态
进程因为等待某个资源而睡眠：等待状态
进程一切准备就绪等待cpu：就绪状态
2.getpid（）
#include <sys/types.h>
#include <unistd.h>
pid_t getpid(void) 获取本进程ID
pid_t getppid(void) 获取父进程ID
3.fork（）
#include <unistd.h>
pid_t fork(void) 创建子进程
fork（）函数调用一次，返回两次，三种不同的值。
对于父进程，返回的是子进程的进程号。
对于子进程，返回值为0。
返回值为-1，创建进程失败。
返回值为0，即子进程
返回值大于0，即父进程。
由于进程是并发执行，fork（）函数创建的进程，子进程和父进程谁先执行是随机的。
子进程的数据空间、堆栈空间都会从父进程得到一个拷贝，而不是共享。在父进程中对count进行加1的操作，并没有影响到子进程中的count值，子进程中的count值仍然为0
在子进程执行后，return 0 会直接退出程序，释放变量，父程序再执行时，虽然变量值不变，但地址已经被归还给内核。
在子进程执行完成后，可用_exit（）函数退出。
exit():退出进程并清空缓冲区
_exit()：直接退出程序
4.vfork（）
#include <sys/types.h>
#include <unistd.h>
pid_t vfork(void) 创建子进程
区别：
1. fork:子进程拷贝父进程的数据段 vfork:子进程与父进程共享数据段
2. fork:父、子进程的执行次序不确定 vfork:子进程先运行，父进程后运行
仅仅是创建的进程的fork（）替换成了vfork（），结果不一样
5.exec函数族
fork创建一个新的进程，产生一个新的PID。exec启动一个新程序，替换原有的进程，因此进程的PID不会改变。
int execl（const char * path,const char *arg,...）;
int execv（const char *path,char *const argv[]）;
int execlp（const char *file,const char *arg,...）;
int execvp（const char *file,char *const argv[]）;
int execle（const char * path,const char *arg,...,char *const envp[]）;
int execve（const char *path,char *const argv[],char *const envp[]）;
int execl（const char * path,const char *arg,...）;
path：被执行程序名（含完整路径）。
arg1 ---- argn: 被执行程序所需的命令行参数，含程序名。以空指针（NULL）结束。
执行不成功不返回，执行失败返回-1.
int execv（const char *path,char *const argv[]）;
path：被执行程序名（含完整路径）。 argv[]: 被执行程序所需的命令行参数数组。
执行不成功不返回，执行失败返回-1.
便于记忆：（文件名+路径，命令，命令参数，...，NULL）；
execl和execv两者区别仅仅是execv用数组存了参数，而且exec函数执行完后都不会再执行后面函数。（图中的printf函数就没有执行）
int execlp（const char *file,const char *arg,...）;
int execvp（const char *file,char *const argv[]）;
execlp函数会从PATH环境变量所指的目录中查找符合参数file的文件名，找到后会执行该文件，然后将后面的参数当做argv[0].....，最后一个参数必须为NULL。
执行不成功不返回，执行失败返回-1.
便于记忆：（文件名，命令，命令参数，...，NULL）；
int execle（const char * path,const char *arg,...,char *const envp[]）;
int execve（const char *path,char *const argv[],char *const envp[]）;
执行不成功不返回，执行失败返回-1.
便于记忆：（文件名+路径，命令，命令参数，...，新的环境变量数组）
6.启动进程：system
#include<stdlib.h>
7.僵尸进程
僵尸进程是指已经结束了的，但是没有从进程表中删除的进程。僵尸进程已经释放了内存空间，没有可执行代码，不能被调度。
如果父进程直接结束，僵尸进程成为孤儿进程，会被分配给init进程，被清除。
如果父进程一直循环，僵尸进程会一直占着进程表，保持僵尸状态。
避免僵尸进程：进程等待。
父进程可以用signal调用wait函数进行回收，也可以用signal通知内核回收。
wait（）
#include <sys/types.h>
#include <sys/wait.h>
pid_t wait (int * status) 功能： 阻塞该进程，直到其某个子进程退出。
如果成功，wait（ ）会返回被收集的子进程的进程 ID;
如果调用进程没有子进程，则会失败，此时 wait（ ）返回-1，同时 errno 被置为 ECHILD。
参数 status 用来保存被收集进程退出时的状态，它是一个指向 int 类型的指针。但如果不关心子进程是如何死植的，而只想把该僵死进程销毁（事实上绝大多数是这种情况），则可以设置参数为 NULL，其调用形式如下∶
pid = wait(NULL);
如果参数status的值不是NULL，wait就会把子进程退出时的状态取出并存入其中，这是一个整数值（int），指出了子进程是正常退出还是被非正常结束的（一个进程也可以被其他进程用信号结束，我们将在以后的文章中介绍），以及正常结束时的返回值，或被哪一个信号结束的等信息。由于这些信息被存放在一个整数的不同二进制位中，所以用常规的方法读取会非常麻烦，人们就设计了一套专门的宏（macro）来完成这项工作，下面我们来学习一下其中最常用的两个：
1、WIFEXITED(status) 这个宏用来指出子进程是否为正常退出的，如果是，它会返回一个非零值（请注意，虽然名字一样，这里的参数status并不同于wait唯一的参数---指向整数的指针status，而是那个指针所指向的整数，切记不要搞混了）
2、WEXITSTATUS(status) 当WIFEXITED返回非零值时，我们可以用这个宏来提取子进程的返回值，如果子进程调用exit(5)退出，WEXITSTATUS(status) 就会返回5；如果子进程调用exit(7)，WEXITSTATUS(status)就会返回7。请注意，如果进程不是正常退出的，也就是说， WIFEXITED返回0，这个值就毫无意义。
waitpid（）
#include <sys/types.h>
#include <sys/wait.h>
pid_t waitpid(pid_t pid,int *status,int options)
pid>0时，只等待进程id为pid的子进程，不管其它已经有多少子进程运行结束退出了，只要指定的子进程还没有结束，waitpid就会一直等下去。
pid=-1时，等待任何一个子进程退出，没有任何限制，此时waitpid和wait的作用一模一样。
pid=0时，等待同一个进程组中的任何子进程，如果子进程已经加入了别的进程组，waitpid不会对它做任何理睬。
pid<-1时，等待一个指定进程组中的任何子进程，这个进程组的ID等于pid的绝对值。
options：
不使用options时：waitpid(-1,NULL,0);
目前在Linux中只支持WNOHANG和WUNTRACED两个选项
如果使用了WNOHANG参数调用waitpid，（非阻塞方式）即使没有子进程退出，它也会立即返回，不会像wait那样永远等下去。
- 当正常返回的时候，waitpid返回收集到的子进程的进程ID；
- 如果设置了选项WNOHANG，而调用中waitpid发现没有已退出的子进程可收集，则返回0；
- 如果调用中出错，则返回-1，这时errno会被设置成相应的值以指示错误所在；
当pid所指示的子进程不存在，或此进程存在，但不是调用进程的子进程，waitpid就会出错返回，这时errno被设置为ECHILD；
实例：
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
void die(const char *msg)
{
perror(msg);
exit(1);
}
void child2_do()
{
printf("In child2: execute 'date'\n");
sleep(5);
if (execlp("date", "date", NULL) < 0) {
perror("child2 execlp");
}
}
void child1_do(pid_t child2, char *argv)
{
pid_t pw;
do {
if (*argv == '1') {
pw = waitpid(child2, NULL, 0);
}
else {
pw = waitpid(child2, NULL, WNOHANG);
}
if (pw == 0) {
printf("In child1 process:\nThe child2 process has not exited!\n");
sleep(1);
}
}while (pw == 0);
if (pw == child2) {
printf("Get child2 %d.\n", pw);
sleep(5);
if (execlp("pwd", "pwd", NULL) < 0) {
perror("child1 execlp");
}
}
else {
printf("error occured!\n");
}
}
void father_do(pid_t child1, char *argv)
{
pid_t pw;
do {
if (*argv == '1') {
pw = waitpid(child1, NULL, 0);
}
else {
pw = waitpid(child1, NULL, WNOHANG);
}
if (pw == 0) {
printf("In father process:\nThe child1 process has not exited.\n");
sleep(1);
}
}while (pw == 0);
if (pw == child1) {
printf("Get child1 %d.\n", pw);
if (execlp("ls", "ls", "-l", NULL) < 0) {
perror("father execlp");
}
}
else {
printf("error occured!\n");
}
}
int main(int argc, char *argv[])
{
pid_t child1, child2;
if (argc < 3) {
printf("Usage: waitpid [0 1] [0 1]\n");
exit(1);
}
child1 = fork();
if (child1 < 0) {
die("child1 fork");
}
else if (child1 == 0) {
child2 = fork();
if (child2 < 0) {
die("child2 fork");
}
else if (child2 == 0) {
child2_do();
}
else {
child1_do(child2, argv[1]);
}
}
else {
father_do(child1, argv[2]);
}
return 0;
}
main创建child1子进程，创建成功就用child1创建child2子进程。
1.因为用fork（）创建进程，父子进程执行顺序随机，本机先执行child1，利用非阻塞方式等待child2（1是阻塞方式,0是非阻塞方式，图中赋值的是1），此时child2还未执行，child1不会一直等待，会先执行后面的语句。此时waitpid(child2, NULL, WNOHANG)函数返回值pw为0，输出： printf("In child1 process:\nThe child2 process has not exited!\n");，并且睡一秒。
2.当child1沉睡1秒时，cpu会去执行child2的函数，沉睡5秒，此时child1醒过来，此时pw还是0，继续循环，当循环到第五次时，child2函数醒来，执行后面的语句，打印出系统时间。
3.此时chid2执行完成后，child1的waitpid（）返回值pw为此时child2的pid，child1退出while循环，执行之后的语句。
4.child1遇到sleep（）沉睡五秒，系统去执行child1的父进程，即father，father进程里采用的是阻塞式等待，会一直等待直到child1完成。child1醒来后，打印出此时位置。
5.father进程waitpid返回child1的pid，然后退出while循环，打印出目录文件。
扫一扫
1022
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
