Linux进程控制-进程创建/终止/等待&封装fork/wait&函数popen/system

最新推荐文章于 2024-07-13 06:57:30 发布

ReginaPhilange

最新推荐文章于 2024-07-13 06:57:30 发布

阅读量1.3k

点赞数

分类专栏： LINUX

本文链接：https://blog.csdn.net/qq_41268108/article/details/83029093

版权

LINUX 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

本文详细介绍了Linux进程控制的相关知识，包括fork、vfork函数创建进程，写时拷贝机制，进程的正常与异常终止，wait与waitpid的等待机制，system函数以及popen函数的使用。还提到了进程间通信的popen方法，并讲解了如何封装fork和wait操作以实现自定义进程创建。

摘要由CSDN通过智能技术生成

进程创建

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

#include<unistd.h>

pid_t fork(void)；返回值：子进程返回0，父进程返回子进程的id,出错返回-1.

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

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

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
int main()
{ 
    pid_t pid;
    printf("before:pid is %d\n",getpid());
     if(pid=fork()==-1) 
        perror("fork()");
        printf("after:pid is %d,fork return %d\n",getpid(),pid);
    return 0;
｝

注意：fork之前是父进程独立执行，fork之后，if分流，父子进程分别执行。fork之后，谁先执行完全是由调度器决定的。

写时拷贝

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

fork 调用失败的原因：

系统中有太多的进程；

实际用户的进程数超过了限制。

vfork函数

vfork用于创建一个子进程，而子进程和父进程共享地址空间，fork的子进程具有独立地址空间
vfork保证子进程先运行，在它调用exec或（exit）之后父进程才能被调度运行4

父进程的变量值被子进程改变，因为子进程和父进程共享相同的地址空间。

进程终止

进程退出场景：

1.代码运行完毕，结果正确；

2.代码运行完毕，结果不正确；

3.代码异常终止。

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

1.从main返回；

2.调用exit，将所有缓存数据写入；

3.调用 _exit。

异常退出：

ctrl+c,信号终止。

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

进程等待

进程等待的必要性：

1.回收子进程资源，避免内存泄漏；

2.获取子进程退出信息，查看退出码，看运行结果是否正确。

获取子进程status

1)wait和waitpid，均有一个status参数，该参数是一个输出型参数，由操作系统填充；

2）若传NULL，表示不关心子进程的退出状态信息；

3）否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程；

4）status不能当做简单整型看待，可以当做位图来看待，具体如下图（这里只有低16位比特位）：

由图可知，当程序正常终止时，status的位图的低8位不会收到任何信号，保持全0状态，此时位图的次低8位则保存着程序的退出码。一旦低8位收到信号，则表示程序被信号杀死即异常终止。此时位图的低8位保存程序的终止信号，次低8位不会用。不过需要注意的是，实际上用来保存收到终止信号的只有7个比特位，因为低8位中有一个比特位是core dump标志。

wait函数

pid_t wait(int * status)返回值：成功返回被等待进程pid，失败返回-1

参数：输出型参数，获取子进程退出状态，不关心则可以设置成为NULL

低16比特位，次低八位表示退出码全部向右移8位，按位与0xFF，得到退出码，

最低7位表示是否收到信号，如果是0即是有收到信号，反之没有收到信号。

中间一位是core dump标志位。

waitpid方法：

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

返回值：

当正常返回的时候waitpid返回收集到的子进程的进程id;

如果设置了选项WNOHANG，而调用中waitpid发现没有已退出的子进程可回收，则返回0,；

如果调用出错，则返回-1.

参数：

pid:

pid=-1,等待任意一个子进程，与wait等效。

pid>0,等待其进程id与pid相等的子进程。

status:

WIFEXITED(status):若为正常终止子进程返回的状态，则为真（查看进程是否是正常退出，即是否收到信号）；

WEXITSTATUS(status):若WIFEXITED不为0，提取进程退出码。（查看进程退出码）

options：

阻塞：指pid指定的子进程没有结束，返回0，不予等待。

非阻塞：正常退出，则返回该子进程的id.

system()函数
函数原型

#include <stdlib.h>
int system(const char *command);

system()会调用fork()产生子进程，由子进程来调用/bin/sh-c string来执行参数string字符串所代表的命令，此命令执行完后随即返回原调用的进程。在调用system()期间SIGCHLD 信号会被暂时搁置，SIGINT和SIGQUIT 信号则会被忽略。
调用/bin/sh来执行参数指定的命令，/bin/sh 一般是一个软连接，指向某个具体的shell。

实际上system()函数执行了三步操作：
1.fork一个子进程；
2.在子进程中调用exec函数去执行command；
3.在父进程中调用wait去等待子进程结束。
返回值：
1>如果 exec 执行成功，即 command 顺利执行，则返回 command 通过 exit 或 return 的返回值。(注意：command 顺利执行不代表执行成功，当参数中存在文件时，不论这个文件存不存在，command 都顺利执行)
2>如果exec执行失败，也即command没有顺利执行，比如被信号中断，或者command命令根本不存在，返回 127
3>如果 command 为 NULL，则 system 返回非 0 值.
4>对于fork失败，system()函数返回-1。
判断一个 system 函数调用 shell 脚本是否正常结束的方法的条件应该是
1. status != -1
2.(WIFEXITED(status) 非零且 WEXITSTATUS(status) == 0

1 #include<stdio.h>
2 #include<unistd.h> 
3 #include<stdlib.h> 
4 #include<string.h>
5 int main(void)  
6 {  
7         int status=0;  
8         status=system("ls -l");  
9         if(status==-1){
10                 perror("system()"); 
11                 exit(1);} 
12         if(WIFEXITED(status)!=0)//正常退出{ 
13                 if(WEXITSTATUS(status)==0)//操作正确{ 
14                 printf("run command success\n");} 
15                 else{//操作错误 
16                         printf("run command fail and exit code is %d\n", WEXITSTATUS(status)); 
17                 } 
18         }else//异常退出{ 
19                 printf("exit code is  %d\n",  WEXITSTATUS(status)); 
20         } 
21         return 0; 
22 }

popen()函数：创建一个管道用于进程间通信，并调用shell,因为管道被定义为单向的所以 type 参数只能定义成只读或者只写, 不能是两者同时, 结果流也相应的是只读或者只写.
函数原型：

#include <stdio.h>

FILE *popen(const char *command, const char *type);

int pclose(FILE *stream);

函数功能：popen()会调用fork()产生子进程，然后从子进程中调用/bin/sh -c来执行参数command的指令。这个进程必须由 pclose 关闭。

command参数：
command 参数是一个字符串指针, 指向的是一个以 null 结束符结尾的字符串, 这个字符串包含一个 shell 命令. 这个命令被送到 /bin/sh 以 -c 参数执行, 即由 shell 来执行.

type 参数也是一个指向以 null 结束符结尾的字符串的指针
参数type可使用“r”代表读取，“w”代表写入。
依照此type值,popen()会建立管道连到子进程的标准输出设备或标准输入设备，然后返回一个文件指针。
随后进程便可利用此文件指针来读取子进程的输出设备或是写入到子进程的标准输入设备中。
返回值：
若成功则返回文件指针，否则返回NULL，错误原因存于errno中

区别
1.system 在执行期间，调用进程会一直等待 shell 命令执行完成(waitpid)，但是 popen 无需等待 shell 命令执行完成就返回了。可以理解为，system为串行执行，popen 为并行执行。
2.popen 函数执行完毕后必须调用 pclose 来对所创建的子进程进行回收，否则会造成僵尸进程的情况。
3.popen 没有屏蔽 SIGCHLD ，如果我们在调用时屏蔽了 SIGCHLD ，如果在 popen 和 pclose 之间调用进程又创建了其他子进程并调用进程注册了 SIGCHLD 来处理子进程的回收工作，那么这个回收工作会一直阻塞到 pclose 调用。

封装fork/wait等操作, 编写函数 process_create(pid_t* pid, void* func, void* arg)，func回调函数就是子进程执行的入口函数, arg是传递给func回调函数的参数.

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h> 
int process_create(int(*func)(), const char *file, char *argv[])
{    
int ret = 0;   
 pid_t pid = fork();   
 if(pid == 0)   
 {             
 ret = func(file, argv);     
   if(ret == -1)     
   {          
  printf("调用execvp失败\n");   
         perror("func");    
        _exit(-1);       
 }     
}
    else   
 {       
 int st;      
  pid_t ret = wait(&st);    
    if(ret == -1)  
      {          
  perror("wait");      
      exit(-1);      
  }   
 }   
 return 0;
} 
int main()
{  
  char *argv1[] = {"ls"};   
 char *argv2[] = {"ls", "-al", "/etc/passwd", 0}; 
   process_create(execvp, *argv1, argv2);    
return 0;
}