linux就该这么学【进程控制】

进程创建

fork函数初识fork函数返回值写时拷贝进程终止

exit函数_exit函数进程等待

进程等待的方法

wait方法waitpid方法获取子进程status总结：进程程序替换

替换函数函数解释命名理解使用exel发生有趣的现象exec系列的函数使用制作简易shell

进程创建 fork函数初识

在linux中fork函数是非常重要的函数，它从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程

#include   //fork所在头文件
pid_t fork(void);  //fork函数原型

fork创建子进程是以父进程为“模板”的，
fork的返回值：给子进程中返回0，给父进程返回子进程id，创建子进程失败出错返回-1

进程调用fork，当控制转移到内核中的fork代码后，内核做：

分配新的内存块和内核数据结构给子进程将父进程部分数据结构内容拷贝至子进程添加子进程到系统进程列表当中fork返回，开始调度器调度

当一个进程调用fork之后，就有两个二进制代码相同的进程。而且它们都运行到相同的地方。但每个进程都将可以开始它们自己的旅程，看如下程序

[mzt@VM-16-4-centos mzt]$ ./proc
I am a process：29208    
//程序开始执行，先打印的进程id就行主进程的pid
I am a parent：29208  my son id：29209  
//主进程创建子进程，给子进程返回29209
I am a child：29209  my returnval：0  
//子进程pid为29209，fork调用完后给子进程返回0。

[mzt@VM-16-4-centos mzt]$ cat proc.cc
#include 
#include 
using namespace std;

int main()
{

    cout << "I am a process：" << getpid() << endl; //获取父进程的id
    pid_t id = fork();  //父进程创建子进程，并返回进程id
    if(id < 0) 
    {
       cout << "子进程创建失败" << endl;
    }
    else if(id == 0) 
    {
        //child
        cout << "I am a child：" << getpid() << "  my returnval：" << id << endl; 
        sleep(5);
    }
    else
    {
       //parent
       cout << "I am a parent："<< getpid() << "  my son id：" << id << endl;
   
       sleep(5);
    }
  return 0;
}

程序运行结果：

从程序的运行结果可以看出fork之前只会打印主进程的pid，直到执行完fork之后，第2行显示了父进程的pid是29208、而他的子进程的pid确是29209，因为主进程的pid为29208，当fork执行完之后会给父进程返回子进程的pid，对应的显示结果就是my son id：29209，我们都知道fork之后是会分执行流的，而前面仅仅只是讲了父进程的情况（主进程），接下来介绍的第三行就是子进程的情况了，fork执行完会给子进程返回0。但是奇怪的是在fork之前明明主进程还会打印I am a process：29208 怎么重新创建的子进程并没有打印这句话呢？

当主进程（父进程）执行完fork之后，来到到after的位置，因为子进程是以父进程为模板的，所有拷贝过去的时候，子进程也拿到了数据（包括程序计数器）那么可以推断子进程和父进程一样也会从after位置处开始执行，也就是父进程创建完子进程后，父子进程都从fork之后的代码开始执行。

总结：
fork之前父进程是独立执行的，而fork之后主进程和子进程会分别执行，而fork之后谁先执行完全由调用器决定！谁先被调度谁先执行！

fork函数返回值

fork函数为什么要给子进程返回0，给父进程返回子进程的PID？

一个父进程可以创建多个子进程，而一个子进程只能有一个父进程。因此，对于子进程来说，父进程是不需要被标识的；而对于父进程来说，子进程是需要被标识的，因为父进程创建子进程的目的是让其执行任务的，父进程只有知道了子进程的PID才能很好的对该子进程指派任务。

为什么fork函数有两个返回值？

父进程调用fork函数后，为了创建子进程，fork函数内部将会进行一系列操作，包括创建子进程的进程控制块、创建子进程的进程地址空间、创建子进程对应的页表等等。子进程创建完毕后，操作系统还需要将子进程的进程控制块添加到系统进程列表当中（这一部分操作会又系统内核去做），此时子进程便创建完毕了。

也就是说，在fork函数内部执行return语句之前，子进程就已经创建完毕了，那么之后的return语句不仅父进程需要执行，子进程也同样需要执行，这就是fork函数有两个返回值的原因。

默认情况下，父子进程共享代码，但是数据会保存一份，这个代码共享是所有的代码并不是fork之后的代码共享，并且父子进程会从fork之后的代码开始执行。

共享代码：我们都知道程序是由代码 + 数据组成的，而父进程创建子进程后，父子进程会共享代码，这个共享代码是不允许被修改的，那么为什么需要被共享呢？站在系统的角度是为了节省资源避免不必要的开销。数据之间为什么需要私有一份呢？因为进程之间具有独立性，当子进程需要使用数据时会从父进程那么拷贝一份数据（按需所取），是以写时拷贝的方式处理

写时拷贝

通常，父子代码共享，父子再不写入时，数据也是共享的，当任意一方试图写入，便以写时拷贝的方式各自一份副本。具体见下图

总结：
当父进程创建子进程后，父子进程除了代码是共享的，数据也是共享的(不修改的时候)，如果有任何一方需要修改数据那么他需要将数据拷贝一份再私有化（写时拷贝）并且这份数据只供本进程使用

问题：数据10M，写入的时候1M，发生写时拷贝，是拷贝10M还是1M?

操作系统站在节省资源的角度下，发生写时拷贝的时候会只拷贝1M，而剩下的9M也是共享的，写时拷贝是按需所取的（操作多少字节的数据就拷贝多少字节的数据）。操作系统的处理思维永远是站在使用最小空间和最高效率的处理方式。

fork常规用法

一个父进程希望复制自己，使父子进程同时执行不同的代码段。例如，父进程等待客户端请求，生成子进程来处理请求。一个进程要执行一个不同的程序。例如子进程从fork返回后，调用exec函数

fork调用失败的原因

系统中有太多的进程，实际用户的进程数超过了限制。进程终止

进程退出场景

代码运行完毕，结果正确代码运行完毕，结果不正确代码异常终止

进程常见退出方法

正常终止（可以通过 echo $? 查看进程退出码）：

从main返回

[mzt@VM-16-4-centos mzt]$ cat proc.cc
#include 
#include 
using namespace std;

int exe()
{
  return 123;
}

int main()
{
   cout << "hello linux" << endl;
   if(exe() > 0) return 0;  //正常退出
   else return -1;  //异常退出
   
   return 0;
}
[mzt@VM-16-4-centos mzt]$ ./proc
hello linux
[mzt@VM-16-4-centos mzt]$ echo $?
0
[mzt@VM-16-4-centos mzt]$

执行这个程序我们把return 0 表示正常退出，而return -1表示异常退出，最后程序执行结束，用echo $? 查看的返回码是0，那么就确定了程序是正常执行的。

调用exit

exit会终止整个进程，任何地方调用，都会终止进程，而return 叫做终止函数，并不能直接终止一个进程，而是终止一个函数，除非是main函数被return才代表的进程退出。

_exit

异常退出：

ctrl + c，信号终止 exit函数

#include 
void exit(int status);

exit最后也会调用_exit, 但在调用_exit之前，还做了其他工作：

执行用户通过 atexit或on_exit定义的清理函数。关闭所有打开的流，所有的缓存数据均被写入调用_exit

测试代码

[mzt@VM-16-4-centos mzt]$ cat proc.cc
#include 
#include 
#include 
using namespace std;

int exe()
{
  exit(123); //OS终止该进程	
}

int main()
{
    exe();
    return 0;
}
[mzt@VM-16-4-centos mzt]$ ./proc
[mzt@VM-16-4-centos mzt]$ echo $?
123   		//打印进程退出码

_exit函数

#include   //_exit存在这个头文件中
void _exit(int status);  
参数：status 定义了进程的终止状态，父进程通过wait来获取该值

说明：
虽然status是int，但是仅有低8位可以被父进程所用。所以_exit(-1)时，在终端执行$?发现返回值是255。

_exit 和 exit的区别

使用_exit时，只是做到终止进程的作用，并不会刷新缓冲区

使用exit() 函数会刷新缓冲区，并且会执行用户定义的清理函数

return退出

return是一种更常见的退出进程方法。执行return n等同于执行exit(n),因为调用main的运行时函数会将main的返回值当做 exit的参数。

进程等待

之前讲过，子进程退出，父进程如果不管不顾，就可能造成‘僵尸进程’的问题，进而造成内存泄漏。另外，进程一旦变成僵尸状态，那就刀枪不入，“杀人不眨眼”的kill -9 也无能为力，因为谁也没有办法杀死一个已经死去的进程。最后，父进程派给子进程的任务完成的如何，我们需要知道。如，子进程运行完成，结果对还是不对，或者是否正常退出。父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息

[mzt@VM-16-4-centos mzt]$ cat proc.cc
#include 
#include 
#include 
using namespace std;

int main()
{
    pid_t pid = fork();  
    if(pid == 0)  //子进程处理相关的业务
    {
      while(1){
        sleep(1);
        cout<< "child..." << endl;
        break;
      }
      exit(0);  //终止子进程
    }
    else
    {
      while(1){
        sleep(1);
        cout << "parent..." << endl;
        break;
      }
    }

    cout << "hello word" << endl;
    return 0;
}
[mzt@VM-16-4-centos mzt]$ ./proc 
parent...   
hello word
[mzt@VM-16-4-centos mzt]$ child...

从程序的运行结果可以看出当父进程创建子进程后，子进程打印完"child..." 就会直接被终止掉，父进程会继续执行else{} 的代码，并在最后打印"hello word"，

其实子进程被父进程创建出来后，父子进程的执行前后是由调度器管理的，而在退出的时候通常都是让子进程先退出，子进程先退出的好处：子进程一退出，父进程就能检测到子进程退出，父进程就可以通过进程等待的方式去回收子进程，子进程主要是为了处理业务的，所以需要让父进程帮子进程拿到执行的结果，所以子进程是需要被父进程等待的，等待方式：wait/waitpid

总结：
父进程创建子进程的目的在于让子进程完成某些业务，而为了让父进程能够拿到子进程的执行结果，这里需要让父进程以wait的方式等待子进程返回执行结果，其中父进程等待子进程的意义在于：1、回收资源， 2、得到子进程的执行结果（返回值）。

进程等待的方法

使用wait函数之前

#include 
#include 
#include 
#include 
using namespace std;

int main()
{
    pid_t pid = fork();  
    if(pid == 0)
    {
      int count = 0;
      while(1){
        sleep(1);
        cout<< "child...：" << count << endl;
        
        if(count >= 5){   //当子进程运行到5秒之后直接跳出循环
           break;
        }
        count++;
      }
      exit(0);  //终止子进程
    }
    else
    {
      int count = 0;
      while(1){
        sleep(1);
        cout << "parent...："<< count << endl;
        if(count == 10){   //父进程执行10秒后跳出循环，最后走完下面的逻辑直接终止
           break;
        }
        count++;
      }
    }

    cout << "hello word" << endl;
    return 0;
}

其实在子进程执行完5秒之后是已经被exit()了，那么在这个过程中由于父进程并没有获取到子进程的执行结果(返回值)，所以子进程在这个时候会进入僵尸状态，而当5秒过后父进程单独执行到第10秒最后打印hello word结束，其实整个进程执行的过程中是会存在内存泄漏的！！，因为子进程进入僵尸状态后就无法被父进程回收

wait方法

wait方法介绍

#include
#include
pid_t wait(int*status);
返回值：
 成功返回被等待进程pid，失败返回-1。
参数：
 输出型参数，获取子进程退出状态,不关心则可以设置成为NULL

测试代码:

#include 
#include 
#include 
#include 
using namespace std;

int main()
{
    pid_t pid = fork();  
    if(pid == 0)
    {
      int count = 10;
      while(count--){  
        sleep(1);
        cout<< "child...：" << count << endl;
        
        if(count >= 5){   //当子进程运行到5秒之后直接跳出循环
           break;
        }
      }
      exit(0);  //终止子进程
    }
    else if(pid > 0)
    {
        //父进程等待子进程
        wait(NULL); //防止子进程终止后,父进程没有获取到子进程的返回结果，而导致子进程出现僵尸状态
    }
    else { count << "子进程创建失败" < 
子进程执行5秒之后结束 ，父进程以wait方式等待子进程，将子进程回收，接受子进程的返回结果，最后打印hello word整个父进程执行完毕
  
waitpid方法 
pid_t waitpid(pid_t pid, int *status, int options);

参数：
//pid： waitpid需要等待的特定进程
//status：这是一个输出型参数，在等待子进程退出的时候，操作系统就会从进程
//PCB中读取退出信息，保存到status指针所指向的变量中去
//但是如果个status传递NULL，那么status就不会存放子进程的状态

//options：表示父进程等待子进程的方式，使用0值做参数默认以阻塞方式进行等待，
// 使用WNOHANG做参数父进程会以非阻塞状态进行等待子进程
 
 
返回值：
 当正常返回的时候waitpid返回收集到的子进程的进程ID；如果设置了选项WNOHANG,而调用中waitpid发现没有已退出的子进程可收集,则返回0； 如果调用中出错,则返回-1,这时errno会被设置成相应的值以指示错误所在；
  参数： 
  pid：
 1、 Pid=-1,等待任一个子进程。与wait等效。
 2、Pid>0.等待其进程ID与pid相等的子进程。status:
 1、WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出）会检测status所指向变量的低7位的比特位（因为包含了退出信号）
 2、WEXITSTATUS(status): 若WIFEXITED非零（进程正常退出），提取子进程退出码。（查看进程的退出码）提取退出码的方式是获取status所指向的变量的低8位的比特位所对应的值options:
 1、WNOHANG: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID。  
 
 如果子进程已经退出，调用wait/waitpid时，wait/waitpid会立即返回，并且释放资源，获得子进程退出信息。如果在任意时刻调用wait/waitpid，子进程存在且正常运行，则进程可能阻塞。如果不存在该子进程，则立即出错返回。 
 
获取子进程status 
wait和waitpid，都有一个status参数，该参数是一个输出型参数，由操作系统填充。 
如果传递NULL，表示不关心子进程的退出状态信息。否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程。status不能简单的当作整形来看待，可以当作位图来看待，具体细节如下图（只研究status低16比特位）： 
 
 
 补充知识：
 检查一个进程是不是被信号所杀，只需要看他的低7位表示的是不是0，如果是0的话表示该进程是正常退出的， 其中进程的第8位表示的是core dump标志，而进程的后8位也就是进程的退出状态(退出码)。 
 
验证status的测试代码： 
#include 
#include 
#include 
#include 
#include 
using namespace std;

int main()
{

  pid_t id = fork();
  if(id < 0){
    printf("fork errorn");
    return 1;
  }
  else if(id == 0) {
    int count = 3;
    while(count--){    //获取子进程pid
      printf("child[%d]: is runningn", getpid());  
      sleep(1);
    }
 
    exit(0);  //终止子进程返回退出码0
  } 


  //父进wait前
  printf("father wait beforen");
  
  int st = 0;  //记录子进程的退出信息
  pid_t ret = waitpid(id, &st, 0);
  if(ret > 0){
    printf("wait success!n");  //等待成功
    printf("st：%dn", st);  //打印子进程的退出信息
    printf("child exit signal：%dn", st & 0x7f); //打印子进程的退出信号
    printf("child exit code：%dn",(st >> 8) & 0xff);  //获取子进程的退出码
    
    if(st & 0x7f){   //获取子进程的低7位退出信号,如果返回值是非0表示的就不是正常退出
      printf("child run errorn");
    }
    else{     //else 表示子进程正常退出
      int code = ((st >> 8) & 0xff);   // 计算子进程的退出码
      if(code) printf(" child run success, but result is not right!：code : %dn" ,code); //退出码为非0值表示退出码不正确
      else printf("child run success, result is right! code :%dn", code);  //退出码为0值表示退出码正确
    }
  }
  else printf("wait failedn");  //等待失败
  
  
  //父进程wait后
  printf("father wait aftern");

  printf("程序执行完n");
  return 0;
}
 
程序运行结果：
  
使用系统调用WEXITSTATUS获取子进程的退出码 
#include 
#include 
#include 
#include 
#include 
using namespace std;

int main()
{

	 pid_t id = fork();
	 if(id < 0){
	   printf("fork errorn");
	   return 1;
	 }
	 else if(id == 0) {
	   int count = 3;
	   while(count--){    //获取子进程pid
	     printf("child[%d]: is runningn", getpid());  
	     sleep(1);
	   }
	
	   exit(0);  //终止子进程返回退出码0
	 } 
	
	
	 //父进wait前
	 printf("father wait beforen");
	 
	 int st = 0;  //记录子进程的退出信息
	 pid_t ret = waitpid(id, &st, 0);
	 if(ret > 0) {  //等待成功
	   if(WIFEXITED(st)) {  //判断子进程是否正常退出
	       printf("child exit success code:%dn", WEXITSTATUS(st));  //打印子进程的退出码
	   }
	 }
	else printf("wait failedn");  //等待失败
	 
	 
	 //父进程wait后
	 printf("father wait aftern");
	
	 printf("程序执行完n");
	 return 0;
}
 
程序运行结果
  
 
 第二种直接使用系统调用的好处就是更方便 
 
父进程以非阻塞方式等待子进程 
 
 需要注意的是如果父进程以非阻塞的方式等待子进程，那么options对应需要传递的参数就是WNOHANG，而以非阻塞的方式等待子进程，如果子进程没有exit()，那么waitpid()函数将会返回0值，而父进程就不会等待子进程，如果子进程正常exit()，那么waitpid就会返回子进程的退出码。 
 
#include 
#include 
#include 
#include 
#include 


using namespace std;


int main()
{
    pid_t id = fork();  
    if(id < 0){
      printf("child fork error n");
      return 0;
    }
    else if(id == 0){
        int count = 3;
        while(count--){
          sleep(1);
          printf("child[%d] is running...n",getpid() );
        }
        exit(0);  //子进程退出
    }
    //父进程以非阻塞方式等待子进程
	 do{
	      int st = 0;
	      pid_t ret = waitpid(id, &st, WNOHANG);
	      if(ret == 0){//waitpid返回值为0，表示子进程没有终止
	         printf("child is not exit n");
	         sleep(1); 
	         continue; 
	        
	      }
	      else if(ret > 0){  //waitpid返回值为子进程的id
	        if(WIFEXITED(st)){
	          printf("child is success exit code：%dn",WEXITSTATUS(st)); //打印子进程的退出码
	        }  
	        break;
	      }
	      else{  //waitpid 返回-1，表示进程等待失败
	          printf(" waitpid failedn");
	          break;
	      }
     } while(1);
	
	printf("father wait aftern");
    return 0;
}
 
程序运行结果： 
child is not exit 
child[19388] is running...
child is not exit 
child[19388] is running...
child is not exit 
child[19388] is running...
child is not exit        	  
child is success exit code：0   
father wait after
 
 
 直到子进程退出后，父进程就不需要再等待子进程了，waipid会将子进程的id返回 
 
总结： 
 
 wait是什么？ 
 
wait是父进程通过wait等系统调用，用来等待子进程状态的一种现象，这就叫做进程等待， 
 
 父进程为什么需要以wait的方式去等待子进程 
 
如果父进程不用wait去等待子进程，那么就会导致子进程发生僵尸进程，从僵尸进程进而引发的内存泄漏问题，无法读取子进程的退出信息 
 
 为了防止子进程发生僵尸问题我们需要怎么办？ 
 
让父进程使用wait/ waitpid等系统调用，以阻塞等待的方式等待子进程 
进程程序替换 
 
 首先我们都知道fork创建子进程：
 1、会让子进程执行父进程代码的一部分（因为子进程会和父进程共享代码）
 2、子进程执行属于自己的代码（需要用到进程程序替换的知识，涉及写时拷贝知识） 
 
替换原理
 用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支),子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时,该进程的用户空间代码和数据完全被新程序替换,从新程序的启动例程开始执行。调用exec并不创建新进程,所以调用exec前后该进程的id并未改变 
 
 
 问题：进程的程序替换有没有创建新的进程？？
 回答：并没有创建新的进程，因为进程的程序替换并没有再一次创建PCB，并且PID也没用被重新生成！ 
 
替换函数 
其实有六种以exec开头的函数,统称exec函数：
  
#include    //exec系列函数所在头文件

//以下函数的第一个参数代表的是你想执行谁， 
//第二个参数代表的是以什么方式执行
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 execve(const char *path, char *const argv[], char *const envp[])； 
函数解释 
这些函数如果调用成功则加载新的程序从启动代码开始执行,不再返回。如果调用出错则返回-1所以exec函数只有出错的返回值而没有成功的返回值 
命名理解 
这些函数原型看起来很容易混,但只要掌握了规律就很好记。 
 
l(list) : 表示参数采用列表
  v(vector) : 参数用数组
  p(path) : 有p自动搜索环境变量PATH
  e(env) : 表示自己维护环境变量
   
 
 execl函数基本使用 
 
#include 
#include 
using namespace std;

int main()
{ 
    execl("/usr/bin/ls","ls", "-a","-l", NULL);
   return 0;
}
 
程序运行结果可以看出使用我们的./exe和直接使用ls -al好像是一样的功能
  
使用exel发生有趣的现象 
#include 
#include 
using namespace std;

int main()
{ 
    execl("/usr/bin/ls","ls", "-a","-l", NULL);
    while(1) printf("hello wordn");
    return 0;
}
 
程序运行结果：
 
 其实当我们执行完了./exe，exe就会变成一个进程，执行到execl后会发生一个程序替换，会将ls这个系统的可执行程序替换到exe这个进程中来，将exe进程原本的代码给整体替换掉，所以后面的循环打印hello word就不执行了，于是进程exe就开始执行ls的代码了，这就是进程替换
 
 注意：我们的execl函数是会带返回值的，那么思考一个问题，当发生了进程替换execl还会带回来返回值吗？ 
int execl(const char *path, const char *arg, ...);
 
 
 答案是不会，因为发生了进程替换exe进程中的所有代码都将会被整体替换成ls的代码，所以execl函数是不会带回来返回值的，那么问题来了，如果进程替换失败execl函数是否就会带回来返回值呢？这个问题值得尝试一下。。 
 
测试代码： 
#include 
#include 
#include 

using namespace std;

int main()
{ 
  
    //execl("/usr/bin/ls","ls", "-a","-l", NULL);  //正确路径下
    int ret = execl("/usr/b/ls","ls", "-a","-l", NULL);    //故意将路径写错
    while(1) printf("hello word, ret = %dn",ret);
    return 0;
}
 
测试结果：
  
 
 所以我们可以验证之前的问题，如果进程替换失败execl函数是会带回返回值的，并且值是为-1 
 
exec系列的函数使用 
#include 
int main()
{
 char *const argv[] = {"ps", "-ef", NULL};
 char *const envp[] = {"PATH=/bin:/usr/bin", "TERM=console", NULL};
 execl("/bin/ps", "ps", "-ef", NULL);
 // 带p的，可以使用环境变量PATH，无需写全路径
 execlp("ps", "ps", "-ef", NULL);
 // 带e的，需要自己组装环境变量
 execle("ps", "ps", "-ef", NULL, envp);
 execv("/bin/ps", argv);
 
 // 带p的，可以使用环境变量PATH，无需写全路径
 execvp("ps", argv);
 // 带e的，需要自己组装环境变量
 execve("/bin/ps", argv, envp);
 exit(0);
}
 
演示execle函数 
 
 这里的envp我们是可以手动传递的， 也可以通过设置环境变量全局域的方式自己组织环境变量 
 
 execle("ps", "ps", "-ef", NULL, envp);  
 
exe.c文件 
#include 
#include 

int main()
{
    char* str1 = (char*)"myenv=you can see me!";
    char* str2 = NULL;
    char* const env[] = {str1,str2};

    int ret = execle("./cmd", "./cmd", NULL, env);  //参数列表做参数 + 组装环境变量
    while(ret < 0)  printf("hello wordn");  //表示进程替换失败
    return 0;
}
 
cmd.c文件 
#include 
#include 

int main()
{

  printf("%sn", getenv("myenv"));
  return 0;
}
 
程序运行结果： 
[mzt@VM-16-4-centos exec函数测试]$ ./exe 
you can see me!
[mzt@VM-16-4-centos exec函数测试]$ 
 
 
 梳理这个程序运行的过程，当执行. /exe 这个过程，会将exe这个可执行程序变成一个进程，而直到exe进程执行到execle("./cmd", "./cmd", NULL, env);这句代码时，会将cmd进程的代码替换exe进程的代码，并且还会传递一个env的环境变量，那么cmd进程就会接受这个env环境变量最后打印you can see me!这个字符串 
 
再看一种通过设置全局环境变量的方式让演示上述过程吧，当然实验之前我们需要将exe.c的代码修改一下，也就是不手动传递环境变量 
[mzt@VM-16-4-centos exec函数测试]$ export myenv='you_see_me!'  //设置全局的环境变量env
[mzt@VM-16-4-centos exec函数测试]$ ./exe 
you_see_me!  			//程序运行结果
[mzt@VM-16-4-centos exec函数测试]$ cat exe.c
#include 
#include 

int main(int argc, char *argv[], char *env[])  
{
    

    int ret = execle("./cmd", "./cmd", NULL, env); //这里的env获取的是全局的环境变量 
    //参数列表做参数 + 组装环境变量
    while(ret < 0)  printf("hello wordn");
    return 0;
}
 
最后
 事实上,只有execve是真正的系统调用,其它五个函数最终都调用 execve,所以execve在man手册 第2节,其它函数在man手册第3节。这些函数之间的关系如下图所示。
 下图exec函数族 一个完整的例子 
 int execve(const char *path, char *const argv[], char *const envp[]);
 
 
制作简易shell 
用下图的时间轴来表示事件的发生次序。其中时间从左向右。shell由标识为sh的方块代表，它随着时间的流逝从左向右移动。shell从用户读入字串"ls"。shell建立一个新的进程，然后在那个进程中运行ls程序并等待那个进程结束
  
然后shell读取新的一行输入，建立一个新的进程，在这个进程中运行程序 并等待这个进程结束。所以要写一个shell，需要循环以下过程： 
获取命令行解析命令行建立一个子进程（fork）替换子进程（execvp）父进程等待子进程退出（wait） 
#include 
#include 
#include 
#include 

#define NUM 16
#define SIZE 256

int main()
{
 
  char cmd[SIZE];   //创建缓冲区
  const char *str = "[shell@VM-16-4-centos shell程序]";
  while(1){
      cmd[0] = 0;  //清空缓冲区
      printf("%s", str);
      fgets(cmd , SIZE, stdin);  //从标准输入流获取字符串存放进cmd
      cmd[strlen(cmd) - 1] = '';  //去除n

      int i = 1;
      char *args[NUM];
      
      args[0] = strtok(cmd, " ");  
      do{
          args[i] = strtok(NULL, " ");
          i++;
      }while(args[i]);  //直到遇到NULL，就初始化完毕

      int j;
      for(j = 0; j < i; j++){
          printf("args[%d]：%sn", j,args[j]);
      }
      pid_t id = fork();
      if(id < 0) printf("frok errorn");
      if(id == 0) {
          execvp(args[0], args);  //进程程序替换，将args[0]环境变量所对应的程序替换进shell进程
          exit(1);  //程序替换失败子进程返回1
      }
      
      int st = 0;
      pid_t ret = waitpid(id, &st , 0); //父进程以阻塞方式等待子进程
      if(WIFEXITED(st)) printf("%d",WEXITSTATUS(st));  //子进程正常终止，就打印子进程的退出码
      
      else printf("wait errorn");  //等待失败
     // printf("%s", cmd);
  }

    return 0;
}
 
程序运行结果：
  
在继续学习新知识前，我们来思考函数和进程之间的相似性exec/exit就像call/return 一个C程序有很多函数组成。一个函数可以调用另外一个函数，同时传递给它一些参数。被调用的函数执行一定的操作，然后返回一个值。每个函数都有他的局部变量，不同的函数通过call/return系统进行通信。这种通过参数和返回值在拥有私有数据的函数间通信的模式是结构化程序设计的基础。Linux鼓励将这种应用于程序之内的模式扩展到程序之间。如下图:
 
 一个C程序可以fork/exec另一个程序，并传给它一些参数。这个被调用的程序执行一定的操作，然后通过exit(n)来返回值。调用它的进程可以通过wait（&ret）来获取exit的返回值。

linux就该这么学【进程控制】

Linux相关栏目本月热门文章