Linux系统编程——进程

一、进程概念

1.何为程序，何为进程

（1）进程是一个动态的概念，程序是一个静态的概念。

程序是静态的概念，gcc test.c -o pro
磁盘中生成pro文件，叫做程序
进程是程序的一次运行活动

（2）进程具有并发性，而程序没有
（3）进程是资源分配和处理机调度的独立单位，其并发性受系统制约。
（4）一个程序，多次执行，对应多个进程，不同的进程可包含同一组程序。

2.如何查看系统中有哪些进程

（1）使用 ps指令查看进程，ps -aux查看完整进程，实际工作中，配合grep来查找程序中是否存在某一进程
ps指令：

ps-aux指令

ps -aux |grep init 查看init进程

（2） 使用top指令查看，类似windows任务管理器

3.进程标识符

进程号就相当于是标识进程存在的序号，这个序号是随机产生的，每次产生的进程的进程号都是不同的。它是用来唯一标识进程的。就像每个人自出生起你的身份证号就固定起来了。（唯一标识：在当前主机），比如说两个不同的主机，两个进程号就算相同的话，它也不是同一进程。
pid = 0；称为交换进程（swapper）

作用——进程调度

pid = 1；init进程

作用——系统初始化
利用 getpid(void)；函数获取进程的ID号
利用 getppid(void);获取父进程的pid号

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
int main()
{
    pid_t pid ppid;
    pid = getpid();//获取进程的pid号
	ppid = getppid();
    printf("the pid is %d\n",pid);
    while(1);
    return 0;
}
     

输出结果：

用top指令查看运行的进程，发现运行进程的pid

父进程为bsah（命令行解释器）：

基本Linux下的所有命令的父进程都是bash。
bash的运行原理：
通过创建子进程，让子进程去完成任务。 为什么？因为通过上面可以看到bash也相当于是操作系统的一个进程，所以具有进程独立性的特点，命令执行基础是要保证自己是安全的。等于说自己先创建一个子进程去完成命令，就算执行不了，崩掉了，此时根据进程独立性特点，它也影响不到父进程。因为bash是Linux程序运行的基础，bash崩了，整个Linux操作系统就崩了。

4.父子进程

进程A创建了进程B那么A叫做父进程，B叫做子进程，父子进程是相对的概念，理解为人类中的父子关系

5.C程序的存储空间分配

编译器在编译程序的时候，将程序中的所有的元素分成了一些组成部分，各部分构成一个段，所以说段是可执行程序的组成部分。

正文段（代码段）
这是由CPU执行的机器指令的部分，代码段就是程序中的可执行部分，直观理解代码段就是函数堆叠组成的。通常代码段是共享的，所以即使是频繁执行的程序在储存器中也只需有一个副本，另外正文段通常是只读的，以防止程序由于意外而修改其指令，例如char *p=“hello”；中的“hello”是常量字符串而不是变量字符串它被放在代码段的，如果妄图去修改它会导致段错误的发生。

初始化数据段（数据段）
初始化数据段。通常将此段称为数据段（也被称为数据区、静态数据区、静态区）数据段就是程序中的数据，直观理解就是C语言程序中的全局变量。（注意：全局变量才算是程序的数据，局部变量不算程序的数据，只能算是函数的数据），它包含了程序需要明显赋值的变量，例如，C程序中任何函数之外的声明：int count=1；
显式初始化为非零的全局变量和静态局部变量放在数据段。

未初始化数据段(bss段)
未初始化数据段通常将此段称之为bss段，内核将此段中的数据初始化为0或空指针。
未初始化或显式初始化为0的全局变量放在bss段。
bss段的特点就是被初始化为0，bss段本质上也是属于数据段，bss段就是被初始化为0的数据段。
注意区分：数据段（.data）和bss段的区别和联系：二者本来没有本质区别，都是用来存放C程序中的全局变量的。区别在于把显示初始化为非零的全局变量存在data段中，而把显式初始化为0或者并未显式初始化（C语言规定未显式初始化的全局变量值默认为0）的全局变量存在bss段。

栈
运行时自动分配&自动回收：栈是自动管理的，程序员不需要手工干预。方便简单。
反复使用：栈内存在程序中其实就是那一块空间，程序反复使用这一块空间。
脏内存：栈内存由于反复使用，每次使用后程序不会去清理，因此分配到时保留原来的值。使用栈内存时要要初始化（定义局部变量）。
临时性：（函数不能返回栈变量的指针，因为这个空间是临时的）
栈会溢出：因为操作系统事先给定了栈的大小，如果在函数中无穷尽的分配栈内存总能用完。例如函数递归调用没有收敛会导致栈溢出，或者是在函数中定义的局部变量太大也会用完栈内存从而导致栈溢出。
小知识：
自动变量:什么是自动变量呢？自动变量就是指在函数内部定义使用的变量。只能在函数内部使用它。自动变量是局部变量，即它的作用区域是在定义它的函数内部。由于自动变量在定义它的函数的外部是不可见的，所以允许我们在这个函数外部或者其他的函数内部定义同名的变量。计算机在执行这个函数的时候，创建这个变量并为它分配内存，当函数执行完毕返回后，自动变量就会被销毁。为自动变量分配内存就是压栈，而函数返回时就退栈。
临时变量是指在未在程序开头部分声明的，待使用它时才声明类型的变量。常见的如函数中定义的变量，循环语句、条件语句中声明定义的变量。这些变量可与主程序中的变量同名，在其作用域里，主程序中的同名变量一般无法调用。并且这种变量有效存在时间是从变量声明开始到相应程序段（循环结构或函数体）结束。

堆
操作系统堆管理器管理：堆管理器是操作系统的一个模块，堆管理内存分配灵活，按需分配。
大块内存：堆内存管理者总量很大的操作系统内存块，各进程可以按需申请使用，使用完释放。如果申请了内存使用完毕后没有释放会导致内存泄漏，还有就是如果p=（char*）malloc（16）；申请了空间并且指针p已经指向了申请的空间，但是中途又来一个p=&fa；对p指针进行赋值让其指向另一个内存空间，这就造成了原先申请的存储地址丢失，从而导致内存泄漏。当程序不断地发生内存泄漏，堆管理器没能够及时的回收内存，当程序再次申请内存时堆管理器已经没有内存能够分配给当前进程了，这样就发生了内存溢出，最终导致程序运行崩溃。
程序手动申请&释放：手工意思是需要写代码去申请malloc和释放free。
脏内存：堆内存也是反复使用的，而且使用者用完释放前不会清除，因此也是脏的。在malloc申请了得到堆空间后应该马上对他进行初始化memset（p，0，sizeof（p））；
临时性：堆内存只在malloc和free之间属于我这个进程，而可以访问。在malloc之前和free之后都不能再访问，否则会有不可预料的后果。
gcc中的malloc默认最小是以16B为分配单位的。如果malloc小于16B的大小时都会返回一个16字节的大小的内存。malloc实现时没有实现任意自己的分配而是允许一些大小的块内存的分配。

二、创建进程函数（fork）

1.fork函数用法

• 示例

#include <unistd.h>//头文件
pid_t fork(void);
fork函数调用成功，返回两次
在子进程中返回0，
父进程中返回子进程的PID，
子进程创建失败返回-1。

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>

int main()
{

        pid_t pid;

        printf("before fork the father pid is %d\n",getpid());
        pid=fork();//判断fork函数返回的值 

        if(pid>0){//返回值为非负数 代表是父进程
                printf("this is father print pid=%d , the return value is %d\n",getpid(),pid);//父进程的返回值为子进程的PID
        }else if(pid ==0){

                printf("this is child print pid=%d ， the return value is %d\n",getpid(),pid);//子进程的返回值为0
        }
        return 0;
}
                                                                                                                                                                                                                                                                                            

• 说明

（1）fork()为什么会有两个返回值

fork()只调用了一次
此时父进程创建出来一次的时候会return一次，子进程的数据流也会返回一次。
由于在复制时复制了 父进程的堆栈段，所以两个进程都停留在fork函数中，等待返回.因为fork函数会返回两次,一次是在父进程中返回，另一次是在子进程中返回，这两次的返回值不同. 从fork函数开始以后的代码父子共享，既父进程要执行这段代码，子进程也要执行这段代码.(子进程获得父进程数据空间，堆和栈的副本. 但是父子进程并不共享这些存储空间部分. 父，子进程共享代码段.) 现在很多现实并不执行一个父进程数据段，堆和栈的完全复制. 而是采用 写时拷贝技术.这些区域有父子进程共享，而且内核地他们的访问权限改为只读的.如果父子进程中任一个试图修改这些区域,则内核值为修改区域的那块内存制作一个副本, 也就是如果你不修改我们一起用，你修改了之后对应修改的那部分。
就是类似于进程的独立性，进程间代码共享，数据私有，此时因为数据要私有一份(数据改变)，所以此时父进程会return 一次（return一次子进程的进程号），子进程return一次，（return 0）；前提是进程创建成功的前提下。

（2）fork()父子的执行顺序和代码和数据的复制问题

进程数据=代码+数据
父进程创建子进程时，代码共享(因为代码在内存中一般为只读)，数据私有(写时拷贝)，这也就解释了上面的fork()为什么会有两个不同的返回值。

之前Linux系统采用完全拷贝，将父进程的内存地址和内容都重新拷贝一份
现在Linux系统采用写实拷贝，只有再对某一变量运用时才执行拷贝
写实拷贝：
当子进程刚刚被创建时，子进程和父进程的数据和代码是共享的，即父子进程的代码和数据通过页表映射到物理内存的同一块空间。
只有当父进程或子进程需要修改数据时，才将父进程的数据在内存当中拷贝一份，然后再进行修改。这种在需要进行数据修改时再进行拷贝的技术，称为写时拷贝技术。

例

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>

int main()
{

        pid_t pid;
        int data = 10;

        printf("before fork the father pid is %d\n",getpid());
        pid=fork();//判断fork函数返回的值 

        if(pid>0){//返回值为非负数 代表是父进程
                printf("this is father print pid=%d , the return value is %d\n",getpid(),pid);//父进程的返回值为子进程的PID
        }else if(pid ==0){
                data = data +100;
                printf("this is child print pid=%d ， the return value is %d\n",getpid(),pid);//子进程的返回值为0
        }
        printf("data = %d\n",data);
        return 0;
}   

可以看到，data的值在子进程中改变时data = data +100;，是通过重新赋值了父进程的数据段修改的，父进程的data值没有改变

关于执行顺序：当子进程被创建成功时，此时它会被加载到内存的运行队列中，又因为进程的
特征具有异步性。(进程以不可预料的结果向前推进)，所以这块子进程与父进程的执行顺序是不确定的。由操作系统中的调度器决定

（3）子进程是从fork之后开始运行

子进程是从fork()之后开始运行的。
父进程调用fork()函数时，其程序计数器中保存的是fork’()之后的下一条汇编指令。
上下文信息：调用fork()完毕之后保存的寄存器内容。
此时子进程去拷贝父进程的PCB，所以此时子进程拿到的便是fork之后的代码，所以子进程的执行是从fork()之后开始的。

（4）fork创建子进程的目的

①
一个父进程希望复制自己，使父、子进程同时执行不同的代码段。这在网络服务进程中是常见的——父进程等待客户端的服务请求。当这种请求到达时，父进程调用fork，使子进程处理此请求。父进程则继续等待下一个服务请求到达。

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>

int main()
{
    int data;
    pid_t pid;
    while(1){
        printf("Please input data\n");//等待用户输入,当用户输入为1时父进程创建子进程，在子进程中处理请求。
        scanf("%d",&data);
        if(data==1){
            pid=fork();
            if(pid == 0){
                while(1){
                    printf("do net requset,pid =%d\n",getpid());//在子进程中执行网络操作
                    sleep(3);
                }
        }

        }else{
            printf("do nothing\n");
        }
    }
    return 0;
}

②
一个进程要执行一个不同的程序。这对shell是常见的情况。在这种情况下，子进程从fork返回后立即调用exec。

2.vfork函数

vfork函数也可以创建进程，与fork的区别

关键区别一：

vfork保证子进程先运行，当子进程调用exit退出后，父进程才执行。
例：

• 在fork时：

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>

int main()
{
    int data;
    pid_t pid;
    pid = vfork();
    if(pid == 0){
        while(1){
            printf("this is child the pid is %d\n",getpid());
            sleep(2);
        }
    }else if(pid > 0){
        while(1){
            printf("this is father the pid is %d\n",getpid());
            sleep(2);
        }
    }
    return 0;
}

可见父子进程可同时运行

• 在vfork时：

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>

int main()
{
    int data;
    pid_t pid;
    pid = vfork();
    if(pid == 0){
        while(1){
            printf("this is child the pid is %d\n",getpid());
            sleep(2);
        }
    }else if(pid > 0){
        while(1){
            printf("this is father the pid is %d\n",getpid());
            sleep(2);
        }
    }
    return 0;
}

可见当子进程不退出时，父进程无法运行

• 当改为子进程循环三次后退出时

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main()
{
    int data;
    pid_t pid;
    pid = vfork();
    int cnt = 0;
    if(pid == 0){
        while(1){
            cnt++;
            printf("this is child the pid is %d\n",getpid());
            //当子进程执行三次后退出
            if(cnt ==3){
                printf("chile exit！\n");
                exit(0);
            }
            sleep(1);
        }
    }else if(pid > 0){
        while(1){
            printf("this is father the pid is %d\n",getpid());
            sleep(1);
        }
    }
    return 0;
}

可见当子程序退出时，父进程才可继续执行

关键区别二：

vfork直接使用父进程存储空间，与父进程共享数据段，不拷贝。

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main()
{
    int data;
    pid_t pid;
    int cnt = 0;
    pid = vfork();
    if(pid == 0){
        while(1){
            cnt++;
            printf("this is child the pid is %d\n",getpid());
            printf("the child cnt = %d\n",cnt);
            //当子进程执行三次后退出
            if(cnt ==3){
                printf("chile exit！\n");
                exit(0);
            }
            sleep(1);
        }
    }else if(pid > 0){
        while(1){
            printf("this is father the pid is %d\n",getpid());
            printf("the father cnt = %d\n",cnt);
            sleep(1);
        }
    }
    return 0;
}

可见当子进程改变cnt的值之后，父进程的cnt也改变，因为改变的是同一个cnt

三、进程退出

1.进程退出情况

代码运行完毕，结果正确。
代码运行完毕，结果不正确。
代码异常终止（进程崩溃）。

2.进程退出码

main函数是间接性被操作系统所调用的。当main函数调用结束后就应该给操作系统返回相应的退出信息，而这个所谓的退出信息就是以退出码的形式作为main函数的返回值返回，我们一般以0表示代码成功执行完毕，以非0表示代码执行过程中出现错误，这就是为什么我们都在main函数的最后返回0的原因。
当我们的代码运行起来就变成了进程，当进程结束后main函数的返回值实际上就是该进程的进程退出码，可以使用echo $?命令查看最近一次进程退出的退出码信息。
例：
代码正常运行结束后可以用echo $?命令查看退出码为0

当代码被强行结束时（ctrl+c）echo $?命令查看退出码为130

3.进程正常退出

（1）return退出

在main函数中使用return退出进程是我们常用的方法。

#include <stdio.h>
int main()
{
    printf("Hello world!\n");
    return 0;
}      

（2）exit函数

使用exit函数退出进程也是我们常用的方法，exit函数可以在代码中的任何地方退出进程，并且exit函数在退出进程前会做一系列工作：
1.执行用户通过atexit或on_exit定义的清理函数。
2.关闭所有打开的流，所有的缓存数据均被写入。
3.调用_exit函数终止进程。

调用exit函数时需要引入头文件 #include <stdlib.h>
例：

#include <stdio.h>
#include <stdlib.h>
void test()
{
    printf("Hello world!");//注意这里未加\n，结束时，未将缓冲区的内容输出
    exit(1);

}
int main()
{
    test();
    return 0;
}

可见输退出码为1，并关闭所有打开的流，所有的缓存数据均被写入，将缓冲区的内容输出

（3）_exit函数

使用_exit函数退出进程的方法我们并不经常使用，_exit函数也可以在代码中的任何地方退出进程，但是_exit函数会直接终止进程，并不会在退出进程前会做任何收尾工作。
调用exit函数时需要引入头文件 #include <unistd.h>
例：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void test()
{
    printf("Hello world!");//注意这里未加\n，结束时，未将缓冲区的内容输出
    _exit(2);

}
int main()
{
    test();
    return 0;
}

可见输退出码为2，没有将缓冲区的内容输出

（4）return、exit和_exit之间的区别与联系

①区别：
只有在main函数当中的return才能起到退出进程的作用，子函数当中return不能退出进程，而exit函数和_exit函数在代码中的任何地方使用都可以起到退出进程的作用。

使用exit函数退出进程前，exit函数会执行用户定义的清理函数、冲刷缓冲，关闭流等操作，然后再终止进程，而_exit函数会直接终止进程，不会做任何收尾工作。
②联系：
执行return num等同于执行exit(num)，因为调用main函数运行结束后，会将main函数的返回值当做exit的参数来调用exit函数。
使用exit函数退出进程前，exit函数会先执行用户定义的清理函数、冲刷缓冲，关闭流等操作，然后再调用_exit函数终止进程。

4.进程异常退出

进程异常退出
情况一：向进程发生信号导致进程异常退出。

例如，在进程运行过程中向进程发生kill -9信号使得进程异常退出，或是使用Ctrl+C使得进程异常退出等。

如下图：

情况二：代码错误导致进程运行时异常退出。

例如，代码当中存在野指针问题使得进程运行时异常退出，或是出现除0的情况使得进程运行时异常退出等。

int* test( )
{
	int a = 5;
	return &a;
}
int main()
{
	int* p = test();//变量a的地址只在test()函数内有效，当把a的地址传给指针p时，因为出了test函数，变量a的空间地址释放，导致p变成了野指针。
	*p = 10;
	return 0;
}

出现野指针异常退出

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
    int a = 10;
    int b;
    b = a/0;
    printf("%d\n",b);
    return 0;
}

出现除0错误

五、进程等待

1.Linux环境下的几种状态

（1）R状态–运行状态

程序正在运行

#include <stdio.h>
#include <stdlib.h>
int main()
{
    while(1){
    }
    return 0;
}

（2）S状态 --睡眠状态，可中断的

意味着进程在等待事件完成（这里的睡眠有时候也叫做可中断睡眠（interruptible sleep））。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
    while(1){
        printf("hello\n");
        sleep(5);
    }
    return 0;
}

休眠状态是在等待某种条件就绪，在休眠状态，可被操作系统杀死，也叫浅度睡眠。

处于这个状态的进程因为等待某某事件的发生（比如等待socket连接、等待信号量），而被挂起。这些进程的task_struct结构被放入对应事件的等待队列中。当这些事件发生时（由外部中断触发、或由其他进程触发），对应的等待队列中的一个或多个进程将被唤醒。
一般情况下，进程列表中的绝大多数进程都处于S状态（除非机器的负载很高）。毕竟CPU就这么一两个，进程动辄几十上百个，如果不是绝大多数进程都在睡眠，CPU又怎么响应得过来。

（3）Z状态，僵尸进程***

僵尸进程的概念：
1.僵死状态（Zombies）是一个比较特殊的状态。当子进程退出并且父进程没有读取到子进程退出的返回代码时就会产生僵死(尸)进程
2.僵死进程会以终止状态保持在进程表中，并且会一直在等待父进程读取退出状态代码。
3.所以，只要子进程退出，父进程还在运行，但父进程没有读取子进程状态，子进程进入Z状态

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main()
{
    int data;
    pid_t pid;
    int cnt = 0;
    pid = fork();
    if(pid == 0){
        while(1){
            printf("this is child the pid is %d\n",getpid());
            cnt++;
            sleep(1);
            //子进程循环三次退出
            if(cnt == 3){
                printf("chile exit！\n");
                exit(1);
            }
        }
    }else if(pid > 0){
        while(1){
            printf("this is father the pid is %d\n",getpid());
            sleep(1);
            //父进程没有回收子进程的退出码
        }
    }
    return 0;
}

（4）D状态 —磁盘休眠状态。

有时候也叫不可中断睡眠状态（uninterruptible sleep），在这个状态的进程通常会等待IO的结束。

（5）T状态–暂停状态

可以通过发送 SIGSTOP 信号给进程来停止（T）进程（ctrl + z）。这个被暂停的进程可
以通过发送 SIGCONT 信号让进程继续运行。

通过键入ctrl + z，使得进程进入暂停状态


命令kill -18 + 进程号（PID） 让程序暂停执行

（6）X状态 --死亡状态

一般来说我们是看不到死亡进程的，死亡进程会被立即置换出内存，这个过程是及其短暂的，所以很难追踪到。

（7）孤儿进程

父进程如果不等待子进程退出，在子进程之前就结束了自己的生命，此时子进程叫做孤儿进程
Linux避免系统存在过多孤儿进程，init进程收留孤儿进程，变成孤儿进程的父进程。
例：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{
    pid_t pid;
    int cnt = 0;
    pid = fork();
    if(pid == 0){
        while(1){
            printf("this is child the pid is %d , my father pid is %d \n",getpid(),getppid());
            cnt++;
            sleep(1);
            if(cnt == 5){//子进程循环5次退出
                printf("child exit！\n");
                exit(3);//返回退出码3
            }
        }
    }else if(pid > 0){
        printf("this is father the pid is %d\n",getpid());
        sleep(1);
    }
    return 0;
}

由上例得：子进程为16421，父进程为16420，当父进程先与子进程退出时，子进程便成为了孤儿进程，这是它的父进程pid不在是16420，而是15754

查看15754进程：

这里/lib/systemd/systemd --user 就是【孤儿收养院】

2.进程等待的方法

下面进程等待所使用的两个函数wait和waitpid，都有一个status参数，该参数是一个输出型参数，由操作系统进行填充。
如果对status参数传入NULL，表示不关心子进程的退出状态信息。否则，操作系统会通过该参数，将子进程的退出信息反馈给父进程。
我们通过一系列位操作，就可以根据status得到进程的退出码和退出信号。
对于此，系统当中提供了两个宏来获取退出码和退出信号。

WIFEXITED(status)：用于查看进程是否是正常退出，本质是检查是否收到信号。
WEXITSTATUS(status)：用于获取进程的退出码。

（1） wait函数

• 函数原型：pid_t wait(int* status);

• 作用：等待任意子进程。

• 返回值：等待成功返回被等待进程的pid，等待失败返回-1。

• 参数：输出型参数，获取子进程的退出状态（传入的是整型指针），不关心可设置为NULL。

例

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{
    int data;
    pid_t pid;
    int cnt = 0;
    pid = fork();
    int status;
    if(pid == 0){
        while(1){
            printf("this is child the pid is %d\n",getpid());
            cnt++;
            sleep(1);
            if(cnt == 3){//子进程循环三次退出
                printf("child exit！\n");
                exit(3);//返回退出码3
            }
        }
    }else if(pid > 0){
        int ret = wait(&status);//父进程等待子进程，接受子进程的退出码，成功返回被等待进程的pid
        if(ret > 0){
            printf("wait child success!，the child pid is %d\n",ret);
        }
        if(WIFEXITED(status)){//通过这个宏 判断子进程是否正常退出，为1则正常退出
            printf("exit normal ，the status is %d\n",WEXITSTATUS(status));//通过这个宏获得子进程的退出码
        }
        while(1){
            printf("this is father the pid is %d\n",getpid());
            sleep(1);
        }
    }
    return 0;
}

（2）waitpid函数

wait和waitpid区别：

wait使调用者阻塞，waitpid有一个选项，可以使调用者不阻塞

• 函数原型：pid_t waitpid(pid_t pid, int* status, int options);

• 作用：等待指定子进程或任意子进程。

• 返回值：
  1、等待成功返回被等待进程的pid。
  2、如果设置了选项WNOHANG，而调用中waitpid发现没有已退出的子进程可收集，则返回0。
  3、如果调用中出错，则返回-1，这时errno会被设置成相应的值以指示错误所在。

• 参数：
  1、pid：待等待子进程的pid，若设置为-1，则等待任意子进程。
  2、status：输出型参数，获取子进程的退出状态，不关心可设置为NULL。
  3、options：当设置为WNOHANG时，若等待的子进程没有结束，则waitpid函数直接返回0，不予以等待。若正常结束，则返回该子进程的pid。
  示例：

• 多进程创建，父进程依次等待子进程的退出

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{
    int data;
    pid_t id;
    int cnt = 0;
    int status;
    int ret;
    pid_t ids[10];
    int i;
    for(i = 0;i<10;i++){
        id = fork();//循环创建十个子进程

        if(id ==0){//子进程
            printf("chile creat success! the pid = %d\n",getpid());
            sleep(3);//休眠3秒
            exit(i);
        }
        ids[i] = id;
    }
    //父进程
    for(i = 0;i<10;i++){
        ret = waitpid(ids[i],&status,0);
        if(ret > 0){
            printf("wait child success!，the child pid is %d\n",ret);
        }
        if(WIFEXITED(status)){
            printf("exit normal ，the status is %d\n",WEXITSTATUS(status));//通过这个宏获得子进程的退出码
        }

    }

    return 0;
}

由此可见，父进程创建了10个子进程，子进程等待3s后，结束并返回退出码，父进程依次等待子进程退出，并收集退出码

• 父进程设置为非阻塞等待
  上述所给例子中，当子进程未退出时，父进程都在一直等待子进程退出，在等待期间，父进程不能做任何事情，这种等待叫做阻塞等待。
  实际上我们可以让父进程不要一直等待子进程退出，而是当子进程未退出时父进程可以做一些自己的事情，当子进程退出时再读取子进程的退出信息，即非阻塞等待。

做法很简单，向waitpid函数的第三个参数potions传入WNOHANG，这样一来，等待的子进程若是没有结束，那么waitpid函数将直接返回0，不予以等待。而等待的子进程若是正常结束，则返回该子进程的pid。

例如，父进程可以隔一段时间调用一次waitpid函数，若是等待的子进程尚未退出，则父进程可以先去做一些其他事，过一段时间再调用waitpid函数读取子进程的退出信息，由此将父进程设置成为非阻塞模式

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>

int main()
{
    int data;
    pid_t pid;
    int cnt = 0;
    int status;
    pid_t ret;
    pid = fork();
    if(pid == 0){
        while(1){
            printf("this is child the pid is %d\n",getpid());
            cnt++;
            sleep(1);
            if(cnt == 5){//子进程循环5次退出
                printf("child exit！\n");
                exit(3);//返回退出码3
            }
        }
    }else if(pid > 0){
        while(1){
            ret = waitpid(pid,&status,WNOHANG);//父进程等待子进程，接受子进程的退出码，成功返回被等待进程的pid
            printf("ret = %d \n",ret);
            if(ret > 0){
                printf("wait child success!，the child pid is %d\n",ret);

                if(WIFEXITED(status)){//通过这个宏 判断子进程是否正常退出，为1则正常退出
                    printf("exit normal ，the status is %d\n",WEXITSTATUS(status));//通过这个宏获得子进程的退出码
                    break;//退出父进程
                }
            }else if(ret == 0){//waitpid的返回值为0时，说明子进程没有退出，父进程执行自己的程序
                printf("this is father the pid is %d\n",getpid());
                sleep(1);
            }else{
                printf("exit err!\n");
                break;//退出父进程
            }
        }
    }
    return 0;
}

运行结果表明：一开始，父进程与子进程同时运行，打印各自pid，当子进程循环5次后，执行退出命令，并将退出码传给父进程，父进程接收到子进程的退出信息后退出

六、进程程序替换（exec族函数）

1.替换原理

用fork创建子进程后，子进程执行的是和父进程相同的程序（但有可能执行不同的代码分支），若想让子进程执行另一个程序，往往需要调用一种exec函数。

当进程调用一种exec函数时，该进程的用户空间代码和数据完全被新程序替换，并从新程序的启动例程开始执行。

2.exec族函数

fork函数是用于创建一个子进程，该子进程几乎是父进程的副本，而有时我们希望子进程去执行另外的程序，exec函数族就提供了一个在进程中启动另一个程序执行的方法。它可以根据指定的文件名或目录名找到可执行文件，并用它来取代原调用进程的数据段、代码段和堆栈段，在执行完之后，原调用进程的内容除了进程号外，其他全部被新程序的内容替换了。另外，这里的可执行文件既可以是二进制文件，也可以是Linux下任何可执行脚本文件。
有六种以exec开头的函数，它们统称为exec函数：

• 所需头文件
  #include <unistd.h>

• 函数返回值

成功：函数不会返回,加载指定的程序并从启动代码开始执行。

出错：返回-1，失败原因记录在error中

• 命名理解
  这六个exec系列函数的函数名都以exec开头，其后缀的含义如下：

l(list)：表示参数采用列表的形式，一一列出。
v(vector)：表示参数采用数组的形式。
p(path)：表示能自动搜索环境变量PATH，进行程序查找。
e(env)：表示可以传入自己设置的环境变量。

（1）execl

int execl(const char *path, const char *arg, ...)
第一个参数是要执行程序的路径
第二个参数是可变参数列表，表示你要如何执行这个程序，并以NULL结尾。
例：

include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
    if(execl("/bin/ls","ls","-a","-l",NULL) == -1){

        perror("why");
    }

    return 0;
}

（2）execv

int execv(const char *path, char *const argv[])
第一个参数是要执行程序的路径
第二个参数是一个指针数组，数组当中的内容表示你要如何执行这个程序，数组以NULL结尾。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
    char * arg[] = {"-a","-l",NULL};
    if(execv("/bin/ls",arg) == -1){

        perror("why");
    }

    return 0;
}

（3）execlp

int execlp(const char *file, const char *arg, ...)
第一个参数是要执行程序的名字
第二个参数是可变参数列表，表示你要如何执行这个程序，并以NULL结尾。

对比上述的execl ，execlp函数可以在系统中能自动搜索环境变量PATH，进行程序查找
不用加绝对路径也可调用一些系统指令：
execp：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
    if(execlp("ls","ls",NULL) == -1){

        perror("why");
    }

    return 0;
}

可以不用绝对路径，调用系统指令：

execl：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{

    if(execl("ls","ls",NULL) == -1){
        perror("why");
    }
    return 0;
}

execl不加绝对路径则会报错

（4）execvp

int execvp(const char *file, char *const argv[])
第一个参数是要执行程序的名字
第二个参数是一个指针数组，数组当中的内容表示你要如何执行这个程序，数组以NULL结尾。
与execlp用法一致，只不过第二参数需要传入字符串数组：char * arg[] = {"-a","-l",NULL};

（5）execle

int execle(const char *path, const char *arg, ..., char *const envp[])
第一个参数是要执行程序的路径
第二个参数是可变参数列表，表示你要如何执行这个程序，并以NULL结尾
第三个参数是你自己设置的环境变量。

（6）execve

int execve(const char *path, char *const argv[], char *const envp[])
第一个参数是要执行程序的路径
第二个参数是一个指针数组，数组当中的内容表示你要如何执行这个程序，数组以NULL结尾
第三个参数是你自己设置的环境变量。

（5）、（6）函数 具体说明：将环境变量传递给需要替换的进程，原来的环境变量不再起作用。

打印当前系统环境变量的程序：

#nclude<stdio.h>

extern char **environ;

int main()
{
  int i;

  for(i = 0; environ[i]!=NULL; i++)
    printf("*environ[%d]: %s\n", i, environ[i]);

  return 0;
}

执行结果：
编译上述程序为ENV

执行程序显示系统的环境变量

由execle函数修改环境变量后调用这段程序

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
//  char * arg[] = {"-a","-l",NULL};
    char * envp[] = {"aa=1","cc=2",NULL};
    if(execle("./ENV","ENV",NULL,envp) == -1){

        perror("why");
    }

    return 0;
}

执行结果：打印了由execle调用ENV且更改后的环境变量

3.exec函数小练习

当用户输入1是，创建子进程修改配置文件的字段值

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main()
{
    int data;
    pid_t pid;
    while(1){
        printf("Please input data\n");//等待用户输入,当用户输入为1时父进程创建子进程，在子进程中处理请求。
        scanf("%d",&data);
        if(data==1){
            pid=fork();
            if(pid == 0){
                execlp("revise","revise","TEST.config",NULL);//执行已经写好的修改配置文件程序
                exit(0);
        }
		wait(NULL);
        }else{
            printf("do nothing\n");
        }
    }
    return 0;
}

revise程序：

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

int main(int argc,char **argv)
{
        int fdScr;// 需要修改的源文件操作符
        char* scrBuf=NULL;//用来接受源文件的字符串
        fdScr=open(argv[1],O_RDWR);//打开源文件
        int size=lseek(fdScr,0,SEEK_END);//间接计算源文件内容
        lseek(fdScr,0,SEEK_SET);//将光标值向头
        scrBuf=(char *)malloc(sizeof(char)*size+8);//为用来接受源文件内容的字符串开辟空间
        read(fdScr,scrBuf,size);//读取源文件内容至srcBuf
        char *p=strstr(scrBuf,"LENG=");//用strstr函数索引到需要改的地方，返回的p为索引到字符串的头指针。
        if(p==NULL){
                printf("NOT FOUND!\n");
                exit(-1);
        }
        p=p+strlen("LENG=");//将指针移动到需要修改的字符串
        *p='4';//修改指定内容
        close(fdScr);
        fdScr =open(argv[1],O_RDWR|O_TRUNC);//重新打开，以清空源文件内容方式打开
        write(fdScr,scrBuf,strlen(scrBuf));//写入新的内容
        close(fdScr);
        return 0;
}

具体文件的操作可查看
Linux 文件

4.system函数

• 函数原型：

int system(const char * string);

• 函数说明
  system()会调用fork()产生子进程，由子进程来调用/bin/sh-c string来执行参数string字符串所代表的命令，此命令执行完后随即返回原调用的进程。在调用system()期间SIGCHLD 信号会被暂时搁置，SIGINT和SIGQUIT 信号则会被忽略。
  注意：不同于exec族函数，system执行完之后还会执行原来的程序

• 返回值
  成功，则返回进程的状态值；
  当sh不能执行时，返回127；
  失败返回-1；
  例：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
    if(system("ps") == -1){

        perror("why");
    }

    printf("after system\n");
    return 0;
}

5.popen函数

• 函数原型

FILE * popen(conste char * command, const char * type);

• 函数说明：
  popen()会调用fork()生成子进程，在子进程中调用/bin/sh -c来执行参数command的指令，command对应的指令与在终端命令行中输入的命令相似如:“ls - l”、"/tmp/load_usb.sh"等

• 参数：
  command：是一个指向以NULL结束的shell命令字符串指针，shell将执行的命令
  type:可使用“r”或者"w",分别代表读取及写入，但由于popen是以创建管道的方式创建进程连接到子进程的标准输出设备或标准输入设备，因此其带有管道的一些特性，同一时刻只能定义为写或者读。

• 返回值
  文件指针，函数执行成功返回文件指针，否则返回NULL。
  可用来存储执行后的结果
  例：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
    FILE *fp;
    fp = popen("ls -l","r");
    char getstr;
    while(!feof(fp)){
        printf("%c",getstr);
    }
    return 0;
}

可见opopen函数将数据流返回，可以用C标准文件操作该数据流