补充：
1、 C程序的执行过程：
C编译器调用链接器，链接器设置可执行程序文件的启动起始地址（启动例程），启动例程获得内核传递来的
命令行参数和环境变量值，为调用main函数做准备。【实际上该启动例程常用汇编语言编写】，如果将启动例程换做C语言就是：exit(main(argc,argv));
main(int argc,char *argv[],char *engv[]);argv为指向参数的各个指针所构成的数组。
2、exit做一些清理处理（标准IO库的清理关闭操作为所有打开的流调用fclose函数）再进入内核，而_exit和_EXIT直接进入内核中。
main函数中返回一个整型值与用该值调用exit是等价的。 使用命令"echo $?"来打印终止状态.
注意：内核使程序执行起来的唯一方法是调用一个exec函数。其实各个exec函数族的各个函数参数意思都差不多，无论是哪个exec函数，都是将可执行程序的路径，命令行参数，和环境变量3个参数传递给可执行程序的main()函数;
代码示例：
#include<stdio.h>
#include<stdlib.h>
int main(int argc,char *argv[])
{
int i=0;
printf("hello!\n");
for(i=0;i<argc;i++)
{
printf("argv[%d]=%s\n",i,argv[i]);
}
char *p=NULL;
p=getenv("USER"); //getenv函数返回的是一个char *类型的指针
printf("p=%s\n",p);
exit(0);
}
3、环境表：环境表也是一个字符指针数组，每个程序都会接收到一张环境表。每个指针数组包含一个以null结束的C字符串的地址。
4、所有进程都具有唯一的进程ID号码，ID为0的进程是调度进程，即交换进程；该进程是内核的一部分，即系统进程，所有子进程的父ID不可能是0；init进程1是所有孤儿进程的父进程,它由内核调用，但不属于内核，一般做一些初始化的工作。进程ID2是页守护进程，此进程负责支持虚拟存储系统的分页操作。
1)pid_t getpid(void);//该进程ID号码
2)pid_t getppid(void);//当前进程的父ID号
5、fork函数的返回值有两个，一个返回给子进程，一个返回给父进程；其中返回给子进程的ID号是0，返回给父进程的ID号是新创建的子进程ID，因为父进程可以有很多个子进程，要通过这个ID号来区分不同的子进程。
注意的几点：
1）子进程对变量所做的改变并不影响父进程中该变量的值。
2）fork后父进程中所有打开的文件描述符都会被复制到子进程中。
3）fork的用法中在网络服务进程中，父进程等待客户端的服务请求，当这种请求到达时，父进程调用fork，使子进程处理此请求，父进程则继续等待下一个服务请求到达。
wait&waitpid
exec族 ：被内核调用
进程状态（运行、等待、停止、就绪、僵尸）
进程关系（进程组和会话）
守护进程
进程间通信
-----------------------------------------------------------------------------------------------------------------------------------------------------------
3.4.1.程序的开始和结束
3.4.1.1、main函数由谁调用
(1)编译链接时的引导代码。操作系统下的应用程序其实在main执行前也需要先执行一段引导代码(构建执行环境)才能去执行main，我们写应用程序时不用考虑引导代码的问题，编译链接时（准确说是链接时）由链接器将编译器中事先准备好的引导代码给连接进去和我们的应用程序一起构成最终的可执行程序。
(2)运行时的加载器。加载器是操作系统中的程序，当我们去执行一个程序时（譬如./a.out，譬如代码中用exec族函数来运行）加载器负责将这个程序加载到内存中去执行这个程序。
(3)程序在编译连接时用链接器，运行时用加载器，这两个东西对程序运行原理非常重要。
(4)argc和argv的传参如何实现
3.4.1.2、程序如何结束
(1)正常终止：return、exit、_exit /_EXIT
(2)非正常终止：自己或他人发信号(类似于电话标志)终止进程，信号也是有优先级的
3.4.1.3、atexit向操作系统注册进程终止处理函数(即main执行结束后调用的函数)
注意：按照ISO C的规定，一个进程可以登记多达32个函数，这些函数将由exit自动调用。atexit（）注册的函数类型应为不接受任何参数的void函数,exit调用这些注册函数的顺序与它们 登记时候的顺序相反(压栈过程)。同一个函数如若登记多次，则也会被调用多次。
【函数原型：】
#include <stdlib.h>
int atexit(void (*function)(void));
(1)实验演示
代码示例：
#include<stdio.h>
#include<stdlib.h>
void func1(void)
{
printf("func1\n");
}
void func2(void)
{
printf("func2\n");
}
int main(int argc,char **argv)
{
printf("hello world \n");
atexit(func1);
atexit(func2);
return 0; //效果等同于exit(0);
//_exit(0);和_Exit(0);不能显示 atexit();的内容，因为它立即返回给内核态
}
(2)atexit注册多个进程终止处理函数，先注册的后执行（先进后出，和栈一样）因为注册一个，就把atexit函数中的参数--函数指针进行压栈处理。
(3)return、exit和_exit的区别：return和exit效果一样，都是会执行进程终止处理函数，但是用_exit终止进程时并不执行atexit注册的进程终止处理函数。
补充：我们通常认为C语言的起始函数是main函数，实质上一个程序的启动函数并不一定是main函数，这个可以采用链接器来设置，但是gcc中默认main就是C语言的入口函数，在main函数启动之前，内核会调用一个特殊的启动例程，这个启动例程从内核中【取得命令行参数值和环境变量值】，为调用main函数做好准备，因此对应用程序而言main函数并不是起始，但是对应C语言而言，main函数就是入口地址，其他的由链接器帮助我们完成，实际上mian函数的执行是使用了exec函数，这是一个函数族，这也是内核执行一个程序的唯一方法，这在进程控制部分将进行分析。
记得在面试题中有一道关于在main函数退出之后，是否还可以执行程序的问题，这时候就要使用到前面提到的atexit函数。
#include<stdlib.h>
int atexit(void(*func)(void));
其中，atexit的参数是一个函数地址（或者说是一个函数指针），当调用此函数（指的是atexit的参数 ）时无须传递任何参数，该函数也不能返回值，atexit函数称为终止处理程序注册程序，注册完成以后，当函数终止是exit()函数会主动的调用前面注册的各个函数，但是exit函数调用这些函数的顺序于这些函数登记的顺序是相反的，我认为这实质上是参数压栈造成的，参数由于压栈顺序而先入后出。同时如果一个函数被多次登记，那么该函数也将多次的执行。
我们知道exit是在main函数调用结束以后调用，因此这些函数的执行肯定在main函数之后，这也是上面面试题的解决方法。即采用atexit函数登记相关的执行函数即可。
在exit函数的介绍中我们知道，exit()和_exit()以及_Exit()函数的本质区别是是否立即进入内核，_exit()以及_Exit()函数都是在调用后【立即进入内核】，而不会执行一些清理处理(就比如说地震的时候我们直接非正常下班)，但是exit()则会执行一些清理处理，这也是为什么会存在atexit()函数的原因，因为exit()函数需要执行清理处理，需要执行一系列的操作，这些终止处理函数实际上就是完成各种所谓的清除操作的实际执行体。atexit函数的定义也给了程序员一种运用exit执行一些清除操作的方法，比如有一些程序需要额外的操作，具体的清除操作可以采用这种方法对特殊操作进行清除等。
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
3.4.2.进程环境
3.4.2.1、环境变量(可以理解为操作系统中的全局变量)
(1)export命令查看环境变量
(2)进程环境表介绍.每一个进程中都有一份所有环境变量(export)构成的一个表格，也就是说我们当前进程中可以直接使用这些环境变量。进程环境表其实是一个字符串数组，用environ变量指向它。
(3)程序中通过【environ全局变量】使用环境变量，只需要声明就可以了，extern char **environ //二重指针
代码示例：打印出系统中的所有环境变量
#include<stdio.h>
int main(void)
{
extern char **environ;
int i=0;
while(NULL != environ[i])
{
printf("%s\n",environ[i]);
i++;
}
return 0;
}
(4)我们写的程序中可以无条件直接使用系统中的环境变量，所以一旦程序中用到了环境变量那么程序就和操作系统环境有关了.
(5)在一个应用程序中获取指定环境变量函数getenv(值得注意的是我们setenv或者是getenv的时候更改的是当前这个进程中的一份环境变量，而不是更改的操作系统中的那一份环境变量)
uboot中的环境变量移植了linux内核中的环境变量的设置方法。
3.4.2.2、进程运行的虚拟地址空间
(1)操作系统中每个进程在独立地址空间中运行
(2)每个进程的逻辑地址空间均为4GB（32位系统）
(3)每个进程认为4G的内存空间，0-1G为OS，1-4G为应用
(4)虚拟地址到物理地址空间的映射
(5)意义。进程隔离，安全性，提供多进程同时运行
我们写程序不用指定链接脚本的原因就是已经有了一个默认的链接脚本，这个默认的链接脚本指定我们应用程序的虚拟地址从0地址开始运行。
像单片机中用的RTOS，用的物理地址，需要重新烧录和编译。
-----------------------------------------------------------------------------------------------------------------------------------------------------------
3.4.3.进程的正式引入
3.4.3.1、什么是进程
(1)动态过程而不是静态实物
(2)进程就是程序的一次运行过程，一个静态的可执行程序a.out的一次运行过程（./a.out去运行到结束）就是一个进程。
(3)进程控制块PCB（process control block），内核中专门用来管理一个进程的数据结构。
也就是说对于我们每一个进程，操作系统会分配给我们一个PCB结构体，这个结构体中包含了这个进程的各种信息和元素。
3.4.3.2、进程ID(唯一来标识一个进程)
(1)getpid（获得当前进程的ID）、getppid(获得父进程ID)、getuid(获取当前进程的用户ID，比如root用户或是普通用户)、geteuid、getgid(获得当前进程的组ID)、getegid这些函数来获得当前进程的ID。
(2)实际用户ID和有效用户ID区别（可百度）
实际组ID和有效组ID。
【 #include <sys/types.h>
#include <unistd.h>
pid_t getpid(void); //获得当前进程的ID
pid_t getppid(void); //获得父进程ID
】
当我们执行一个进程后，操作系统分配的进程ID只能使用一次，就算再次执行这个进程，操作系统分配的进程ID也不会跟之前的进程重复了，而是一直往后走。
(3)linux中使用ps -aux命令来打印操作系统中所有的进程。
3.4.3.3、多进程调度(调度就是指在单位时间里怎么分配、安排多个进程之间的运行次序)原理
(1)操作系统同时运行多个进程(裸机程序就可以当作是只运行一次的操作系统，是单进程的操作系统)
(2)宏观上的并行和微观上的串行
(3)实际上现代操作系统最小的【调度单元】是进程，执行的最小单位是线程。
(例子：服务员（CPU）在不停桌间（进程）的上菜（执行线程）)
3.4.4.fork创建子进程
操作系统每次重新创建一个进程都是需要一定成本的，因为对于PCB这个结构体块来说需要占有一定的内存
3.4.4.1、为什么要创建子进程
(1)每一次程序的运行都需要一个进程
(2)多进程实现宏观上的并行
如果完全建立一个全新的进程出来是需要占用很多资源的，比如时间资源；但是从一个老进程那里直接copy出一个新进程，并且在这个新进程中进行更改某些模块，会节约很多资源，效率也会高很多。 这就是建立一个新的进程的主要意义。
3.4.4.2、fork的内部原理
#include <unistd.h>
pid_t fork(void);
(1)进程的分裂生长模式。如果操作系统需要一个新进程来运行一个程序，那么操作系统会用一个现有的进程来复制生成一个新进程。【老进程叫父进程，复制生成的新进程叫子进程。】
(2)fork的演示
(3)【fork函数调用一次会返回2次】，返回值等于0的就是子进程，而返回值大于0（实际上是子进程的进程ID号）的就是父进程。因为fork函数就是去创造进程的，自然要返回两次。(就像生孩子一样，进去一个人，出来两个人，fork调用后就会出现两个进程，通过其返回值来判断哪个是父进程，哪个是子进程
父进程和子进程里面有完全一样的代码，同时被操作系统调度运行，也就是一个程序中fork后拥有两个进程，一个是程
序本身作为父进程，一个是fork创建的子进程。
代码示例：
#include <unistd.h>
#include <stdio.h>
int main(void)
{
pid_t p1;
p1=fork();
if(p1==0)
{
printf("这里是子进程，ID是：%d\n",getpid());
printf("在子进程中，父进程ID是：%d\n",getppid());
}
if(p1>0)
{
printf("这里是父进程，ID是：%d\n",getpid());
printf("在父进程中，子进程ID是：%d\n",p1);
}
return 0;
}
(4)典型的使用fork的方法：使用fork后然后用if判断返回值，并且返回值大于0时就是父进程，等于0时就是子进程。
(5)fork的返回值在子进程中等于0，在父进程中等于本次fork创建的子进程的进程ID。
3.4.4.3、关于子进程
(1)子进程和父进程的关系（相互独立的）
(2)子进程有自己独立的PCB(由父进程那里复制而来，但是后来有改动，子进程被内核同等调度)
(3)子进程被内核同等调度
3.4.5.父子进程对文件的操作
3.4.5.1、子进程继承父进程中打开的文件
(1)上下文：父进程先open打开一个文件得到fd，然后在fork创建子进程。之后在父子进程中各自write向fd中写入内容
(2)测试结论是：接续写。实际上本质原因是父子进程之间的fd对应的文件指针是彼此关联的（很像O_APPEND标志后的样子）
(3)实际测试时有时候会看到只有一个，有点像分别写。但是实际不是。原因是父进程写完后直接把文件关闭了，关闭后子进程就写不进去内容了。
代码测试：
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define NAME "1.txt"
int main()
{
char a[]="aa";
char b[]="bb";
int fd=-1;
pid_t pid;
fd=open(NAME,O_RDWR);
if(fd<0)
{
perror("open");
return -1;
}
pid=fork();
if(pid==0) //子进程
{
write(fd,&a,2);
}
if(pid>0) //父进程
{
write(fd,&b,2);
}
if(pid<0) //fork出错
{
perror("fork");
return -1;
}
return 0;
}
3.4.5.2、父子进程各自独立打开同一文件实现共享
(1)父进程open打开1.txt然后写入，子进程打开1.txt然后写入，结论是：【分别写】。原因是父子进程分离后才各自打开的1.txt，这时候这两个进程的PCB已经独立了，文件表也独立了，因此2次读写是完全独立的。
(2)open时使用O_APPEND标志看看会如何？实际测试结果标明O_APPEND标志可以把父子进程各自独立打开的fd的文件指针给关联起来，实现接续写。
代码示例：
#include<stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define NAME "1.txt"
int main(void)
{
char buf[100]="linux program";
pid_t pid;
int fd=-1;
ssize_t ret;
pid=fork();
if(pid>0) //父进程
{
fd=open(NAME,O_RDWR | O_APPEND);
if(fd==-1)
{
perror("open");
_exit(-1);
}
ret= write(fd,&buf,sizeof(buf));
if(ret == -1)
{
perror("write");
_exit(-1);
}
}
if(pid==0) //子进程
{
fd=open(NAME,O_RDWR | O_APPEND);
if(fd==-1)
{
perror("open");
_exit(-1);
}
ret= write(fd,&buf,sizeof(buf));
if(ret == -1)
{
perror("write");
_exit(-1);
}
}
if(pid<0)
{
perror("fork");
_exit(-1);
}
close(fd);
return 0;
}
3.4.5.3、总结
(1)父子进程间终究多了一些牵绊
(2)父进程在没有fork之前自己做的事情对子进程有很大影响，但是父进程fork之后在自己的if里做的事情就对子进程没有影响了。本质原因就是因为fork内部实际上已经复制父进程的PCB生成了一个新的子进程，并且fork返回时子进程已经完全和父进程脱离并且独立被OS调度执行。
(2)子进程最终目的是要独立去运行另外的程序
(有点类似于父子分家)
-----------------------------------------------------------------------------------------------------------------------------------------------------------
3.4.6.进程的诞生和消亡
3.4.6.1、进程的诞生
(1)进程0和进程1(在内核态由进程0 fork出来的进程1也就是init进程)，从进程2才开始进入用户态。
进程0属于内核态，进程1不属于内核态，但是它被内核态调用，是所有孤儿进程的父进程，从进程2开始才是进入用户态。
(2)fork
(3)vfork
vfork和fork的主要区别是vfork能够保证子进程先运行。
3.4.6.2、进程的消亡
(1)正常终止和异常终止
(2)进程在运行时需要消耗系统资源（内存、IO），进程终止时理应完全释放这些资源（如果进程消亡后仍然没有释放相应资源则这些资源就丢失了）
(3)linux系统设计时规定：每一个进程退出时，操作系统会【自动回收】这个进程涉及到的所有的资源（譬如malloc申请的内容没有free时，当前进程结束时这个内存会被释放，譬如open打开的文件没有close的在程序终止时也会被关闭）。但是操作系统并没有回收干净，只是回收了这个进程工作时消耗的内存和IO，而并没有回收这个进程本身占用的内存（8KB，主要是task_struct(进程描述结构体)和栈内存）
(4)因为进程本身的8KB内存操作系统不能回收需要别人来辅助回收，因此我们每个进程都需要一个帮助它收尸的人，这个人就是这个进程的父进程。
3.4.6.3、僵尸进程
(1)子进程先于父进程结束。子进程结束后父进程此时并不一定立即就能帮子进程“收尸”，在这一段（子进程已经结束且父进程尚未帮其收尸）子进程就被成为僵尸进程。
(2)子进程除task_struct和栈外其余内存空间皆已被操作系统清理
(3)父进程可以使用wait函数或waitpid函数以显式回收【子进程的剩余待回收内存资源】并且【获取子进程退出状态。看子进程是否是正常退出的】
(4)父进程也可以不使用wait或者waitpid回收子进程，此时父进程结束时一样会回收子进程的剩余待回收内存资源。（这样设计是为了防止父进程忘记显式调用wait/waitpid来回收子进程从而造成内存泄漏）
3.4.6.4、孤儿进程
(1)父进程先于子进程结束，子进程成为一个孤儿进程。
(2)linux系统规定：所有的孤儿进程都自动成为一个特殊进程（进程1，也就是init进程）的子进程。
3.4.7.父进程调用wait函数回收子进程
3.4.7.1、wait的工作原理
(1)子进程结束时，【操作系统】就向其父进程发送SIGCHILD信号 来提醒父进程去回收
(2)父进程调用wait函数后阻塞，阻塞就是为了随时循环监听、等待操作系统发给的信号
(3)父进程收到信号后被SIGCHILD信号唤醒然后去回收僵尸子进程
(4)父子进程之间是异步的（就是说父子进程之间发生什么事是互相不知道的），SIGCHILD信号机制就是为了解决父子进程之间的【异步通信】问题，让父进程可以及时的去回收僵尸子进程。
(5)若父进程没有任何子进程则wait函数返回错误
3.4.7.2、wait实战编程
函数原型：
#include <sys/types.h>
#include <sys/wait.h>
pid_t wait(int *status);
pid_t waitpid(pid_t pid, int *status, int options);
(1)wait的参数status。status用来返回子进程结束时的状态，父进程通过wait得到status后就可以知道子进程的一些结束状态信息。
(2)wait的返回值pid_t，这个返回值就是本次wait回收的子进程的PID。当前父进程有可能有多个子进程，wait函数阻塞直到其中一个子进程结束wait就会返回，wait的返回值就可以用来判断到底是哪一个子进程本次被回收了。
对wait做个总结：wait主要是用来回收子进程资源，回收同时还可以得知被回收子进程的【pid和退出状态】。
(3)fork后wait回收实例
(4)WIFEXITED、WIFSIGNALED、WEXITSTATUS这几个函数宏用来获取子进程的退出状态。
1、WIFEXITED宏用来判断子进程是否正常终止（return、exit、_exit退出）
2、WIFSIGNALED宏用来判断子进程是否非正常终止（被信号所终止）
3、WEXITSTATUS宏用来得到正常终止情况下的进程返回值的。
代码示例：
#include<stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
int main(void)
{
pid_t pid,ret_pid; //分别定义fork返回值和wait回收后获得的子进程ID
int status;
pid = fork();
if(pid>0) //父进程
{
ret_pid= wait(&status);
printf("父进程回收的子进程的PID是：%d\n",ret_pid);
if(WIFEXITED(status))
{
printf("子进程是正常终止\n");
printf("子进程正常终止的返回值是:%d\n",WEXITSTATUS(status));//得到正常终止情况下的进程返回值的
}
printf("子进程是否非正常终止：%d\n",WIFSIGNALED(status));
}
if(pid==0) //子进程
{
printf("子进程，pid是%d\n",getpid());
return 234;
sleep(1);
}
if(pid<0)
{
perror("fork");
_exit(-1);
}
return 0;
}
3.4.8.waitpid介绍
3.4.8.1、waitpid和wait差别
(1)基本功能一样，都是用来回收子进程
(2)waitpid可以回收指定PID的子进程
(3)waitpid可以阻塞式或非阻塞式两种工作模式 ，而wait函数只能够阻塞式的去回收。
3.4.8.2、waitpid原型介绍
(1)参数
(2)返回值
#include <sys/types.h>
#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *status, int options);
3.4.8.3、代码实例
(1)使用waitpid实现wait的效果
ret = waitpid(-1, &status, 0); 负1表示不等待某个特定PID的子进程而是回收任意一个子进程，0表示用默认的方式（阻塞式）来进行等待，返回值ret是本次回收的子进程的PID
(2)ret = waitpid(pid, &status, 0); 等待回收PID为pid的这个子进程，如果当前进程并没有一个ID号为pid的子进程，则返回值为负1；如果成功回收了pid这个子进程则返回值为回收的进程的PID ,0表示用默认的方式（阻塞式）来进行等待
(3)ret = waitpid(pid, &status, WNOHANG);这种表示父进程要【非阻塞式】的回收子进程。此时如果父进程执行waitpid时子进程已经先结束等待回收则waitpid直接回收成功，返回值是回收的子进程的PID；如果父进程waitpid时子进程尚未结束则父进程立刻返回（非阻塞），但是返回值为0（表示回收不成功）。
3.4.8.4、竟态初步引入
(1)竟态全称是：竞争状态，多进程环境下，多个进程同时抢占系统资源（内存、CPU运行时间、文件IO）
(2)竞争状态对OS来说是很危险的，此时OS如果没处理好就会造成结果不确定。
(3)写程序当然不希望程序运行的结果不确定，所以我们写程序时要尽量消灭竞争状态。操作系统给我们提供了一系列的消灭竟态的机制，我们需要做的是在合适的地方使用合适的方法来消灭竟态。
*******************************************************************************************************************************************************************************************
3.4.9.exec族函数及实战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[]);
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[]);
3.4.9.1、为什么需要exec函数
补充两点：
（1）exec函数说明
fork函数是用于创建一个子进程，该子进程几乎是父进程的副本，而有时我们希望子进程去执行另外的程序，exec函数族就提供了一个在进程中启动另一个程序执行的方法。它可以根据指定的文件名或目录名找到可执行文件，并用它来取代原调用进程的数据段、代码段和堆栈段，在执行完之后，原调用进程的内容除了进程号外，其他全部被新程序的内容替换了。另外，这里的可执行文件既可以是二进制文件，也可以是Linux下任何可执行脚本文件。
（2）在Linux中使用exec函数族主要有以下两种情况：
当进程认为自己不能再为系统和用户做出任何贡献时，就可以调用任何exec 函数族让自己重生。
如果一个进程想执行另一个程序，那么它就可以调用fork函数新建一个进程，然后调用任何一个exec函数使子进程重生。
(1)fork子进程是为了执行新程序(fork创建了子进程后，子进程和父进程同时被OS调度执行，因此子进程可以单独的执行一个程序，这个程序宏观上将会和父进程程序同时进行)
(2)可以直接在子进程的if中写入新程序的代码。这样可以，但是不够灵活，因为我们只能把子进程程序的源代码贴过来执行（必须知道源代码，而且源代码太长了也不好控制），譬如说我们希望子进程来执行ls -la 命令就不行了（没有源代码，只有编译好的可执行程序）
(3)使用exec族运行新的可执行程序（exec族函数可以直接把一个编译好的可执行程序直接加载运行）
(4)我们有了exec族函数后，我们典型的父子进程程序是这样的：子进程需要运行的程序被单独编写、单独编译连接成一个可执行程序（叫hello），（项目是一个多进程项目）主程序为父进程，fork创建了子进程后在子进程中调用exec函数族来执行hello，达到父子进程分别做不同程序同时（宏观上）运行的效果。
3.4.9.2、exec族的6个函数介绍
(1)execl和execv 这两个函数是最基本的exec，都可以用来执行一个程序，区别是传参的格式不同。execl是把参数列表（本质上是多个字符串，【必须以NULL结尾】）依次排列而成（l其实就是list的缩写），execv是把参数列表事先放入一个字符串数组中，再把这个字符串数组传给execv函数。
(2)execlp和execvp 这两个函数在上面2个基础上加了p，较上面2个来说，区别是：上面2个执行程序时必须指定可执行程序的【全路径】（如果exec没有找到path这个文件则直接报错），而加了p的传递的可以是file（也可以是path，只不过兼容了file。加了p的这两个函数会首先去找file，如果找到则执行，如果没找到则会去环境变量PATH所指定的目录下去找，如果找到则执行如果没找到则报错）
(3)execle和execvpe 这两个函数较基本exec来说加了e，函数的参数列表中也多了一个字符串数组envp形参，e就是environment环境变量的意思，和基本版本的exec的区别就是：执行可执行程序时会多传一个环境变量的字符串数组给待执行的程序。
3.4.9.3、exec实战1
(1)使用execl运行ls -l -a
(2)使用execv运行ls
(3)使用execl运行自己写的程序
/*主要就是传参的注意 man 3 execl*/
int execl(const char *path, const char *arg, ...); //函数原型
代码示例：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
//使用execl运行ls -l -a
#define PATH "/bin/ls"
int main()
{
int ret=-1;
ret = fork();
char *p[]={"PATH","-l","-a",NULL}; //字符串数组定义
if(ret<0)
{
perror("fork:");
_exit(-1);
}
if(ret == 0) //子进程
{
//(1)execv(PATH,p);
//(2)execl(PATH,"ls","-a","-l",NULL);
// (3)执行自己的函数程序 execl("./hello","./hello",NULL);
}
if(ret > 0)
{
printf("hello !\n");
sleep(1);
}
return 0;
}
hello.c代码示例：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int test(char * p, char *p2,int *numGet)
{
int ret = 0;
if(p ==NULL || p2 == NULL || numGet == NULL)
{
ret =-1;
return ret;
}
char *pget=p;
char *sub=p2;
int *count=numGet;
int i=0;
while(pget=strstr(pget,sub))
{
i++;
pget = pget+strlen(sub);
if(*pget==‘\0‘)
{
break;
}
}
*count = i;
return ret;
}
int main()
{
char *pw="afndaidsgsabc";
char *subs ="a";
int countn=0;
int ret=0;
ret=test(pw,subs,&countn);
if(ret==0)
{
printf("次数为：%d\n",countn);
}
else
{
printf("出错了！\n");
}
return 0;
}
3.4.10.exec族函数及实战2
3.4.10.1、execlp和execvp
(1)加p和不加p的区别是：不加p时需要全部路径+文件名，如果找不到就报错了。加了p之后会多帮我们到PATH所指定的路径下去找一下。
3.4.10.2、execle和execvpe
(1)main函数的原型其实不止是int main(int argc, char **argv)，而可以是
int main(int argc, char **argv, char **env) 第三个参数是一个字符串数组，内容是环境变量。
(2)如果用户在执行这个程序时没有传递第三个参数，则程序会自动从父进程继承一份环境变量（默认的，最早来源于OS中的环境变量）；如果我们exec的时候使用execle或者execvpe去给传一个envp数组，则程序中的实际环境变量是我们传递的这一份（取代了默认的从父进程继承来的那一份）
注意：execle和execvpe的第三个环境变量参数是可以更改从系统环境变量继承过来的这一份的。
代码示例：
#include <unistd.h>
int main(int argc, char *argv[])
{
char *envp[]={"PATH=/tmp", "USER=lei", "STATUS=testing", NULL};
char *argv_execv[]={"echo", "excuted by execv", NULL};
char *argv_execvp[]={"echo", "executed by execvp", NULL};
char *argv_execve[]={"env", NULL};
if(fork()==0) {
if(execl("/bin/echo", "echo", "executed by execl", NULL)<0)
perror("Err on execl");
}
if(fork()==0) {
if(execlp("echo", "echo", "executed by execlp", NULL)<0)
perror("Err on execlp");
}
if(fork()==0) {
if(execle("/usr/bin/env", "env", NULL, envp)<0)
perror("Err on execle");
}
if(fork()==0) {
if(execv("/bin/echo", argv_execv)<0)
perror("Err on execv");
}
if(fork()==0) {
if(execvp("echo", argv_execvp)<0)
perror("Err on execvp");
}
if(fork()==0) {
if(execve("/usr/bin/env", argv_execve, envp)<0)
perror("Err on execve");
}
}
-----------------------------------------------------------------------------------------------------------------------------------------------------------
3.4.11.进程状态和system函数
1、所有进程链表
2、就绪态链表
3.4.11.1、进程的5种状态（结合超市购物买单的例子）
(1)就绪态。这个进程当前所有运行条件就绪，只要得到了CPU时间就能直接运行(只差被CPU调度了)。
(2)运行态。就绪态时得到了CPU调度就进入运行态开始运行。
(3)僵尸态。子进程已经结束但是父进程还没来得及回收
(4)等待态（浅度睡眠&深度睡眠），进程在等待某种条件，【条件成熟后可进入【就绪态】】。等待态下就算你给他CPU调度进程也无法执行。浅度睡眠等待时进程可以被（信号）唤醒，而深度睡眠等待时不能被唤醒，【只能等待的条件到了】才能结束睡眠状态。
(5)暂停态。暂停并不是进程的终止，只是被别人（信号）暂停了，还可以恢复的。暂停状态收到信号后，进入就绪态。
3.4.11.2、进程各种状态之间的转换图(百度)
进程刚fork出来的时候默认是进入就绪态的，运行，僵尸态，回收。
进程调度的时候，linux操作系统是按照一定的时间片来调度的
补充： 时间片，简单说来，就是CPU分配给各个程序的运行时间，使各个程序从表面上看是同时进行的，而不会造成CPU资源浪费。
总结：之所以进程之间要来回切换，操作系统要有这么多的CPU就是为了尽量充分的利用CPU的资源。
3.4.11.3、system函数简介 ： system这个函数是系统调用。类似于再cmd窗口中执行，其参数是可执行的命令.
(1)system函数 = fork+exec
(1)system函数是原子操作。原子操作意思就是整个操作一旦开始就会不被打断的执行完。原子操作的好处就是不会被人打断（不会引来竞争状态），坏处是自己单独连续占用CPU时间太长影响系统整体实时性，因此应该尽量避免不必要的原子操作，就算不得不原子操作也应该尽量原子操作的时间缩短。
(2)使用system调用ls
代码示例：
#include <stdlib.h>
#include<stdio.h>
int main()
{
int i;
i=system("ls -al");
return 0;
}
-----------------------------------------------------------------------------------------------------------------------------------------------------------
3.4.12.进程关系(百度一下)
(1)无关系
(2)父子进程关系
(3)进程组（group）由若干进程构成一个进程组，希望这些进程之间的关系更加亲近一些，更方便管理一些。
(4)会话（session）会话就是进程组的组(相当于一个班级单位)
属于不同会话的进程是没有关系的。
3.4.13.守护进程的引入
3.4.13.1、进程查看命令ps
(1)ps -ajx 偏向显示进程各种有关的ID号
(2)ps -aux 偏向显示进程各种占用资源
3.4.13.2、向进程发送信号指令kill
(1)kill -信号编号 进程ID，向一个进程发送一个信号
(2)kill -9 xxx，将向xxx这个进程发送9号信号，也就是要结束进程
3.4.13.3、何谓守护进程(后台程序)
(1)daemon，表示守护进程，简称为d（进程名后面带d的基本就是守护进程）
(2)长期运行（一般是开机运行直到关机时关闭）
(3)与控制台(终端)脱离（普通进程都和运行该进程的控制台相绑定，表现为如果终端被强制关闭了则这个终端中运行的所有进程都被会关闭，背后的问题因素还在于会话，因为一个终端里面所有运行的进程的代表-----会话被关闭了）
(4)服务器（Server），服务器程序就是一个一直在运行的程序，可以给我们提供某种服务（譬如nfs服务器给我们提供nfs通信方式），当我们程序需要这种服务时我们可以调用服务器程序（和服务器程序通信以得到服务器程序的帮助）来进程这种服务操作。【服务器程序一般都实现为守护进程。】
守护进程属于应用层的东西，不是属于内核里。
3.4.13.4、常见守护进程
(1)syslogd，系统日志守护进程，提供syslog功能。 【ps -aux | grep "syslogd"】
(2)cron，cron进程用来实现操作系统的时间管理，linux中实现定时执行程序的功能就要用到cron。
3.4.14.编写简单守护进程
3.4.14.1、任何一个进程都可以将自己实现成守护进程（守护进程并不是一个特别的东西）
3.4.14.2、create_daemon函数要素(当一个进程只要调用create_daemon函数，就会使被调用的函数成为一个守护进程)
创建守护进程的主要步骤：
(1)子进程等待父进程退出
(2)子进程使用setsid函数创建新的会话期，脱离控制台
(3)调用chdir函数将当前进程工作目录设置为/ 【chdir("/");】
(4)umask设置为0以取消任何文件权限屏蔽,使得进程具有最大的权限 【umask(0);】
(5)关闭所有文件描述符，变成守护进程后其他打开的文件描述符就没什么用了。
(6)将0、1、2三个文件描述符定位到/dev/null(也就是把这个进程的标准输入、标准输出和标准出错信息全部绑定到/dev/null)
代码示例：守护进程代码示例：
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <signal.h>
void my_daemon() {
int pid, fd;
// 1.转变为后台进程
if ((pid = fork()) == -1) exit(1);
if (pid != 0) exit(0); // 父进程（前台进程）退出
// 2.离开原先的进程组，会话
if (setsid() == -1) exit(1); // 开启一个新会话
// 3.禁止再次打开控制终端
if ((pid = fork()) == -1) exit(1);
if (pid != 0) exit(0); // 父进程（会话领头进程）退出
// 4.关闭打开的文件描述符，避免浪费系统资源
for (int i = 0; i < NOFILE; i++)
close(i);
// 5.改变当前的工作目录，避免卸载不了文件系统
if (chdir("/") == -1) exit(1);
// 6.重设文件掩码，防止某些属性被父进程屏蔽
if (umask(0) == -1) exit(1);
// 7.重定向标准输入，输出，错误流，因为守护进程没有控制终端
if ((fd = open("/dev/null", O_RDWR)) == -1) exit(1); // 打开一个指向/dev/null的文件描述符
dup2(fd, STDIN_FILENO);
dup2(fd, STDOUT_FILENO);
dup2(fd, STDERR_FILENO);
close(fd);
// 8.本守护进程的子进程若不需要返回信息，那么交给init进程回收，避免产生僵尸进程
if (signal(SIGCHLD, SIG_IGN) == SIG_ERR) exit(1);
}
#define INTERVAL 2
int main(int argc, char *argv[]) {
my_daemon(); // 首先使之成为守护进程
int t = 0;
FILE *fp = fopen("/root/tmp.txt", "a");
fprintf(fp, "ppid = %d, pid = %d, sid = %d, pgrp = %d\n", getppid(), getpid(), getsid(0), getpgrp());
fflush(fp);
do { // 测试此后台进程，每INTERVAL秒打印当前时间t，30秒后退出此后台进程
fprintf(fp, "%d\n", t);
fflush(fp); // 输出缓冲区内容到文件中
sleep(INTERVAL);
t += INTERVAL;
} while(t < 30);
fclose(fp);
return 0;
}
保存为daemon.c
编译命令 gcc daemon.c
运行 ./a.out
查看tmp.txt文件内容 cat /root/tmp.txt
3.4.15.使用syslog来记录调试信息 【man 3 syslog】
3.4.15.1、openlog、syslog、closelog
3.4.15.2、各种参数
3.4.15.3、编程实战
(1)一般log信息都在操作系统的/var/log/messages这个文件中存储着，但是ubuntu中是在/var/log/syslog文件中的。
3.4.15.4、syslog的工作原理
(1)操作系统中有一个守护进程syslogd（开机运行，关机时才结束），这个守护进程syslogd负责进行日志文件的写入和维护。
(2)syslogd是独立于我们任意一个进程而运行的。我们当前进程和syslogd进程本来是没有任何关系的，但是我们当前进程可以通过调用openlog打开一个和syslogd相连接的通道，然后通过syslog向syslogd发消息，然后由syslogd来将其写入到日志文件系统中。
(3)syslogd其实就是一个日志文件系统的服务器进程，提供日志服务。任何需要写日志的进程都可以通过openlog/syslog/closelog这三个函数来利用syslogd提供的日志服务。这就是操作系统的服务式的设计。
3.4.16.让程序不能被多次运行
3.4.16.1、问题
(1)因为守护进程是长时间运行而不退出，因此./a.out执行一次就有一个进程，执行多次就有多个进程。
(2)这样并不是我们想要的。我们守护进程一般都是服务器，服务器程序只要运行一个就够了，多次同时运行并没有意义甚至会带来错误。
(3)因此我们希望我们的程序具有一个单例运行的功能。意思就是说当我们./a.out去运行程序时，如果当前还没有这个程序的进程运行则运行之，如果之前已经有一个这个程序的进程在运行则本次运行直接退出（提示程序已经在运行）。
3.4.16.2、实现方法：
(1)最常用的一种方法就是：用一个文件的存在与否来做标志。具体做法是程序在执行之初去判断一个特定的文件是否存在，若存在则标明进程已经在运行，若不存在则标明进程没有在运行。然后运行程序时去创建这个文件。当程序结束的时候去删除这个文件即可。
(2)这个特定文件要古怪一点，确保不会凑巧真的在电脑中存在的。
守护进程
进程间通信/进程同步
（1）linux进程间通信的主要方式：
（2）
- 管道(PIPE)机制。在Linux文本流中，我们提到可以使用管道将一个进程的输出和另一个进程的输入连接起来，从而利用文件操作API来管理进程间通信。在shell中，我们经常利用管道将多个进程连接在一起，从而让各个进程协作，实现复杂的功能。
- 传统IPC (interprocess communication)。我们主要是指消息队列(message queue)，信号量(semaphore)，共享内存(shared memory)。这些IPC的特点是允许多进程之间共享资源，这与多线程共享heap和global data相类似。由于多进程任务具有并发性 (每个进程包含一个进程，多个进程的话就有多个线程)，所以在共享资源的时候也必须解决同步的问题 (参考Linux多线程与同步)。
- （3） 进程间通信（IPC：InterProcess Communication)
- (4)管道包括有名管道和无名管道两种，其中无名管道用于父子进程之间的通信，而有名管道用于任何两个进程之间的通信。
1、无名管道由pipe（）函数创建：
#include <unistd.h>
int pipe(int fd[2])；
参数fd为整数数组名，管道创建成功后系统为管道分配的两个文件描述符将通过这个数组返回到用户进程中： fd[0]为读而打开， fd[1]为写而打开。 fd [1]的输出是 fd[0]的输入。
无名管道不能保证写入的原子性，需要注意的是向管道中写入数据时，必须关闭管道的读取端，反之，从管道中读取数据时，也必须关闭管道的写端,代码示例：
#define INPUT 0
#define OUTPUT 1
void main() {
int file_descriptors[2];
/*定义子进程号 */
pid_t pid;
char buf[256];
int returned_count;
/*创建无名管道*/
pipe(file_descriptors);
/*创建子进程*/
if((pid = fork()) == -1) {
printf("Error in fork/n");
exit(1);
}
/*执行子进程*/
if(pid == 0) {
printf("in the spawned (child) process.../n");
/*子进程向父进程写数据，关闭管道的读端*/
close(file_descriptors[INPUT]);
write(file_descriptors[OUTPUT], "test data", strlen("test data"));
exit(0);
} else {
/*执行父进程*/
printf("in the spawning (parent) process.../n");
/*父进程从管道读取子进程写的数据，关闭管道的写端*/
close(file_descriptors[OUTPUT]);
returned_count = read(file_descriptors[INPUT], buf, sizeof(buf));
printf("%d bytes of data received from spawned process: %s/n",
returned_count, buf);
}
}
2、有名管道： 在Linux系统下，有名管道可由两种方式创建：命令行方式mknod系统调用和函数mkfifo。下面的两种途径都在当前目录下生成了一个名为myfifo的有名管道：
方式一：mkfifo("myfifo","rw");
方式二：mknod myfifo p
生成了有名管道后，就可以使用一般的文件I/O函数如open、close、read、write等来对它进行操作。
删除命名管道的方法是：int unlink(const char *pathname);pathname是要删除的命名管道的全路径。
代码示例：
/* 进程一：读有名管道*/
#include <stdio.h>
#include <unistd.h>
void main() {
FILE * in_file;
int count = 1;
char buf[80];
in_file = fopen("mypipe", "r"); //在这里设置为默认的阻塞方式
if (in_file == NULL) {
printf("Error in fdopen./n");
exit(1);
}
while ((count = fread(buf, 1, 80, in_file)) > 0)
printf("received from pipe: %s/n", buf);
fclose(in_file);
}
/* 进程二：写有名管道*/
#include <stdio.h>
#include <unistd.h>
void main() {
FILE * out_file;
int count = 1;
char buf[80];
out_file = fopen("mypipe", "w"); //在这里设置为默认的阻塞方式
if (out_file == NULL) {
printf("Error opening pipe.");
exit(1);
}
sprintf(buf,"this is test data for the named pipe example/n");
fwrite(buf, 1, 80, out_file);
fclose(out_file);
}
3、消息队列： 消息队列用于运行于同一台机器上的进程间通信，它和管道很相似，是一个在系统内核中用来保存消息的队列，它在系统内核中是以消息链表的形式出现。消息链表中节点的结构用msg声明。
事实上，它是一种正逐渐被淘汰的通信方式，我们可以用流管道或者套接口的方式来取代它，所以，我们对此方式也不再解释，也建议读者忽略这种方式。
4、共享内存：就是多个进程将同一块内存区域映射到自己的进程空间中，以此来实现数据的共享和传输。
第一步：创建共享内存：
首先要用的函数是shmget，它获得一个共享存储标识符。
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
int shmget(key_t key, int size, int flag);
其中第一个参数是：共享内存的键值，可以由用户指定，也可以调用ftok()来生成
第二个参数是：共享内存的大小
第三个参数是：创建共享内存并设定其存取权限
代码示例：
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <stdlio.h>
#include <unistd.h>
#define SHM_SIZE 1024
int main()
{
int shmid;
key_t key;
key=ftok(); // key_t ftok( char * fname, int id ) 生成共享内存的键值 fname就是你指定的文件名（已经存在的文件名），一般使用当 //前目录，如：key_t key;key = ftok(".", 1); 这 样就是将fname设为当前目录。
if(key < 0)
{
perrror("ftok error\n");
exit(1);
}
shmid = shmget(key,SHM_SIZE,IPC_CREAT | 0666 ); //创建一块共享内存
if(shmid < 0)
{
perrror("shmget error\n");
exit(1);
}
else {
printf(""创建共享内存完成！\n);}
return 0;
}
创建 完共享内存后使用ipcs -m命令来查看系统中的共享内存。
第二步：读写共享内存：在读写之前必须使用shmat()函数将共享内存映射到进程的地址空间中才可以进行访问。
void *shmat(int shmid, void *addr, int flag);
shmid为shmget函数返回的共享存储标识符，addr和flag参数决定了以什么方式来确定连接的地址，函数的返回值即是该进程数据段所连接的实际地址，进程可以对此进程进行读写操作。使用共享存储来实现进程间通信的注意点是对数据存取的同步，必须确保当一个进程去读取数据时，它所想要的数据已经写好了。通常，信号量被要来实现对共享存 储数据存取的同步，另外，可以通过使用shmctl函数设置共享存储内存的某些标志位如SHM_LOCK、SHM_UNLOCK等来实现。