【进程控制上】创建、终止、等待、程序替换

★进程的创建、终止、等待、程序替换、以及popen/system与fork之间的区别。

一、进程的创建

init进程将系统启动后，init将成为此后所有进程的祖先，此后的进程都是直接或间接从init进程“复制”而来。完成该“复制”功能的函数有fork()和clone()等。
1.fork

#include <unistd.h>
pid_t fork(void);
返回值：子进程返回0，父进程返回子进程的id；出错父进程返回-1，子进程创建失败。

2.进程调用fork，当控制转移到内核中的fork代码后，内核做了四件事情。
①分配新的内存块和内核数据结构给子进程。
②将父进程部分数据结构内容拷贝至子进程。
③添加子进程到系统进程列表当中。
④fork返回，开始调度器调度。

3.当一个进程调用fork之后，就会有两个二进制代码相同的进程，而且他们都运行到相同地方。
4.实现代码

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main()
{
    pid_t pid;
    printf("Before is %d\n",getpid());
    if((pid=fork())<0){
            perror("fork");
            exit(1);
    }
    printf("After is %d,return is %d\n",getpid(),pid);
    sleep(1);
    return 0;
}

注：父进程打印了两行，为什么子进程只打印了一行？
因为fork之前父进程独立运行，fork之后，父子两个执行流分别执行，但是，父子进程谁先执行完全由调度器决定，没有固定顺序。

5.什么时候使用fork呢？
1)一个父进程希望子进程同时执行不同的代码段，这在网络服务器中常见——父进程等待客户端的服务请求，当请求到达时，父进程调用fork，使子进程处理此请求。
2)一个进程要执行一个不同的程序，一般fork之后立即调用exec

6.写时拷贝
新进程得到的是父进程的副本，所以，父子进程count变量不会相互影响。
fork函数将复制父进程的地址空间给子进程，但为了提高效率，复制过程并不会真正的进行物理内存的完整复制，而是采用“写时拷贝（copy-on-write）”技术让父子进程尽可能地长久地共享该物理内存，仅仅是复制内存页入口地址并标记写拷贝对应的页面，当修改真正发生时才真正复制。

7.进程状态

8.fork调用失败的原因。
1)系统中太多的进程。
2)实际用户的进程超过了限制。

9.进程的创建还有另一种方式：vfork
1)函数

#include <sys/types.h>
#include <unistd.h>
pid_t vfork(void);
//成功：子进程返回 0，父进程返回子进程ID。pid_t为无符号整型。
//失败：返回 -1。

2)vfork特点
子进程和父进程共享地址空间。也就意味着子进程可以直接改变父进程的变量值。
vfork保证子进程先运行，在它调用exec（进程替换）或exit（退出进程）之后父进程才可能被调度执行。

二、进程的终止

1.进程的退出场景
1)代码运行完毕，代码正确。
2)代码运行完毕，结果不正确。
3)代码异常终止
2.进程的退出方法
①正常终止（可以使用命令：echo $? 查看进程退出码）
从main返回
调用exit
调用_exit
②异常终止
Ctrl+c，信号终止
③_exit函数

#include <unistd.h>
void _exit(int status);
//参数：status定义了进程的终止状态，父进程通过wait来获取该值。
//虽然status是int，但是仅有低八位可以被父进程所用，所以_exit(-1)时，终端执行
echo $?查看退出码,会发现，返回值是255。

④exit函数

//函数
#include <stdlib.h>
void exit(int staus);

//exit示例代码
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h> 
int main()
{
    printf("hello");//结果显示
    exit(0);                                                              
}

//_exit示例代码
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
    printf("hello");//结果不显示
    _exit(0);
}              

exit最后也会调用_exit，但在调用_exit之前，还做了其他工作，所以才会显示结果：
1、执行用户通过atexit或on_exit定义的清理函数。
2、关闭所有打开的流，所有的缓存数据均被写入
3、调用_exit

三、进程的等待

进程一旦变为僵尸进程就会造成内存泄漏，kill -9也无法杀死一个已经死去的进程，子进程任务完成的怎么样，也需要给父进程一个交代，所以父进程可以通过进程等待的方式，回收子进程资源，获取子进程退出信息。
1.进程等待的方式
1)wait方法

#include <sys/types.h>
#include <sys/wait.h>
pid_t wait(int *status);
返回值：成功返回被等待进程的pid，失败返回-1
参数：输出型参数，获取子进程退出时的信息，不用关心时，可以设置为NULL。

2)waitpid方法

pid_t   waitpid(pid_t  pid,int *status,int  options);
返回值：
正常返回时后waitpid收集到的子进程的id，如果设置了选项WNOHANG，而调用中waitpid发现
没有已退出的子进程可收集，则返回0.如果调用中出错，则返回-1，这时errno会被设置成相应
的值以指示错误所在。

//pid
pid>0时，只等待进程ID等于pid的子进程，不管其它已经有多少子进程运行结束退出了，只要指
定的子进程还没有结束,waitpid就会一直等下去。
pid=-1时，等待任何一个子进程退出，没有任何限制，此时waitpid和wait的作用一模一样。 　　
pid=0时，等待同一个进程组中的任何子进程，如果子进程已经加入了别的进程组，waitpid不会
对它做任何理睬。
pid<-1时，等待一个指定进程组中的任何子进程，这个进程组的ID等于pid的绝对值。 

//status：
WIFEXITED（status）：若为正常终止子进程返回状态，则为真。（查看进程是否是正常退出）
WEXITSTATUS（status）：若WIFEXITED非零，提取子进程退出码。（查看进程的退出码）

//options：
WNOHANG：若pid指定的子进程没有结束，则waitpid返回0，不予以等待。若正常结束，则返回
该子进程的id。

需要注意的一点得是，当子进程正常退出时，调用wait/waitpid时，函数会立即返回，并成功释放资源，获得子进程退出信息，如果在任意时刻调用wait/waitpid时，且子进程正在运行，会造成子进程的阻塞。如果不存在该子进程，则立即出错返回。
还有，wait就是经过包装的waitpid。
2.wait&waitpid的区别
waitpid提供了wait函数不能实现的3个功能:
1.waitpid等待特定的子进程, 而wait则返回任一终止状态的子进程;
2.waitpid提供了一个wait的非阻塞版本;
3.waitpid支持作业控制(以WUNTRACED选项). 用于检查wait和waitpid两个函数返回终止状态的宏: 这两个函数返回的子进程状态都保存在status指针中
3.获取子进程的status
1)wait和waitpid中都有一个status参数，是一个输出型参数，由操作系统填充。
2)如果传递NULL，那么意味着不关心子进程的退出信息。
3)否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程。
4)status不能简单的当做整型看待，可以看做位图，只看低16位

4.进程的阻塞与非阻塞式等待

阻塞
//waitpid(-1, &status, 0);
非阻塞
//waitpid(-1，&status, WNOHANG);

四、程序替换

何为程序替换？
如果操作系统正在执行某项程序，我们可以使用exec函数族进行程序替换，让系统去执行另一个程序，我们可以fork一个子进程，父子进程执行相同的代码，我们就可以使用程序替换，让子进程去干其他的事。

//shell脚本不相信任何人，它将任务交给子进程去执行。
//子进程用于执行命令，父进程用于返回！

1.替换函数

#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[]);//自己维护
//带l的函数，参数表以空指针结尾

int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execve(const char *path, char *const argv[], char *const envp[]);//自己维护 
//成功返回信息，失败返回-1
//execve属于系统调用，而其他的五个函数都是在execve函数基础上经过包装而形成的库函数

替换函数提供了一个在进程中启动另一个程序执行的方法，将当前程序替换为一个新的程序。
2.函数命名

l(list):参数采用列表
v(vector):参数采用数组
p(path):自动搜索环境变量
e(env):自己维护环境变量

3.程序替换的作用
在一个正在运行的进程内部根据函数所指定的文件名和路径找到可执行的文件，并将进程执行的程序替换为新程序，新程序从main处开始执行。其中这里的文件必须是二进制文件或Linux下可执行的脚本文件，另外，exec函数族的函数只是用磁盘上的一个新程序替换了当前进程的正文段、数据段、堆和栈。调用exec并不创建新进程，所以调用前后该进程的id并未改变.
4.代码示例

#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
int main()
{
    char *const argv[]={"ls","-l","-a","-i",NULL};//参数用数组
    char *const envp[]={"PATH=/bin:/usr/bin","TEMR=console",NULL};//自己维护
    pid_t id;
    id=fork();
    if(id<0)//unsucessful
    {
       perror("fork");
       return 0;
    }
    else if(id==0)//child
    {
       //execl("/bin/ls","ls","-l","-a","-i",NULL);
       //execlp("ls","ls","-l","-a","-i",NULL);  //带p的无需写全路径
       //execv("/bin/ls",argv);
       execle("ps","ps","-ef",NULL,envp);  //带e的自己组装环境变量
    }
    else//father
    {
    }
    return 0;
}

五、popen/system与fork之间的区别

1.popen

#include <stdio.h>
FILE *popen(const char *command, const char *type);
int pclose(FILE *stream);
//功能:popen（）会调用fork（）产生子进程，然后从子进程中调用/bin/sh -c来执行参数
//command的指令。

int pclose(FILE * stream)
//功能：pclose（）用来关闭由popen所建立的管道及文件指针

1)如果没有在调用popen后调用pclose那么这个子进程就可能变成”僵尸”。
2)popen执行命令并且通过管道和shell命令进行通信。
3)调用popen的进程为父进程，由popen启动的进程称为子进程。

2.system ：Linux下使用system()函数需谨慎

#include <stdlib.h>
int system(const char *command);

1)system()会调用fork()产生子进程，由子进程来调用/bin/sh-c string来执行参数string字符串所代表的命令.
2) 在编写具有SUID/SGID权限的程序时请勿使用system()，system()会继承环境变量，通过环境变量可能会造成系统安全的问题。