Linux进程控制

最新推荐文章于 2023-05-12 21:41:59 发布

没什么..

最新推荐文章于 2023-05-12 21:41:59 发布

阅读量217

点赞数 5

分类专栏： Linux

本文链接：https://blog.csdn.net/MEANSWER/article/details/114818085

版权

Linux 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

进程控制

1. 进程创建
- 1.1 fork函数初识
- 1.2 写时拷贝
2. 进程终止
3. 进程等待
4. 进程程序替换
- 4.1 替换函数

1. 进程创建

1.1 fork函数初识

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

pid_t fork(void); 这个函数会有两个返回值（给子进程返回0，给父进程返回子进程的pid），那么为什么会这样呢？

第一种理解方式：对于一个父进程来说，是可以有多个子进程的，那么对于父进程如何去调用哪一个子进程时需要pid来标识每个子进程，但是这些子进程们共同都认识这个父进程，所以给子进程返回0，给父进程返回子进程的pid。

第二种理解方式：对于一个父子进程来说，谁先被调度完全取决于调度器说了算，被调度以后子进程return返回，父进程也return返回，所以就会有两个值。
在这里插入图片描述
需要的头文件为#include<unistd.h> #include<sys/types.h>
进程调用fork（属于系统调用），当控制转移到内核中的fork代码后，内核做：

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

1.2 写时拷贝

对于父子进程来说，代码是共享的，数据是各自私有的。（其中代码是共享的，是整个进程中的代码都是共享的（并不是fork之后才共享），但是有的时候由于if /if else/else 进行了分流，导致父子进程所执行了不同的代码块，但是其实在子进程中依旧是有父进程那一块的代码的，只是不需要执行罢了）

那么为什么父子进程代码要共享呢？
程序=代码（逻辑）+ 数据，代码存放在内存中的代码段，被设置为了只读属性，没有权限修改，如果我们让父子进程都各自私有一份代码，带来的结果就是对于OS内存空间的浪费（因为不能修改，他们所看到的都是一样的内容，所以就没有必要私有了）

数据为什么要各自私有呢？（其实也是相对的，当父子进程的数据都没有发生修改的时候，连数据都是共有的）
如果你修改了子进程的数据，那么父进程相对于的数据也发生了修改，这种情况是不允许的。因为进程之间具有独立性。

所以这里引入写时拷贝：父子代码共享，父子再不写入时，数据也是共享的，当任意一方试图写入，便以写时拷贝的方式各自一份副本。具体见下图:
在这里插入图片描述
在没有修改前数据段被设置为了只读状态，父子进程谁先写入，就会报错，OS就会去处理这个错误，并以写时拷贝的方式向需要修改的那个数据段写入数据，这样做的好处就是节省空间和时间。

写时拷贝的本质：修改了页表和物理地址之间的映射关系

for调用失败的原因：

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

2. 进程终止

进程退出场景

代码运行完毕，结果正确
代码运行完毕，结果不正确（前两个都用退出码来标识）
代码异常终止（此时退出码就没有意义了，而退出原因才有意义）

进程常见退出方法
正常终止（可以通过 echo $? 查看最近一次进程退出码）：

从main返回
调用exit
_exit

异常退出：

ctrl + c，信号终止

为什么我们一般所编写的程序最终要加return 0呢？那是由于main函数退出的时候，return的数字叫做进程的退出码，而0在函数设计中，一般代表的是正确，非零则是错误的（当退出码是1,2，3,4等的时候，每一个退出码的数字则代表了一种错误的情况）

exit和return的区别
exit：终止整个进程，任何地方调用，都会终止，eixt(参数)这个参数就是退出码
return：叫做终止函数(只有在main函数中代表进程终止，在函数里面代表函数返回)，并不会杀死整个进程。

exit（C的库函数）和_exit（系统调用）的区别？

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

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

在这里插入图片描述

3. 进程等待

子进程被创建出来，父子进程谁先运行，是由调度器说了算的，但是谁先退出呢？一般而言，我们通常要让子进程先退出，为什么呢？因为父进程可以很容易对子进程进行管理（垃圾回收），其次子进程被创建出来的目的是去处理业务，所以需要父进程帮我们拿到子进程执行的结果。

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

3.1 wait

父进程没有回收子进程的情况，在这种情况下一直在资源浪费

  1 #include<iostream>
  2 #include<sys/types.h>
  3 #include<unistd.h>
  4 #include<stdlib.h>
  5 using namespace std;
  6 
  7 int main()
  8 {
  9   pid_t id = fork();
 10   if(id < 0){
 11     cerr<< "error"<<endl;
 12   }
 13   else if(id == 0){
 14     int count = 0;
 15     while(1){
 16       sleep(1);
 17       cout<< "child... :"<<count<<endl;
 18       count++;
 19       if(count >= 10){
 20         break;
 21       }
 22     }
 23     exit(0);
 24   }
 25   else{
 26     while(1){
 27       sleep(1);
 28       cout<<"father..."<<endl;
 29     }
 30   }
 31   cout << "hello world"<<endl;                                                          
 32 }

在这里插入图片描述

父进程等待子进程，并回收。

  1 #include<iostream>
  2 #include<sys/types.h>
  3 #include<unistd.h>
  4 #include<stdlib.h>
  5 #include<sys/wait.h>
  6 using namespace std;
  7 
  8 int main()
  9 {
 10   pid_t id = fork();
 11   if(id < 0){
 12     cerr<< "error"<<endl;
 13   }
 14   else if(id == 0){
 15     int count = 0;
 16     while(1){
 17       sleep(1);
 18       cout<< "child... :"<<count<<endl;
 19       count++;
 20       if(count >= 10){
 21         break;
 22       }
 23     }
 24     exit(0);
 25   }
 26   else{
 27     int count = 0;
 28     while(1){
 29       sleep(1);
 30       cout<<"father..."<<endl;
 31       count++;
 32       if(count >= 15){
 33         break;
 34       }
 35     }
 36     wait(NULL);                                                                         
 37   }
 38   cout << "hello world"<<endl;
 39 }

在这里插入图片描述

3.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): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出） (st & 0x7f)
WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的退出码） ((st>>8)&0xff)
options:
WNOHANG: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID。0表示阻塞方式：你不给我结果我不返回，一直等待着。

3.2.1 获取子进程status

wait和waitpid，都有一个status参数，该参数是一个输出型参数，由操作系统填充。（输出型参数：定义了一个 int st = 0; waitpid(pid,&st,0),父进程开始等待，子进程退出后，操作系统就会从进程PCB中读取退出信息，保存在这个status指向的变量中）
如果传递NULL，表示不关心子进程的退出状态信息。否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程。
status不能简单的当作整形来看待，可以当作位图来看待，具体细节如下图（只研究status低16比特位）：

在这里插入图片描述
图中的正常终止和被信号所杀两种情况是排斥的，只可能有一种情况出现，如果子进程退出正常那么对于status的最后一个字节应该为0，只有这种情况表示正常退出（此时退出又分为两种：代码跑完，结果正确和代码跑完，结果不正确），当正常退出的时候，又要考虑是哪一种退出，所以需要查看其退出码，就是status的倒数第二个字节的结果。如果出现返回非零就是被信号所杀了的情况，这种情况就可以在kill -l 中查找到原因。

3.3 进程等待总结

进程等待是什么？
是父进程通过wait等系统调用，用来等待子进程状态的一种现象，这个等待是必须的

为什么？
1.防止子进程发生僵尸问题，进而产生内存泄漏
2.读取子进程状态

怎么办？
wait/waitpid，status（singal，exit code）

4. 进程程序替换

fork创建子进程目的是什么？：
1.想让子进程执行父进程代码的一部分（富二代子承父业）
2.想让子进程执行和父进程完全不同的事情（富二代创业）

进程程序替换：
把磁盘上的数据和代码覆盖式的以写时拷贝的方式写入物理内存中，就相当于直接把进程全部替换掉了。

用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支),子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时,该进程的用户空间代码和数据完全被新程序替换,从新程序的启动例程开始执行。调用exec并不创建新进程,因为没有产生新的PCB，且调用exec前后该进程的id并未改变。
在这里插入图片描述

4.1 替换函数

其实有六种以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[]);
（所以函数的第一个参数都代表你想执行谁，第二个参数表示你想在命令行以什么形式调用，那么在参数中就怎么传递，最后以NULL来结尾，表示就这样子执行）

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

命名解释

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

在这里插入图片描述
我想让我写的myexe执行我所写的mycmd程序。
Makefile
如果没有开始的伪目标all，那么当你输入make的时候，只会默认优先编译写在前面的那个。

  1 .PHONY:all
  2 all:myexe mycmd
  3 
  4 myexe:myexe.c
  5   gcc -o $@ $^
  6 
  7 mycmd:mycmd.c
  8   gcc -o $@ $^
  9 .PHONY:clean
 10 clean:
 11   rm -f myexe mycmd

myexe.c

  1 #include<stdio.h>
  2 #include<unistd.h>
  3 
  4 int main(int argc,char* argv[],char* env[])
  5 {
  6   printf("begin.................\n");
  7  //sleep(1);
  8  //execl("/usr/bin/ls","ls","-a","-i","-l",NULL); // 1
  9 
 10  //execlp("ls","ls","-a","-i","-l",NULL); // 2
 11 
 12   //char *arg[] ={
 13   // "ls",
 14   // "-a",
 15   //  "-i",
 16   //  "-l",
 17   // NULL,                                                                           
 18   //};                                               
 19   //execv("/usr/bin/ls",arg);   //3   
 20   //execvp("ls",arg); //4
      //execle("./mycmd","./mycmd","NULL",env);

 21   execl("./mycmd","./mycmd",NULL);                                           
 22   printf("you should running here!.....\n");                                                                                                                                            
 23   return 0;             
 24 }

mycmd.c

  1 #include<stdio.h>
  2 
  3 int main()
  4 {
  5   int i = 0;
  6   int sum = 0;
  7   for(;i<=100;i++){
  8     sum += i;
  9   }
 10 
 11   printf("result[1-100] : %d\n",sum);
 12   return 0;                                                                                                                                                                             
 13 }

在这里插入图片描述
事实上,只有execve是真正的系统调用,其它五个函数终都调用 execve

没什么..

关注

5
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Linux进程控制

进程控制1. 进程创建1.1 fork函数初识1.2 写时拷贝2. 进程终止3. 进程等待3.1 wait3.2 waitpid1. 进程创建1.1 fork函数初识在linux中fork函数时非常重要的函数，它从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程（子进程是以父进程为模板创建的）pid_t fork(void); 这个函数会有两个返回值（给子进程返回0，给父进程返回子进程的pid），那么为什么会这样呢？第一种理解方式：对于一个父进程来说，是可以有多个子进程的，那么对于父进
复制链接

扫一扫