进程等待与程序替换

最新推荐文章于 2023-03-23 20:18:39 发布

WoLannnnn

最新推荐文章于 2023-03-23 20:18:39 发布

阅读量409

点赞数 14

分类专栏： linux C 文章标签： linux 操作系统

本文链接：https://blog.csdn.net/aaaaaaaWoLan/article/details/122608212

版权

C 同时被 2 个专栏收录

37 篇文章 23 订阅

订阅专栏

linux

19 篇文章 2 订阅

订阅专栏

进程等待

子进程被创建，谁先运行谁先退出？
谁先运行，是由调度器说了算

那谁先退出呢？
一般来说，我们通常要让子进程先退出。

因为父进程可以很容易对子进程进行管理(垃圾回收).子进程处理业务，需要让父进程帮我们拿到子进程执行的结果

所以，一般子进程是需要被等待的，具体是被父进程等待

进程等待必要性

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

进程等待的方法

wait方法

父进程调用了wait()，就会等待子进程运行，直到子进程退出，收集结束信息，回收运行完的子进程的资源。

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

示例：

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/wait.h>

int main()
{
    pid_t id = fork();
    
    if (id == 0)//子进程
    {
        int count = 0;
        while (1)
        {
            printf("I am a child\n");
            sleep(1);
            if (count == 4)
            {
                printf("child exits\n");
                exit(1);
            }
            ++count;
        }
    }
    else
    {
        printf("father waits...\n");
        wait(NULL);
        printf("father exits\n");
    }
    
    return 0;
    
}

我们用一个shell脚本来监视进程的状态： while :; do ps axj | head -1 && ps axj | grep test | grep -v grep; sleep 1; echo "##################"; done

运行效果：观察父子进程的状态：

wait

我们看到，当子进程结束，父进程也跟随着结束了，如果不使用wait()，父进程就会比子进程先结束，并且无法回收子进程

waitpid方法

pid_ t waitpid(pid_t pid, int *status, int options);

返回值：
当等待成功的时候waitpid返回收集到的是子进程的进程ID；
如果设置了选项WNOHANG,而调用中waitpid发现没有已退出的子进程可收集,则返回0；
如果等待失败,则返回-1,这时errno会被设置成相应的值以指示错误所在；

参数：

pid：
pid =-1,等待任一个子进程。与wait等效。
pid>0.等待其进程ID与pid相等的子进程。

status(结合下面对status的结构进行理解):
WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出）
相当于status & 0x7f
WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的退出码）
相当于(status>>8 ) & 0xff
options:
WNOHANG: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID。如果子进程已经退出，调用wait/waitpid时，wait/waitpid会立即返回，并且释放资源，获得子进程退出信息。

例：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include<sys/wait.h>

int main()
{
    pid_t id = fork();
    
    if (id == 0)//子进程
    {
        int count = 0;
        while (1)
        {
            printf("I am a child\n");
            sleep(1);
            if (count == 4)
            {
                printf("child exits\n");
                exit(1);
            }
            ++count;
        }
    }
    else
    {
        printf("father waits...\n");
        waitpid(id, NULL, 0);
        printf("father exits\n");
    }
    
    return 0;
    
}

同样，我们还是用shell脚本观察：

waitpid(id, NULL, 0)与wait(id)作用相同

如果在任意时刻调wait/waitpid，子进程存在且正常运行，则进程可能阻塞。
如果不存在该子进程，则立即出错返回

获取子进程status

status只使用其低16位

wait和waitpid，都有一个status参数，该参数是一个输出型参数，由操作系统填充。

如果传递NULL，表示不关心子进程的退出状态信息。
否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程。

status不能简单的当作整形来看待，可以当作位图来看待，具体细节如下图（只研究status低16比特位）：

正常终止的status低7位为0，高8位就是退出码
被信号所杀的低7位不为0

获取退出信号：status & ox7f 取出低七位

获取退出码：(status >> 8) & 0xff 取出高8位，观察运行结果是否正确

关于终止信号

就是kill的信号：

所以我们就知道为什么终止信号为0才表示进程正常运行，因为kill的信号最小编号大于0

测试一个子进程被信号杀掉的情况：

#include<stdio.h>
#include<unistd.h>
#include<sys/wait.h>
#include<stdlib.h>

int main()
{
    pid_t id = fork();
    if (id < 0)
    {
        perror("fork error");
        exit(1);
    }
    
    if (id == 0)//子进程
    {
		printf("child's pid is : %d\n", id);
        int i = 1 / 0;//引发错误
    }
    else//父进程
    {
        int st = 0;
        int ret = waitpid(id, &st, 0);

        if (ret > 0 && WIFEXITED(st))//子进程正常运行
        {
            //代码也不会走到这里，就不写内容了
            //...
            ;
        }
        else
        {
			printf("exit signal is %d\n", st & 0x7f);
        }
        
    }
    
    return 0;
}

我们看到进程因为错误而被杀掉了

获取退出信号(终止信号)与退出码的测试代码：

#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

int main( void )  
{
    pid_t pid;
    
    if ( (pid=fork()) == -1 )
    	perror("fork"),exit(1);
    
    if ( pid == 0 )//子进程
    {
    	sleep(5);
    	exit(0);
    } 
    else //父进程
    {
    	int st;//st就是status
    	int ret = wait(&st); //等待子进程，st获取子进程status的值，ret获取子进程的pid
    	if ( ret > 0 && ( st & 0X7F ) == 0 ) // 子进程正常退出
        {
            //获取子进程退出码
    		printf("child exit code:%d\n", (st>>8)&0XFF);
    	} 
        else if( ret > 0 ) // 子进程异常退出
        { 
            //获取子进程终止信号
    		printf("sig code : %d\n", st&0X7F );
    	}
    
    }//对应上面else的右括号
    
    return 0;

}

结果：

也可以将st & 0X7F 的判断换成WIFEXITED(st)

st & 0x ff换成WEXITSTATUS(st)

#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

int main( void )  
{
    pid_t pid;
    
    if ( (pid=fork()) == -1 )
    	perror("fork"),exit(1);
    
    if ( pid == 0 )//子进程
    {
    	sleep(5);
    	exit(0);
    } 
    else //父进程
    {
    	int st;//st就是status
    	int ret = wait(&st); //等待子进程，st获取子进程status的值，ret获取子进程的pid
    	if ( ret > 0 && WIFEXITED(st)) // 子进程正常退出
        {
            //获取子进程退出码
    		printf("child exit code:%d\n", WEXITSTATUS(st));
    	} 
        else if( ret > 0 ) // 子进程异常退出
        { 
            //获取子进程终止信号
    		printf("sig code : %d\n", st & 0X7F );
    	}
    
    }//对应上面else的右括号
	
    return 0;
}

waitpid三个参数的使用示例

进程的阻塞等待与非阻塞等待

进程的阻塞等待方式

阻塞等待就是父进程一直等待子进程到其运行结束，然后回收他

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
    int main()
  	{
          pid_t pid;
          pid = fork();
          if(pid < 0)//创建进程失败
          {
              printf("%s fork error\n",__FUNCTION__);
              return 1;
          }
          else if( pid == 0 )//child
          { 
              printf("child is run, pid is : %d\n",getpid());
              sleep(5);
              exit(257);//257就是1 0000 0001，因为只会取低16位，所以就相当于1
          } 
          else//parent
          {
              int status = 0;
              pid_t ret = waitpid(-1, &status, 0);//阻塞式等待，等待5s
              printf("this is test for wait\n");
              if( WIFEXITED(status) && ret == pid )
              {
                    printf("wait child 5s success, child return code is :%d.\n",WEXITSTATUS(status));
              }
              else
              {
                    printf("wait child failed, return.\n");
                    return 1;
              }

          }//对应上面的else

        	return 0;
  	}

结果：

进程的非阻塞等待方式

非阻塞等待父进程就是每隔一段时间waitpid就要确认等待的子进程是否运行结束了，如果没有，则可以先做其它的，如果结束了，就按流程回收子进程

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>

int main()
{
	pid_t pid;
	pid = fork();
	if(pid < 0)
    {
		printf("%s fork error\n",__FUNCTION__);
		return 1;
	}
    else if( pid == 0 )//child
    { 
		printf("child is run, pid is : %d\n",getpid());
		sleep(5);
		exit(1);
	} 
    else
    {

        int status = 0;
        pid_t ret = 0;
        do
        {
            ret = waitpid(-1, &status, WNOHANG);//非阻塞式等待,如果子进程没结束,则返回0
            if( ret == 0 )
            {
                printf("child is running\n");
            }

            sleep(1);

        } while(ret == 0);

        if( WIFEXITED(status) && ret == pid )
        {
            printf("wait child 5s success, child return code is :%d.\n",WEXITSTATUS(status));
        }
        else
        {
            printf("wait child failed, return.\n");
            return 1;
        }

    }//对应上面的else

    return 0;
}

结果：

wait总结：

是什么：是父进程通过wait等系统调用，用来等待子进程退出的一种现象，是必须的。

为什么：1.防止子进程变成僵尸进程，进而产生内存泄漏 2.读取子进程状态

怎么办：使用wait/waitpid，以及获取状态码status和signal、exit code，还有阻塞式等待和非阻塞等待

进程程序替换

替换原理

用fork创建子进程后执行的是和父进程相同的代码(但有可能执行不同的代码分支),子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时,该进程的用户空间代码和数据完全被新程序替换,从新程序的启动例程开始执行。调用exec并不创建新进程,所以调用exec前后该进程的id并未改变

此时就相当于代码也发生了写时拷贝

替换函数

其实有六种以exec开头的函数,统称exec函数:

#include <unistd.h>`
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[]);

其他五个函数都是经过封装的，是为了应用不同场景。

事实上,只有execve是真正的系统调用,其它五个函数最终都调用 execve,所以execve在man手册第2节,其它函数在man手册第3节。这些函数之间的关系如下图所示。

下图是exec函数族一个完整的关系:

函数解释

这些函数如果调用成功则加载新的程序从启动代码开始执行,不再返回。

如果调用出错则返回-1

所以exec函数只有出错的返回值而没有成功的返回值。

如果执行了原程序后面的代码或者有返回值，说明替换失败了

命名理解

这些函数原型看起来很容易混,但只要掌握了规律就很好记。

l(list) : 表示参数采用列表，类似printf

v(vector) : 参数用数组，将参数写进数组，用数组传参

p(path) : 有p自动搜索环境变量PATH

解释：要使程序替换，就要先找到该程序

所以如果参数名带p，函数自己会在PATH里查找程序

如果不带p，第一个参数就要给程序的路径

e(env) : 表示传递自己维护的环境变量

所有替换函数的第一个参数，表示我们所要替换的程序，也就是要执行的程序

函数名	参数格式	是否带路径	是否使用当前环境变量
execl	列表	不是	是
execlp	列表	是	是
execle	列表	不是	不是，须自己组装环境变量
execv	数组	不是	是
execvp	数组	是	是
execve	数组	不是	不是，须自己组装环境变量

示例

将当前程序替换成ps的执行

excel("/usr/bin/ps", "ps", "-e", "-l", "-f", NULL);

命令行怎么调用执行，如ps -e，在后面的参数中，就怎么传递，ps也算一个参数，最后一个参数要是NULL。

exec调用举例如下:

下面的代码只是列举了这些函数的用法，实际使用不会这样，因为当调用第一个exec的函数后，整个程序就被替换了，后面的代码就不会执行了。

#include <unistd.h>
int main()
{
    char *const argv[] = {"ps", "-ef", NULL};//采用数组的形式传参，也就是给带v的函数传参
    
    //给带e的函数传参
    char *const envp[] = {"PATH=/bin:/usr/bin", "TERM=console", NULL};
    
    //带l的，使用参数列表传参，注意最后要加上NULL
    execl("/bin/ps", "ps", "-ef", NULL);
      
    // 带v的，使用数组传参
    execv("/bin/ps", argv);  
    
    // 带p的，可以使用环境变量PATH，无需写全路径
    execlp("ps", "ps", "-ef", NULL);
    execvp("ps", argv);
    
    // 带e的，需要自己组装环境变量
    execle("ps", "ps", "-ef", NULL, envp);
    execve("/bin/ps", argv, envp);
   
    
    exit(0);
}

列举一个具体例子：将当前程序替换成ls

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

int main()
{
    //使用参数列表传参
    //将当前程序替换成ls -l -a
    execl("/usr/bin/ls", "ls", "-l", "-a", NULL);
    
	return 0;
}

运行结果：

与ls -l -a一样，不过少了颜色的渲染

如果我们修改一下程序：

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

int main()
{
    //使用参数列表传参
    //将当前程序替换成ls -l -a
    execl("/usr/bin/ls", "ls", "-l", "-a", NULL);
    printf("you should run here\n");
    
	return 0;
}

加的这句printf会执行吗？

我们试一下:

可以看到最后是没有打印的。

因此，证明了程序替换是完全替换，而不是执行完了替换的程序再继续执行自己的程序。

也可以用自己创建的程序进行程序替换：

创建myexe.c 和 mycmd.c文件：

myexe.c

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

int main()
{
    //没有选项，所以arg参数只有"./mycmd"
    execl("./mycmd", "./mycmd", NULL);
    
	return 0;
}

mycmd.c

#include <stdio.h>

int main()
{
    int i = 0;
    int sum = 0;
    for (; i <= 100; ++i)
    {
        sum += i;
    }
    
    printf("1-100累加的结果为：%d\n", sum);
    
    return 0;
}

makefile

因为我们要生成两个可执行程序，而makefile默认只生成一个可执行程序，默认是自顶向下扫描makefile文件遇到的第一个目标。所以用all来代表两个可执行程序

伪目标不需要依赖方法

.PHONY:all
all:myexe mycmd

myexe:myexe.c
gcc myexe.c -o myexe
mycmd:mycmd.c
gcc mycmd.c -o mycmd

.PHONY:clean
clean:
rm -f myexe mycmd

运行结果：

在此基础上，我们展示一下带e的函数的使用：

myexe.c

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

int main()
{
    //注意是指针数组
	char*env[] = {
      "myenv = you can see me!!!",
        NULL
    };
    
    execle("./mycmd", "./mycmd", NULL, env);
    
    return 0;
}

mycmd.c

#include <stdio.h>
#include <stdlib.h>//一定要包含头文件，不然报错Segment fault

int main()
{
    //获取自己维护的环境变量
    printf("%s\n", getenv("myenv"));
    return 0;
}

结果：

如果我们只执行mycmd，是不能打印出想要的结果的。

或者我们可以使用export导出myenv的方法，来完成环境变量参数的传递，此时main函数要可以接收环境变量。

以上就是exec函数的讲解。

一般，我们不会自己调用exec系列的函数，一般是用fork()让子进程调用，父进程只需要wait就行，一旦命令本身有问题，不会波及父进程。

我们可以综合前面的知识，做一个简易的shell

考虑下面这个与shell典型的互动：

[root@localhost epoll]# ls
client.cpp readme.md server.cpp utility.h
[root@localhost epoll]# ps
PID TTY TIME CMD
3451 pts/0 00:00:00 bash
3514 pts/0 00:00:00 ps

用下图的时间轴来表示事件的发生次序。其中时间从左向右。shell由标识为sh的方块代表，它随着时间的流逝从左
向右移动。shell从用户读入字符串"ls"。shell建立一个新的进程，然后在那个进程中运行ls程序并等待那个进程结
束。

然后shell读取新的一行输入，建立一个新的进程，在这个进程中运行程序并等待这个进程结束。
所以要写一个shell，需要循环以下过程:

获取命令行

先像模像样地打印出命令提示符 myshell@VM-4-11-centos study_10-4]#

再用cmd数组获取命令

解析命令行

用strtok分割cmd数组，用一个指针数组args接收。比如ls -a -l，分割后，args里的内容就是ls , -a , -l

建立一个子进程（fork）

替换子进程（execvp）

父进程等待子进程退出（wait）

根据这些思路，和我们前面的学的技术，就可以自己来实现一个shell了。
实现代码:

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


#define NUM 256

int main()
{
  //制造命令行
  char *cmdline = "myshell@VM-4-11-centos study_10-4]# " ;
  //接收命令
  char cmd[NUM];

  //因为需要一直输入，所以用死循环
  while (1)
  {
    cmd[0] = '\0';
    printf("%s", cmdline);
    fgets(cmd, NUM, stdin);
    
    //将cmd的最后一个字符设置成\0，否则就是\n，程序替换时会把\n也当成命令
    cmd[strlen(cmd) - 1] = '\0';
    
    //用指针数组接收分割的字符串
    char*args[NUM];
    args[0] = strtok(cmd, " ");
    int i = 1;
    do
    {
      args[i] = strtok(NULL, " ");
      
      //当strtok返回NULL时，说明分割结束
      //这个NULL刚好作为替换函数中数组参数的最后的那个NULL
      if (args[i] == NULL)
      {
        break;
      }
      ++i;
    } while (1);

  pid_t id = fork();

  if (id < 0)
  {
    perror("fork error!");
    exit(1);
  }

  if (id == 0)//子进程执行替换
  {
    //因为我们实现的都是shell命令，可在PATH中找到，所以使用带p的替换函数
    //第一个参数就是args数组的第一个元素
    execvp(args[0], args);
   
    //如果执行到这里，说明替换失败
    exit(1);
  }
  else//父进程等待子进程执行 
  {
    pid_t st = 0;
    //阻塞式等待
    pid_t ret = waitpid(id, &st, 0);
    

    if (ret > 0 && ((st>>8) & 0xff) == 0)//正常运行，结果正确
    {
        ;
    }
    else if (ret > 0 && ((st>>8) & 0xff) != 0)//正常运行，结果错误
    {
      printf("Excution error!\n");
      printf("exit code:%d\n", (st>>8) & 0xff);
    }
    else //错误退出
    { 
      printf("running error!\n");
    }

  }//判断父子进程的else的右括号

  }
  return 0;
}

在继续学习新知识前，我们来思考函数和进程之间的相似性

exec/exit就像call/return

一个C程序有很多函数组成。一个函数可以调用另外一个函数，同时传递给它一些参数。被调用的函数执行一定的
操作，然后返回一个值。每个函数都有他的局部变量，不同的函数通过call/return系统进行通信。
这种通过参数和返回值在拥有私有数据的函数间通信的模式是结构化程序设计的基础。Linux鼓励将这种应用于程
序之内的模式扩展到程序之间。如下图

一个C程序可以fork/exec另一个程序，并传给它一些参数。这个被调用的程序执行一定的操作，然后通过exit(n)来
返回值。调用它的进程可以通过wait（&ret）来获取exit的返回值。

WoLannnnn

关注

14
点赞
踩
7

收藏

觉得还不错? 一键收藏
打赏
14
评论
进程等待与程序替换

进程等待子进程被创建，谁先运行谁先退出？谁先运行，是由调度器说了算那谁先退出呢？一般来说，我们通常要让子进程先退出。因为父进程可以很容易对子进程进行管理(垃圾回收).子进程处理业务，需要让父进程帮我们拿到子进程执行的结果所以，一般子进程是需要被等待的，具体是被父进程等待进程等待必要性之前讲过，子进程退出，父进程如果不管不顾，就可能造成‘僵尸进程’的问题，进而造成内存泄漏。另外，进程一旦变成僵尸状态，那就刀枪不入，“杀人不眨眼”的kill -9 也无能为力，因为谁也没有办法杀死一个已
复制链接

扫一扫