前言

在《关于进程创建分析》一文中，对一些linux命令以及进程创建、进程状态做了讲解，还做了几个小lab。在本篇文章中，将继续延续上篇文章的知识，讲解一些文件操作指令并做一些小lab。

解决僵尸问题

• wait()函数是为了回收资源
• wait for process to change state

1）父进程还在，并且主动回收子进程资源

• pid_t wait (int *status)
• status：获取子进程的退出状态

如果这里是：wait（NULL），代表父进程只回收资源，不关心子进程退出状态。

• int x；
• wait(stdio.h>#include unistd.h>#include stdlib.h>#include sys/wait.h>int main(int argc,char *argv[]){pid_t x;x = fork();if(x>0){sleep(3);printf("3s:I was father ,i will wait my child\n");wait(NULL);printf("I have wait my child\n");}if(x==0){sleep(8);printf("I will death in 8s\n");}}

  
  2）子进程工作时间短，父进程工作时间长

  这种情况会出现僵尸进程问题。

  #include stdio.h>#include unistd.h>#include stdlib.h>#include sys/wait.h>int main(int argc,char *argv[]){pid_t x;x = fork();if(x>0){sleep(8);printf("8s:I was father ,i will wait my child\n");wait(NULL);printf("I  have wait my child\n");}if(x==0){sleep(3);printf("I will death in 3s\n");}}

  

  可以看到这里是有僵尸程序的。

  3）父进程还在，不主动回收子进程资源

  子进程等到父进程退出为止，在寻求一个新的父亲作为父进程，帮自己回收资源。

  #include stdio.h>#include unistd.h>#include stdlib.h>#include sys/wait.h>int main(int argc,char *argv[]){pid_t x;x = fork();if(x>0){sleep(8);printf("8s:I was father ,i will wait my child\n");printf("I  have wait my child\n");}if(x==0){sleep(3);printf("I will death in 3s\n");}}

  4） 子进程的退出状态如何返回给父亲

  子进程在退出时，需要调用一个函数，就可以把退出状态返回给父进程。

  exit()_Exit()_exit()

  这三个函数都可以使得进程退出，并且可以将退出状态返回给父进程。

  exit()先清洗缓冲区，再退出。

  导致普通进程结束：

  #includestdlib.h>void exit(int status)

  参数：

  • status ：0表示正常退出
  • 非0表示异常退出
  • Exit(),exit() 不清洗缓冲区，直接退出

  子进程退出状态问题

  例题：父进程去回收子进程的资源，子进程正常退出，输出 ok，异常退出，输出err

  #include stdio.h>#include stdlib.h>#include unistd.h>#include sys/wait.h>int main(int argc,char *argv[]){pid_t x;x = fork();if(x>0){sleep(1);wait(if(state==0){printf("ok");}else{printf("err");  }}if(x==0)

  

  {sleep(6);exit(0);}}

  
  程序中，调用exit（）函数与执行return语句有什么区别?

  • 如果在main函数中，exit与return语句作用是一样的。
  • 如果不在main函数中，exit就代表进程的退出，return 语句只是代表函数的返回。

  扇形进程个数问题

  #include stdio.h>#include unistd.h>#include stdlib.h>#include sys/wait.h>int main (int argc ,char *argv[]){int n;printf("process mount :\n");scanf("%d",int i;pid_t x;//chanshengfor(i=0;in;i++){x = fork();if(x>0){continue;  }if(x==0){break;}}if(x>0){for(i=0;in;i++){wait(NULL);  }printf("parent pid=%d\n",getpid());}if(x==0){printf("child pid = %d\n",getpid());exit(0);}}

  

  exec函数族

  • exec函数组接口
  • exec 执行
  • exec函数族，指的是一堆可以帮我们执行程序的函数

  execute a file #include unistd.h>extern char **environ;int execl(const char *pathname, const char *arg, .../* (char  *) NULL */);int execlp(const char *file, const char *arg, .../* (char  *) NULL */);int execle(const char *pathname, const char *arg, .../*, (char *) NULL, char *const envp[] */);int execv(const char *pathname, char *const argv[]);int execvp(const char *file, char *const argv[]);int execvpe(const char *file, char *const argv[],char *const envp[]);

  path：需要执行的那个程序的绝对路径

  arg：以“,”分开所有参数，以NULL，作为结束标志（直接作为形参）

  file：程序的文件名

  argv：以”，“分开所有参数，以NULL作为结束标志（先放到一个数组中，再把数组作为形参）

  envp：环境变量的路径

  例题：让子函数实现ls -l操作

  #include stdio.h>#include unistd.h>#include stdlib.h>#include sys/wait.h>int main(int argc,char *argv[]){pid_t x;x= fork();if(x>0){sleep(2);wait(NULL);exit(0);}if(x==0){execl("/bin/ls","ls","-l",NULL);}return 0;}

  结论：只要执行了exec函数族，那么进程后面的代码会被覆盖。

  

  可以看到并没有printf出。

  如何确保子进程先运行？

  vfork()NAMEvfork - create a child process and block parentSYNOPSIS#include sys/types.h>#include unistd.h>  pid_t vfork(void);

  fork是随机运行，vfork是父进程阻塞。

  当子进程中调用exit（）函数后者是exec函数族中的接口时，就会开始运行父进程的代码。

  #include stdio.h>#include unistd.h>#include stdlib.h>#include sys/wait.h>int main(int argc,char *argv[]){pid_t x;x = vfork();if(x>0){printf("my child\n");}if(x==0){sleep(3);printf("child\n");execl("/bin/ls","ls","-l",NULL);}      }

  

  父子进程之间的资源问题

  

  

  进程之间的通信：

  进程之间的资源是分开的，进程之间的资源没有办法进行交换。

  linux下，有多少通信方式？

  一共有4种：

  • 管道通信：无名管道与有名管道。是一种专门用于通信的文件，一个进程往管道文件中写入，一个进程从管道文件中读出数据。
  • 信号：通过发送一些信号给进程，那么这个进程会转换为相应的状态。
  • 消息队列：一个进程负责将消息发送到队列上，另一个进程可以从消息队列中读取数据出来。读取消息的进程可以读取队列上某一个特定的数据。
  • 共享内存：两个进程使用同一片内存空间进行数据交换。 

  什么是无名管道？

  • 无名管道实际是一个数组，所以只能运行于一个文件中。
  • 只能作用于亲缘关系的进程，例如：父子进程。

  实现步骤：

  1. 申请一个数组：读端和写段是一个文件描述符，数组应该定义为：int fd[2]，现在只是定义了数组。
  2. 使用函数接口来初始化数组，使得数组的元素变成读端和写端。

  NAMEpipe, pipe2 - create pipeSYNOPSIS#include unistd.h>

  返回值：

  成功0

  失败-1

  初始化成功

  结果：

  fd[0]-->读端

  fd[1]-->写端

  初始化的读端与写端文件描述符等于多少？

  pipefd：一个具有2个int类型变量的数组。

  例题：初始化的读端与写端的文件描述符

  #include stdio.h>#include unistd.h>#include stdlib.h>#include sys/wait.h>int main(int argc,char *argv[]){int fd[2]={0};printf("fd[0]=%d\n",fd[0]);printf("fd[1]=%d\n",fd[1]);pipe(fd);printf("fd[0]=%d\n",fd[0]);printf("fd[1]=%d\n",fd[1]);return 0;}

  

  总结

  进程这部分内容，是有很多值得研究的东西，还有资源共享、互斥、同步、锁等有关问题，使得用户使用更加方便。