Linux——（四）进程控制

1.进程创建

1.1 fork函数初识

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

1.1.1 pid_t fork(void);

#include <unistd.h>
pid_t fork(void);
//返回值：自进程中返回0，父进程返回子进程id，出错返回-1

• 功能：通过复制父进程创建一个新的进程（子进程）
• 参数：无
• 返回值：对于父进程返回子进程的pid，对于子进程返回0，失败返回-1
• 特点：父子进程之间数据独有
• 写实拷贝技术：先指向同一块物理内存，当物理内存数据发送改变的时候给子进程重新开辟空间（代码段是只读）

进程调用fork，当控制转移到内核中的fork代码后，内核做：
(1)分配新的内存块和内核数据结构给子进程
(2)将父进程部分数据结构内容拷贝至子进程
(3)添加子进程到系统进程列表当中
(4)fork返回，开始调度器调度

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

int main( void )
{
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;
}

运行结果：

[root@localhost linux]# ./a.out
Before: pid is 43676
After:pid is 43676, fork return 43677
After:pid is 43677, fork return 0

这里看到了三行输出，一行before，两行after。进程43676先打印before消息，然后它有打印after。另一个after
消息有43677打印的。注意到进程43677没有打印before，为什么呢？如下图所示

所以，fork之前父进程独立执行，fork之后，父子两个执行流分别执行。注意，fork之后，谁先执行完全由调度器
决定。

1.1.2 fork函数返回值

• 子进程返回0
• 父进程返回的是子进程的pid。

1. 写时拷贝
   通常，父子代码共享，父子再不写入时，数据也是共享的，当任意一方试图写入，便以写时拷贝的方式各自一份副本。具体见下图:
   
2. fork常规用法
   一个父进程希望复制自己，使父子进程同时执行不同的代码段。例如，父进程等待客户端请求，生成子进程来处理请求。
   一个进程要执行一个不同的程序。例如子进程从fork返回后，调用exec函数。
3. fork调用失败的原因
   系统中有太多的进程
   实际用户的进程数超过了限制

1.2 pid_t vfork(void);

#include <unistd.h>
pid_t vfork(void);

• 功能：通过复制父进程创建一个新的进程（但是父子进程共用一个虚拟地址空间）
• 特性：vfork创建子进程之后，父进程会阻塞，直到进程exit退出，或者程序替换之后才会开始运行。

父进程阻塞直到子进程退出或者程序替换后才会运行

• 特点：父子进程共用一个虚拟地址空间，如果同时运行会造成调用栈混乱。

2. 进程终止

2.1 进程退出场景

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

2.2 进程常见退出方法

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

1. 从main返回
2. 调用exit
3. _exit

异常退出：

1. ctrl + c，信号终止

#include <stdio.h>    
#include<unistd.h>                                                                                              
int main()    
{    
    while(1)    
    {    
        printf("hello linux\n");    
        sleep(1);    
    }                                                                                                                                                                           
    return 0;                                                                                      
}        

mam手册 man 1-命令 2-系统调用接口 3-库函数

• 在main函数中return（return只有在main函数中才是退出程序的运行）
• 库函数：void exit(int status);可以在任意位置调用，退出程序的运行(/stdlib.h)
• 系统调用接口： void _exit(int status):可以在任意位置调用，退出程序的运行(unistd.h)

库函数和exit 和_exit的区别就在于：退出程序前是否会刷新缓存区
exit与return在退出程序前都会刷新缓冲区，将还没有写入文件的数据写入到文件中._exit调用直接退出，不会刷新缓冲区，而是直接释放资源(有可能存在缓冲区中的数据丢失)
return后边的数字和exit的参数status的作用:设置进程的退出码
退出码只保留低8位(我们设置进程退出码尽量保持在0~255之间)

2.2.1 _exit函数

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

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

2.2.2exit函数

#include <unistd.h>
void exit(int status);

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

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

• 实例：

int main()
{
printf("hello");
exit(0);
}
运行结果:
[root@localhost linux]# ./a.out
hello[root@localhost linux]#

int main()
{
printf("hello");
_exit(0);
}
运行结果:
[root@localhost linux]# ./a.out
[root@localhost linux]#

2.2.3 return退出

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

3.进程等待

1. 进程等待是什么？
   通过系统调用wait/waitpid，来进行对子进程进行状态检测与回收的功能!
2. 为什么要进程等待？
   (1)僵尸进程无法被杀死，需要通过进程等待来杀掉它，进而解决内存泄漏问题— 必须解决的
   (2)我们要通过进程等待，获得子进程的退出情况 – 知道我布置给子进程的任务，它完成的怎么样了 - 要么关心，也可能不关心——可选的
3. 怎么办，如何实现进程等待?
   代码:
   父进程通过调用wait/waitpid进行僵尸进程的回收问题!

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

3.1 进程等待的方法

3.1.1 wait方法

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

1. int wait(int* status)

• 功能：阻塞等待任意一个子进程的退出。（意味着如果当前有子进程且都没有退出就会阻塞进程一直等待。）
  阻塞等待：为了完成一个功能，我们发起了一个调用，如果功能不能立即完成则一直等待
• 参数： int * status 一个int整形空间的地址，用于存放退出码。
• 返回值：成功则返回退出的子进程的pid，失败返回-1(比如没有子进程)

3.1.2 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:
WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出）
WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的退出码）
options:
WNOHANG: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进
程的ID。

• int waitpid(pid_t pid, int* status, int option);

• 功能：等待一个子进程退出，但是可以等待指定的子进程，以及可以进程非阻塞等待。
  非阻塞等待：为了完成一个功能，我们发起了一个调用，如果功能不能立即完成则接口立即报错返回。

• 参数：
  pid_t pid ——用于指定等待子进程的pid，如果为-1则表示等待任意一个子进程。
  int* status——整形空间地址，用于获取退出码
  int option——设置阻塞标志，0-表示阻塞等待；WNOHANG-表示非阻塞等待

• 返回值：大于0表示处理的退出子进程的pid;等于0表示当前没有子进程退出（适用于非阻塞等待）；返回值小于0表示出错了，

• 代码演示：
  结果：
  

3.1.3 实现流程

• 如果子进程已经退出，调用wait/waitpid时，wait/waitpid会立即返回，并且释放资源，获得子进程退出信息。

• 如果在任意时刻调用wait/waitpid，子进程存在且正常运行，则进程可能阻塞。

• 如果不存在该子进程，则立即出错返回。

3.1.4 获取子进程status

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

4. 程序替换

1. 程序替换定义：
   一个进程正在调度管理的程序。通常很少替换当前进程调度的程序，而是创建子进程之后。替换子进程所运行的程序。
2. 替换原理：
   用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支),子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时,该进程的用户空间代码和数据完全被新程序替换,从新程序的启动例程开始执行。调用exec并不创建新进程,所以调用exec前后该进程的id并未改变。
   
3. 替换函数1
   输入: man execl 得到下图
   
   其中 extern char **environ;（是一个全局变量的声明，是一个二级指针，这个全局变量中保存了所有的环境变量）
   4.函数：int execve(const char *path, char *const argv[], char *const envp[]);
   path:要替换的新程序的路径名；
   argv:传递给新程序的运行参数；
   env：传递给新的程序的环境变量，设置为environ则表示传递默认已有的环境变量，如果自定义就是给什么有什么。
   返回值：失败返回-1；成功返回0
   注意：程序替换函数如果替换成功，则这个函数调用之后的代码都不会被运行，因为程序已经被替换成为新程序，而新程序运行完毕之后，进程就退出了（不会返回之前的程序运行）
4. 替换函数:
   linux下的：
   （1）

#include <unistd.h>
int execl(const char *path, const char *arg, ...);

path：程序路径名；
argv…不定参：参数单个赋予，不需要组织成为指针数组，但是以NULL结尾；环境变量使用默认已有的。
（2）

int execlp(const char *filename, const char *arg, ...);

filename：程序不用给路径，只给名字就行，会自动默认到PATH环境变量指定的路径下去找。
（3）

int execle(const char *path, const char *arg, ...,char *const envp[]);

相比较（1）和（2），由自己设置环境变量。不使用默认环境变量。
注意：
有没有p（没有p则需要给程序路径名。有p则需要给名称不需要路径，但是程序必须在环境变量PATH指定的路径下，常用于命令）；
有没有e（没有e则需要使用默认的环境变量，有e则需要设定环境变量）
（4）

int execv(const char *path, char *const argv[]);

程序给路径名，不需要设定环境变量使用默认。

5. 编写一个minishell

shell：命令解释器，知道用户干什么，然后执行对应的功能程序，完成用户的要求。shell功能流程：

1. 捕捉键盘输入[ ls -l -a ] —— gets（char *buf)：获取一行数据
   
2. 字符串解析得到指令名称和运行参数 [ls] [-a] [-l ]
3. 创建子进程（执行指令程序（程序替换），但是如果替换了当前shell为新的指令程序，则命令运行完毕，shell就没有了）
4. 在子进程中进行程序替换，让子进程运行命令程序—— execvp:用数组进行存储
   
5. 等待子进程退出，避免子进程成为僵尸进程—— wait()
   
6. 循环上去，重新继续捕捉输入

minishell.c:


结果：