二级建造师官网查询系统/优化大师最新版下载

  进程创建

    fork

    vfork

  进程等待

    wait方法

    waitpid方法

  获取子进程status

    wait方式获取子进程status

    waitpid方式获取status

  进程等待

    waitpid进程的阻塞方式等待

    waitpid进程的非阻塞等待方式

  进程替换

    Shell进程替换

    Shell进程替换的本质

  进程替换原理

  实现一个minishell

进程创建

fork

#include <unistd.h>

pid_t fork(void);

返回值：子进程中返回0，父进程返回子进程id，出错返回-1

fork之后，内核做了如下事：

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

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

#include <stdio.h>
#include <unistd.h> //fork
#include <stdlib.h> //exit
int main()
{pid_t pid;printf("Before: pid is %d\n", getpid());if ( (pid=fork()) == -1 ){perror("fork()");exit(1);}printf("After:pid is %d, fork return %d\n", getpid(), pid);sleep(1);return 0;
}

fork之后子进程和父进程是二进制代码相同的进程；fork在子进程中返回值是0，在父进程中返回值是子进程的pid,通过fork的返回值来区分父子进程

fork之后父子进程的执行顺序不定，因为是抢占式执行

写时拷贝

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

fork常用用法

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

fork调用失败的原因

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

进程终止

• 运行中遇到异常终止
• 代码中调用exit，_exit退出程序；
• 从main返回说明程序正常执行结束，结果可能正确符合预期；

_exit函数

_exit函数无返回值，_exit函数的唯一参数status 定义了进程的终止状态，父进程通过wait来获取该值

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

exit函数

exit函数和_exit返回值和参数都一样，exit比_exit多了事务处理

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

return退出

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

vfork

fork函数创建的子进程完全运行在父进程的地址空间上，子进程对虚拟地址空间任何数据的修改都为父进程所见。这与fork是完全不同的，fork进程是独立的空间。另外一点不同的是vfork创建的子进程后，父进程会被阻塞, 直到子进程执行exec ()和exit ()。

fork与vfork不同

1. fork():子进程拷贝父进程的数据段，代码段
   vfork():子进程与父进程共享数据段

2. fork():父子进程的执行次序不确定
   vfork():保证子进程先运行，在调用exec 或exit 之前与父进程数据是共享的,在它调用exec或exit 之后父进程才可能被调度运行。

3. vfork():保证子进程先运行，在她调用exec 或exit之后父进程才可能被调度运行。如果在调用这两个函数之前子进程依赖于父进程的进一步动作，则会导致死锁。

为什么会有vfork呢?

因为以前的fork当它创建一个子进程时，将会创建一个新的地址空间，并且拷贝父进程的资源，然后将会有两种行为：

1.执行从父进程那里拷贝过来的代码段

2.调用一个exec执行一个新的代码段

当进程调用exec函数时，一个新程序替换了当前进程的正文，数据，堆和栈段。这样，前面的拷贝工作就是白费力气了，这种情况下，聪明的人就想出了vfork。vfork并不复制父进程的进程环境，子进程在父进程的地址空间中运行，所以子进程不能进行写操作，并且在儿子"霸占"着老子的房子时候，要委屈老子一下了，让他在外面歇着(阻塞)，一旦儿子执行了exec或者exit后，相当于儿子买了自己的房子了，这时候就相当于分家了。

因此，如果创建子进程是为了调用exec执行一个新的程序的时候，就应该使用vfork

可以粗暴的理解fork之后父子进程数据独立

#include<sys/types.h> //WNOHANG、waitpid
#include <stdlib.h> //exit
#include<unistd.h> //size_t、pid_t
#include<stdio.h>int main()
{pid_t pid;int cnt = 0;pid = fork();if(pid<0)printf("error in fork!\n");else if(pid == 0){cnt++;printf("cnt=%d\n",cnt);printf("I am the child process,ID is %d\n",getpid());}else{   int status = 0;int ret = waitpid(-1, &status, 0);//阻塞式等待cnt++;printf("cnt=%d\n",cnt);printf("I am the parent process,ID is %d\n",getpid());if (WIFEXITED(status) && ret == pid) {printf("wait child success, child return code is: % d.\n",WEXITSTATUS(status));}else {printf("wait child failed, return.\n");return 1;}}return 0;
}

实际fork之后父子代码共享，父子在不写入时，数据也是共享的。当写入cnt变量时，以写时拷贝的方式各自一份副本，因此父子进程输出的cnt值相同

改vfork

将上述fork的例子改成vfork，vfork 保证子进程先运行，所以父进程不用阻塞等待子进程。在子进程调用exec 或exit 之后父进程才可能被调度运行

注意如果子进程没有调用exec 或exit ，此时子进程又依赖父进程进一步的动作产生的结果，父进程等待子进程执行完成才能执行，而子进程要执行又需要父进程产生的动作，则会造成死锁

//#include<sys/types.h> //WNOHANG、waitpid
#include <stdlib.h> //exit
#include<unistd.h> //size_t、pid_t
#include<stdio.h>int main()
{pid_t pid;int cnt = 0;pid = vfork();if(pid<0)printf("error in fork!\n");else if(pid == 0){cnt++;printf("cnt=%d\n",cnt);printf("I am the child process,ID is %d\n",getpid());_exit(0);}else{   cnt++;printf("cnt=%d\n",cnt);printf("I am the parent process,ID is %d\n",getpid());}return 0;
}

子进程中没有_exit(0)时：如果没有_exit（0）的话，子进程也没有调用exec 或exit，所以父进程是不可能执行的，在子进程调用exec 或exit 之后父进程才可能被调度运行。

之所以出现上述运行结果是由于栈混乱造成的

子进程中有_exit(0)时：

进程等待

进程等待必要性

• 需要知道，子进程运行完成，结果对还是不对或者是否正常退出
• 父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息
• 子进程退出，父进程如果不管不顾，就可能造成‘僵尸进程’的问题，进而造成内存泄漏。
• 进程一旦变成僵尸状态，kill -9 pid也无能为力

进程等待的方法

wait方法和waitpid方法

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

wait方法

函数源文件包含了#include<sys/types.h>
#include<sys/wait.h>

pid_t wait(int*status);

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

waitpid方法

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

返回值：

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

参数：

1.pid：

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

2.status:

WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出）WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的退出码）

3.options:

WNOHANG: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID。

获取子进程status

wait和waitpid，都有一个status参数，该参数是一个输出型参数，由操作系统填充。如果传递NULL，表示不关心子进程的退出状态信息。否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程。

status不能简单的当作整形来看待，可以当作位图来看待，具体细节如下图（只研究status低16比特位）：低7位全0表示正常退出，非0则表示终止信号，倒数第8位是core dump标志

wait方式获取子进程status

wait等待任意一个子进程退出，如没有退出，一直阻塞等待

#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 ){ //childsleep(20);exit(10);} else { //parentint st;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 );}}
}

1.以上代码正常执行等待其退出，正常退出其状态码10

2.运行以上代码，查找进程对应的pid,并kill -9强制子进程退出，就可以看到异常退出状态码是9了

ps aux | head -1;ps aux | grep

ps -A -ostat,ppid,pid,cmd| head -1;ps -A -ostat,ppid,pid,cmd | grep proc6_wait_status

kill -9 pid

waitpid方式获取status

阻塞方式和非阻塞方式都可以获取到，请参考后文：进程等待 部分

进程等待

waitpid进程的阻塞方式等待

#include <stdio.h>
#include <stdlib.h> //exit
#include <unistd.h> //fork
//#include<crtdefs.h> //size_t
#include <sys/types.h> //size_t、pid_t
int main()
{pid_t pid;pid = fork();if(pid < 0){printf("%s fork error\n",__FUNCTION__);return 1;} else if( pid == 0 ){ //childprintf("child is run, pid is : %d\n",getpid());sleep(5);exit(257);} else{int status = 0;pid_t ret = waitpid(-1, &status, 0); //阻塞式等待，等待5S。waitpid第一个参数是-1，表示等待一个子进程，与wait等效//pid_t ret = waitpid(pid, &status, 0); //父进程中fork返回值是子进程的id,waitpid第一个参数指定pid代表父进程等待指定子进程printf("this is test for wait\n");if( WIFEXITED(status) && ret == pid ){ //waitpid正常返回收集到的子进程idprintf("wait child 5s success, child return code is :%d.\n",WEXITSTATUS(status));}else{printf("wait child failed, return.\n");return 1;}}return 0;
}

WIFEXITED和WEXITSTATUS都位于stdlib头文件中

1，WIFEXITED(status) 这个宏用来指出子进程是否为正常退出的，如果是，它会返回一个非零值。

（请注意，虽然名字一样，这里的参数status并不同于wait唯一的参数–指向整数的指针status，而是那个指针所指向的整数，切记不要搞混了。）

2，WEXITSTATUS(status) 当WIFEXITED返回非零值时，我们可以用这个宏来提取子进程的返回值，如果子进程调用exit(5)退出，WEXITSTATUS(status)就会返回5；如果子进程调用exit(7)，WEXITSTATUS(status)就会返回7。请注意，如果进程不是正常退出的，也就是说，WIFEXITED返回0，这个值就毫无意义。

waitpid进程的非阻塞等待方式

非阻塞式的waitpid得益于waitpid的第三个参数WNOHANG：若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID。

通过输出发现WNOHANG的值就是1

#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) { //childprintf("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;
}

阻塞式进程等待和非阻塞式进程等待的区别

阻塞和非阻塞关注的是程序在等待调用结果（消息，返回值）时的状态.

阻塞式进程等待方式，在子进程退出之前父进程处于阻塞状态；非阻塞式进程等待，子进程退出前，父进程依然在执行

进程替换

进程替换和命令替换非常相似。命令替换是把一个命令的输出结果赋值给另一个变量，例如dir_files=ls -l或date_time=$(date)；而进程替换则是把一个命令的输出结果传递给另一个（组）命令。

必要性

先来看一个使用管道的例子

echo "https://blog.csdn.net/qq_43808700?spm=1000.2115.3001.5343" | read
echo $REPLY

以上代码输出结果总是为空，因为 echo $REPLY 命令在父 Shell 中执行，而 read 命令在子 Shell 中执行，当 read 执行结束时，子 Shell 被销毁，REPLY 变量也就消失了。管道中的命令总是在子 Shell 中执行的，任何给变量赋值的命令都会遭遇到这个问题。

使用 read 读取数据时，如果没有提供变量名，那么读取到的数据将存放到环境变量REPLY中

Shell提供了进程替换，它可以用来解决这种麻烦

Shell进程替换

一种用来产生标准输出，借助输入重定向，它的输出结果可以作为另一个命令的输入：
<(commands)

另一种用来接受标准输入，借助输出重定向，它可以接收另一个命令的输出结果：
>(commands)

commands 是一组命令列表，多个命令之间以分号;分隔。注意，<或>与圆括号之间是没有空格的。

Shell进程替换例子产生标准输出

read < <(echo "https://blog.csdn.net/qq_43808700?spm=1000.2115.3001.5343")
echo $REPLY

整体上来看，Shell 把echo "http://c.biancheng.net/shell/"的输出结果作为 read 的输入。<()用来捕获 echo 命令的输出结果，<用来将该结果重定向到 read

注意，两个<之间是有空格的，第一个<表示输入重定向，第二个<和()连在一起表示进程替换

本例中的 read 命令和第二个 echo 命令都在当前 Shell 进程中运行，读取的数据也会保存到当前进程的 REPLY变量，大家都在一个进程中，所以使用 echo 能够成功输出。
而在前面的例子中我们使用了管道，echo 命令在父进程中运行，read 命令在子进程中运行，读取的数据也保存在子进程的 REPLY 变量中，echo 命令和 REPLY 变量不在一个进程中，而子进程的环境变量对父进程是不可见的，所以读取失败。

反过来产生标准输入也是一样的

echo "https://blog.csdn.net/qq_43808700?spm=1000.2115.3001.5343"> >(read)
echo $REPLY

进程替换用作「接受标准输入」的例子

echo "C语言中文网" > >(read; echo "你好，$REPLY")

因为使用了重定向，read命令从echo "C语言中文网"的输出结果中读取数据

Shell进程替换的本质

为了能够在不同进程之间传递数据，实际上进程替换会跟系统中的文件关联起来，这个文件的名字为/dev/fd/n（n是一个整数）。该文件会作为参数传递给()中的命令，()中的命令对该文件是读取还是写入取决于进程替换格式是<还是>：

• 如果是>()，那么该文件会给()中的命令提供输入；借助输出重定向，要输入的内容可以从其它命令而来。

• 如果是<()，那么该文件会接收()中命令的输出结果；借助输入重定向，可以将该文件的内容作为其它命令的输入。

使用 echo 命令可以查看进程替换对应的文件名：

echo >(true)echo <(true)echo >(true) <(true)

/dev/fd/目录下有很多序号文件，进程替换一般用的是 63 号文件，该文件是系统内部文件，我们一般查看不到

即使使用ls -a也看不到63号文件

知道了shell进程替换的本质，我们进行一个实例分析

echo "shellscript" > >(read; echo "hello, $REPLY")

第一个>表示输出重定向，它把第一个 echo 命令的输出结果重定向到/dev/fd/63文件中

()中的第一个命令是 read，它需要从标准输入中读取数据，此时就用/dev/fd/63作为输入文件

把该文件的内容交给 read 命令，接着使用 echo 命令输出 read 读取到的内容

进程替换原理

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

进程替换目的

一个进程要执行一个不同的程序(子进程从fork返回后，调用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[]);

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

命名规则

l(list) : 表示参数采用列表
v(vector) : 参数用数组
p(path) : 有p自动搜索环境变量PATH
e(env) : 表示自己维护环境变量

exec调用举例

#include <unistd.h>
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);
}

事实上,只有execve是真正的系统调用,其它五个函数最终都调用 execve,所以execve在man手册 第2节,其它函数在
man手册第3节。

1是普通命令，2是系统调用，3是库函数

实现一个minishell

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#define MAX_CMD 1024
char command[MAX_CMD];
int do_face()
{memset(command, 0x00, MAX_CMD);printf("minishell$ ");fflush(stdout);if (scanf("%[^\n]%*c", command) == 0) {getchar();return -1;}return 0;
}
char** do_parse(char* buff)
{int argc = 0;static char* argv[32];char* ptr = buff;while (*ptr != '\0') {if (!isspace(*ptr)) {argv[argc++] = ptr;while ((!isspace(*ptr)) && (*ptr) != '\0') {ptr++;}continue;}*ptr = '\0';ptr++;}argv[argc] = NULL;return argv;
}
int do_exec(char* buff)
{char** argv = { NULL };int pid = fork();if (pid == 0) {argv = do_parse(buff);if (argv[0] == NULL) {exit(-1);}execvp(argv[0], argv);}else {waitpid(pid, NULL, 0);}return 0;
}
int main(int argc, char* argv[])
{while (1) {if (do_face() < 0)continue;do_exec(command);}return 0;
}