1.进程相关概念

程序和进程

程序是静态的概念，gcc xx.x -o pro,磁盘中生成的pro就是程序。

进程是程序的一次运行活动，通俗的讲就是程序跑起来了，系统中就多了一个进程。

查看系统中的进程

ps指令

查看系统中所有进程

ps -aux

结果：

查看系统中的init进程

ps -aux | grep init

结果：

即把ps -aux指令所有输出的结果通过管道导向grep进行搜索，查找init关键字的文本

-aux 显示所有包含其他使用者的进程
|管道符号
grep 用于查找文件里符合条件的字符串

top指令

类似windows的任务管理器，数据也是实时动态变化的。

进程标识符 使用getpid()获取

每一个进程都有一个非负整数标识唯一的ID，即为pid。

调用getpid()获取自身进程标识符，getppid()获取获取父进程标识符

其中系统所占用的进程标识符如下：

pid	进程名称	作用	说明
pid = 0	交换进程	用于进程调度	所有“同时”在运行的程序所占用的资源受到进程调度的影响
pid = 1	init进程	用于系统初始化	程序运行，内核加载完毕，文件系统起来的第一个进程就是init进程，读取配置文件然后再启动其他进程。（如ktv点歌机开机后看到的是点歌界面，而不是字符界面）

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>int main()
{//pid_t getpid(void);pid_t pid;pid=getpid();printf("我的pid是：%d\n",pid);return 0;
}

父进程，子进程

进程A创建了进程B，A就是父进程，B就是子进程

2.创建进程fork

pid_t fork(void);

fork函数调用成功，返回两次：返回值为0，代表当前进程是子进程，非负数为父进程，如果调用失败则返回-1
创建子进程的目的：复制父进程（此时两个或两个以上进程），父进程等待客户端服务请求，当这种请求到达时，父进程调用fork,让子进程去处理（QQ服务器 客户端 结合Socket网络编程）

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>int main()
{pid_t pid;pid =  getpid();fork();//此处开始，后面所有代码执行了两次 //fork()有两个返回值printf("my pid is %d\n",pid);return 0;
}

返回两次：

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>int main()
{pid_t pid;pid =  getpid();fork();printf("my pid is %d,current pro id:%d\n",pid,getpid());return 0;
}                                    

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>int main()
{pid_t pid;pid =  getpid();fork();if(pid == getpid()){printf("this is father print\n");}else{printf("this is child print,child pid = %d\n",getpid());}return 0;
}                                                                                                                                                                                                              

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>int main()
{pid_t pid;printf("father: pid = %d\n",getpid());pid =  fork();if(pid > 0){printf("this is father print, pid = %d\n",getpid());}else if(pid == 0){printf("this is child print,child pid = %d\n",getpid());}return 0;
}

应用场景（模拟网络等待）：

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>int main()
{pid_t pid;int data;while(1){printf("please input a data\n");scanf("%d",&data);if(data == 1){pid = fork();if(pid > 0){}else if(pid == 0){while(1){printf("do net request,pid=%d\n",getpid());sleep(3);}}}else{printf("wait, do nothing\n");}}return 0;
}

进程创建发生了什么——C程序的存储空间如何分配

详细参照博文：内存四区（代码区 静态区 栈区 堆区）

fork创建进程，所有的东西都进行了拷贝，包括全局变量、局部变量、代码等，各进程内改变变量的值互不影响。

详细说明：

3.创建进程vfork(区别fork)

vfork与fork的区别：
1.（共用）vfork直接使用父进程的存储空间，不拷贝（随着内核的发展，fork目前执行的是写时拷贝—copy on write 若子进程未改变原始变量的值时不会进行拷贝）
2.（等待）vfork保证子进程先运行，当子进程调用exit退出后，父进程才执行

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>int main(){int cnt=0;pid_t pid;pid_t repid;pid=getpid();repid=vfork();if(repid > 0){while(1){printf("cnt=%d\n",cnt);printf("this is father pid,repid=%d\n",repid);sleep(1);}}else if(repid == 0){while(1){printf("this is child pid,repid=%d\n",repid);sleep(1);cnt++;if(cnt==2){exit(0);}}}return 0;
}

运行结果：

4.进程退出

正常退出

1.main函数调用return

2.进程调用exit(),标准C库

3.进程调用_exit()或者_Exit(),系统调用

4.进程最后一个线程返回

5.最后一个线程调用pthread_exit

异常退出

1.调用abort

2.当进程收到某些信号时，如ctrl+c

3.最后一个线程对取消（cancellation）请求作出响应

注意：不管进程如何终止，最后都会执行内核中的同一段代码，这段代码为相应进程关闭所有打开描述符，释放它所使用的存储器等。

5.父进程等待子进程退出

父进程收集子进程退出状态(僵尸进程)

父进程等待子进程退出并收集子进程退出状态
子进程退出状态不被收集，会变成僵尸进程

僵尸进程的例子：

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>int main()
{pid_t pid;int i;int cnt=0;pid=fork();if(pid > 0){//父进程while(1){printf("这是父进程,pid=%d\n",getpid());printf("cnt=%d\n",cnt);sleep(2);//防止刷屏}	}else if(pid == 0){//子进程for(i=0;i<5;i++){//看看是不是保证子进程先运行，五次过后推出进入父进程printf("这是子进程,pid=%d，这是第%d次\n",getpid(),i+1);cnt++;sleep(1);//防止刷屏}exit(-1);}return 0;
}

此时运行的结果是子进程退出了，但是退出状态没有被收集，子进程成了僵尸进程(zomb)。

等待退出函数wait()

wait(int *status):
status参数，他是一个整型数指针。
非空：子进程退出状态放在它所指向的地址
空(NULL)：不关心退出状态

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>int main()
{pid_t pid;int i;int cnt=0;int status;pid=fork();if(pid > 0){//父进程wait(&status);printf("子进程退出，status:%d\n",WEXITSTATUS(status));//WEXITSTATUS()是解析子进程退出码的宏，下面有详细介绍while(1){printf("这是父进程,pid=%d\n",getpid());printf("cnt=%d\n",cnt);sleep(2);//防止刷屏}	}else if(pid == 0){//子进程for(i=0;i<5;i++){//看看是不是保证子进程先运行，五次过后推出进入父进程printf("这是子进程,pid=%d，这是第%d次\n",getpid(),i+1);cnt++;sleep(1);//防止刷屏}exit(3);//退出码返回给父进程中的wait进行收集}return 0;
}

解析出wait()对子进程退出码回收的宏

等待退出函数waitpid()

来个例子：

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>int main()
{pid_t pid;int i;int cnt=0;int status;pid=fork();if(pid > 0){//父进程waitpid(pid,&status,WNOHANG);//WNOHANG不阻塞printf("子进程退出，status:%d\n",WEXITSTATUS(status));while(1){printf("这是父进程,pid=%d\n",getpid());printf("cnt=%d\n",cnt);sleep(2);//防止刷屏}}else if(pid == 0){//子进程for(i=0;i<5;i++){//看看是不是保证子进程先运行，五次过后推出进入父进程printf("这是子进程,pid=%d，这是第%d次\n",getpid(),i+1);cnt++;sleep(1);//防止刷屏}exit(3);}return 0;
}

结果如下所示，发现子进程也变为僵尸进程。

父进程先于子进程退出(孤儿进程)

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

例子：

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>int main()
{pid_t pid;int i;int status;int cunt=0;pid=fork();if(pid > 0){printf("这是父进程,pid=%d\n",getpid());printf("cunt=%d\n",cunt);sleep(2);}else if(pid == 0){for(i=0;i<5;i++){printf("这是子进程,pid=%d,我的父进程的pid=%d\n",getpid(),getppid());cunt++;sleep(2);}exit(3);}return 0;
}

运行结果：

最后再来一个综合的例子：

6.exec族函数(让子进程调用其他程序)

参照博文：https://blog.csdn.net/u014530704/article/details/73848573

execl，execlp

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>int main(){//int execl(const char *path, const char *arg, .../* (char  *) NULL */);
/*      path：可执行文件的路径名字arg：可执行程序所带的参数，第一个参数为可执行文件名字，没有带路径且arg必须以NULL结束file：如果参数file中包含/，则就将其视为路径名，否则就按 PATH环境变量，在它所指定的各目录中搜寻可执行文件exec族函数参数极难记忆和分辨，函数名中的字符会给我们一些帮助：l : 使用参数列表p：使用文件名，并从PATH环境进行寻找可执行文件v：应先构造一个指向各参数的指针数组，然后将该数组的地址作为这些函数的参数。e：多了envp[]数组，使用新的环境变量代替调用进程的环境变量exec函数族的函数执行成功后不会返回，调用失败时，会设置errno并返回-1，然后从原程序的调用点接着往下执行。 
*/printf("before execl\n");if(execl("/bin/ls","ls",NULL,NULL) == -1)//通过whereis指令找到ls命令的位置{printf("execl failed!\n");perror("why");}printf("after execl\n");return 0;
}
int main(){//int execlp(const char *file, const char *arg, .../* (char  *) NULL */);printf("before execl\n");if(execlp("ls","ls","-l",NULL) == -1)//不用找到命令的路径{printf("execl failed!\n");perror("why");}printf("after execl\n");return 0;
}

运行结果：

通过whereis指令查找ls、date（获取系统时间）系统指令的位置：

execv execvp

int main(){//int execv(const char *path, char *const argv[]);      char* argv[]={"ls",NULL,NULL};if(execv("/bin/ls",argv) == -1){printf("execl failed!\n");perror("why");}printf("after execl\n");return 0;
}

int main(){// int execvp(const char *file, char *const argv[]);char* argv[]={"ls","-l",NULL};if(execvp("ls",argv) == -1){printf("execl failed!\n");perror("why");}printf("after execl\n");return 0;
}

exec配合fork使用

应用场景：在执行A程序的过程中让子进程去执行B程序

代码B（用来修改配置文件） 编译生成程序名为change

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/wait.h>int main()
{int fd;int n_write;int n_read;pid_t pid;char *readBuf;fd=open("test15.txt",O_RDWR);int size=lseek(fd,0,SEEK_END);//计算文件的大小lseek(fd,0,SEEK_SET);//光标重新到开头readBuf=(char *)malloc(sizeof(char)*size+8 );//+8防止溢出n_read=read(fd,readBuf,size);char *p=strstr(readBuf,"length=");if(p == NULL ){printf("没有找到\n");exit(-1);}p=p+strlen("length=");//指针往后移动大哦想要改的地方*p='9';//将里面的6改称9lseek(fd,0,SEEK_SET);n_write=write(fd,readBuf,strlen(readBuf));close(fd);exit(0);
}

代码A

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/wait.h>int main()
{int fd;int n_write;int n_read;pid_t pid;int data;char *readBuf;while(1){printf("请输入一个数\n");scanf("%d",&data);if(data == 1){printf("成功进入\n");pid=fork();if(pid > 0){//父进程wait(NULL);//防止子进程变成僵尸进程}if(pid == 0){//子进程execl("./change","change",NULL,NULL);//获取系统时间也能实现}}else{printf("等待输入正确的指令\n");}}return 0;
}

初始的test15.txt

运行程序A后

system函数

本质上是对execl函数的二次封装，可查看其源码。实际上比execl更好用
和execl区别：system执行完该函数后，还会继续执行后面的函数 ，而exec则不会。

#include <stdlib.h>
int system(const char *command);
system()函数返回值如下：
成功，则返回进程的状态值
当sh不执行时，返回127；//shell脚本
失败返回 -1

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>int main(){pid_t pid;pid_t repid;int data;while(1){printf("please input a number:");scanf("%d",&data);if(data==1){repid=fork();//创建进程if(repid > 0){wait(NULL);}if(repid == 0){//execl("./changeNumToFile.out","changeNumToFile.c","changeNum.c",NULL);system("./changeNumToFile.out");//执行完该函数后，还会执行后面的函数  exec就不会回来继续执行后面代码了，除非execl出错返回-1exit(0);}}else{printf("waiting!\n");}}return 0;

popen函数

比system在应用中的好处：可以获取运行的输出结果

#include <stdio.h>
FILE *popen(const char *command, const char *type);
int pclose(FILE *stream);

#include <stdio.h>
#include <stdlib.h>//      FILE *popen(const char *command, const char *type);
//       FILE *fopen(const char *path, const char *mode);
//      size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
int main(){//      system("ls");FILE* fp;char ret[1024];fp=popen("ls -l","r");int n_read=fread(ret,1,1024,fp);if(n_read != -1){printf("read sucess!\n");printf("return n_read=%d,read data=%s\n",nread,ret);}else{printf("no read datas\n");}return 0;
}