进程的系统编程接口

字数统计: 3.3k字   |   阅读时长≈ 13分

进程创建

fork&vfork

fork与vfork同样都是创建子进程，但是注意两者的区别：

  • fork()：子进程拷贝父进程的数据段，代码段，
  • vfork ()：子进程与父进程共享数据段
  • fork()：父子进程的执行次序不确定
  • vfork()： 保证子进程先运行，在调用exec 或exit 之前与父进程数据是共享的,在它调用exec或exit 之后父进程才可能被调度运行
  • vfork()：保证子进程先运行，在她调用exec 或exit 之后父进程才可能被调度运行。如果在调用这两个函数之前子进程依赖于父进程的进一步动作，则会导致死锁
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

int g_val = 100;

int main(int argc, char *argv[]){
	pid_t pid = vfork();
	if(pid == 0){
		sleep(5);
		g_val = 200;
		printf("%d\n",g_val);
		exit(0);
	}else{
		printf("%d\n",g_val);
	}

	return 0;
}

mark

可以看出，vfork出来的子进程实际上和父进程共享数据段！

进程终止

进程退出的三种状况

  • 代码运行完毕、结果正确

  • 代码运行完毕、结果不正确

    • 从main函数返回
    • 调用exit()
    • 调用_exit()

  • 代码异常终止

    • 信号终止：

      1
      kill -9

_exit()

1
2
3
#include <unistd.h>
void _exit(int status);
参数：status定义了进程的终止状态，父进程通过wait来获取该值

exit()

1
2
#include <stdlib.h>
void exit(int status);

exit()最后也会调用_exit()，只不过在调用_exit()之前做了些其他的事情：

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

return 退出

return退出是一种更常见的退出，执行 等同于，因为调用main函数的函数会把main函数的返回值当做的参数

进程等待

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

wait方法

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

waitpid方法

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <sys/types.h>
#include <sys/wait.h>
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: WIFEXITED(status) ：若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出)
	status: WEXITSTATUS(status) ：若 WIFEXITED非零，提取子进程退出码。（查看进程的退出码）
	options :WNOHANG：若 pid 指定的子进程没有结束，则 waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID

如果子进程已经退出，调用 wait和waitpid 时， wait/waitpid 会立即返回，并且释放资源，获得子进程退出信息。
如果在任意时刻调用 wait和waitpid ，子进程存在且正常运行，则进程可能阻塞。如果不存在该子进程，则立即出错返回。

mark

获取子进程status

wait 和 waitpid ，都一个 status 参数，该参数是一个输出型参数，由操作系统填充。如果传递 NULL ，表示不关心子进程的退出状态信息。否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程。
status 不能简单的当作整形来看待，可以当作位图来看待，具体细节如下图（只研究 status 低 16 比特位） :

mark

先看这样一段代码： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

int main(int argc, char *argv[]){
	pid_t pid = fork();
	if(pid < 0){
		printf("fork error");
		exit(1);
	}else if(pid == 0){
		sleep(20);
		exit(10);
	}else{
		int st = 0;
		int ret = wait(&st);
		
		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);
		}
	}
	return 0;
}

进程阻塞式等待方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

int main(int argc, char *argv[]){
	pid_t pid = fork();
	if(pid == 0){
		printf("child is run, pid is %d\n", getpid());
		sleep(5);
		exit(27);
	}else{
		int status = 0;
		pid_t ret = waitpid(-1,&status,0);//阻塞式等待5s
		printf("this is test forwait\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;
		}
	}
	return 0;
}

进程的非阻塞等待

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <stdlib.h>
#include <stdio.h>
#include <unistd.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){
    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);//非阻塞式等待
      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;
    }
  }
  return 0;
}

mark

进程程序替换

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

mark

替换函数

1
2
3
4
5
6
7
#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 execvpe(const char *file, char *const argv[], char *const envp[]);

这些函数如果调用成功则加载新的程序从启动代码开始执行，不再返回。
如果调用出错则返回一1
所以exec函数只有出错的返回值而没有成功的返回值。
这么多函数如何区分？

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

只有execve才是真正的系统调用，其它五个函数最终都是调用execve

mark

利用前面的知识写一个shell

shell的运行原理其实不难，就是从标准输入读入命令和命令参数然后开启一个子进程去执行这个程序，根据程序替换的原理，我们只要使用execve这个系统接口去把要执行的程序的代码段和数据段进行替换，便把一个磁盘上的程序加载到了内存中，变成了进程！此时，我们自己编写的shell变成了该进程父进程！

mark

主要分为以下几个步骤：
1、获取命令行
2、解析命令行
3、建立一个子进程（fork）
4、子进程程序替换（execvp）
5、父进程等待子进程退出（wait） 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#include <unistd.h>
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

char* argv[8];
int argc = 0;

void do_parse(char *buf){
  int i;
  int status = 0;

  for(argc=i=0;buf[i];i++){
    if(!isspace(buf[i]) && status == 0){
      argv[argc++] = buf+i;
      status = 1;
    }else if(isspace(buf[i])){
      status = 0;
      buf[i] = 0;
    }
  }
  argv[argc] = NULL;
}

void do_execute(void){
  pid_t pid = fork();
  switch(pid){
    case -1:
      perror("fork");
      exit(EXIT_FAILURE);
      break;
    case 0:
      execvp(argv[0], argv);
      perror("execvp");
      exit(EXIT_FAILURE);
    default:
      {
        int st;
        while(wait(&st) != pid);
      }
  }
}

int main(void){
  char buf[1024] = {};
  while(1){
    scanf("%[^\n]%*c", buf);
    do_parse(buf);
    do_execute();
  }
  return 0;
}

函数与进程之间的相似性能

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

mark

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

popen/system和fork的区别

system函数原型

1
2
#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。

popen()函数

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

1
2
3
#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 调用。

参考：

《调研popen/system, 理解这两个函数和fork的区别》
《popen/system, 理解这两个函数和fork的区别》

赏

谢谢你请我喝咖啡

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true