进程控制

最新推荐文章于 2022-09-11 22:08:07 发布
最新推荐文章于 2022-09-11 22:08:07 发布
阅读量283 收藏
点赞数
分类专栏： Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43766018/article/details/115752108
版权

进程创建

1.vfork函数
vfork函数创建出来的子进程的虚拟地址空间和父进程共用一份，如果父子进程同时并行运行，有可能会导致函数调用栈混乱。
vfork解决函数调用栈混乱的方式：子进程先运行，子进程运行完毕之后，父进程再运行

2.fork函数

#include <unistd.h>

pid_t fork();
// 返回值：
// fork成功：父进程返回子进程id；子进程返回0
// fork失败：返回-1

进程终止

1、正常终止：代码运行完毕

正常终止方式：

1）main函数的return返回
① 代码运行完毕，结果正确
② 代码运行结束，结果不正确

2）_exit函数：系统调用函数，操作系统为程序员提供的函数

#include <unistd.h>

void _exit(int status);
// status：定义了进程的终止状态，父进程通过wait来获取该值

代码示例：

 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <unistd.h>
  4 #include <sys/wait.h>
  5 
  6 int main()
  7 {
  8   printf("Hello");
  9   _exit(0);                                                                                     
 10 }

在这里插入图片描述
3）exit函数：库函数，C库当中为程序员提供的函数

#include <unistd.h>

void exit(int status);

代码示例：

#include <stdio.h>
  2 #include <unistd.h>
  3 #include <stdlib.h>                                                                             
  4 #include <sys/wait.h>
  5 
  6 int main()
  7 {
  8   printf("Hello");
  9   exit(0);
 10 }

在这里插入图片描述

  • _exit和exit的区别

exit会刷新缓冲区
1）缓冲区是在C库当中维护的，并不是操作系统内核维护的
2）刷新缓冲区的方式
① main函数的return返回
② fflush函数可以强制刷新缓冲区
③ \n也会刷新缓冲区
④ exit函数也会刷新缓冲区

  • atexit：
    作用：注册终止函数(即main执行结束后调用的函数)
    atexit函数可以注册一个函数，当程序结束的时候，再来执行注册的函数，这个被注册的函数称之为回调函数
#include <stdlib.h>

void atexit(void(*func)(void));

2、异常终止：代码没有执行完毕
异常终止方式：
1）调用abort
2）接到一个信号并终止
3）最后一个线程对取消请求做出响应

进程等待

1、作用：防止僵尸进程的产生

2、进程等待的方法
1）wait函数：阻塞等待

#include <sys/types.h>
#include <sys/wait.h>

pid_t wait(int* status);
// status：出参 参数类型为int 获取子进程退出状态
// 返回值：
//      成功：返回被等待进程pid
//      失败：返回-1

代码示例：验证wait函数是阻塞等待

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>

int main()
{
  pid_t pid = fork();
  if(pid < 0)
  {
    perror("fork");
    return 0;
  }
  else if(pid == 0)
  {
    int count = 5;
    //1int* lp = NULL  
    //*lp = 10; 
    while(count > 0)
    {
      printf("i am child pid:%d, ppid:%d\n", getpid(), getppid());
      count--;
      printf("%d\n", count);
      sleep(1);
    }
    exit(10);
  }
  else{
    printf("BEGIN...i am father pid:%d, ppid:%d\n", getpid(), getppid());

    int st;
    wait(&st); // st中保存了子进程异常退出发送的信号
    printf("sig_code: %d\n", st & 0x7f); 
    printf("coredump_code: %d\n", (st>>7) & 0x1); 
    
    // 如果是wait函数是阻塞等待，那么一定要等到
    while(1)                                                                      
    {
      printf("i am father pid:%d, ppid:%d\n", getpid(), getppid());                           
      sleep(1);                                                                   
    }
  }
  return 0;
}

在这里插入图片描述
2）waitpid函数

#include <sys/types.h>
#include <sys/wait.h>

pid_t waitpid(pid_t pid, int* status, int options);
// 参数
// pid：告诉waitpid函数，需要等待的进程
//      传-1：表示等待任意子进程
//      pid > 0：表示等待指定子进程，传入的pid就是子进程的进程号
// status：出参，获取子进程退出状态
// options：
//        0：阻塞
//        WNOHANG：非阻塞 如果调用非阻塞，当子进程没有退出时，waitpid函数会报错返回

代码示例：以被等待进程正常终止为例

1.waitpid阻塞等待

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>

int main()
{
  pid_t pid = fork();
  if(pid < 0)
  {
    perror("fork");
    return 0;
  }
  else if(pid == 0)
  {
    int count = 10;
    while(1)
    {
      if(count < 1)
      {
        break;
      }
      printf("I am child: pid = %d, ppid = %d\n", getpid(), getppid());
      count--;
      sleep(1);
    }
    exit(10);
  }
  else{
    printf("BEGIN...i am father: pid = %d, ppid = %d\n", getpid(), getppid());

    int st;
    // 阻塞等待
    // 此时，父进程将会阻塞在waitpid函数，直到子进程中count减到0，退出循环，然后执行exit(10)
    // 父进程等待成功后，拿到st，因为子进程是正常退出，所以st中使用高8位，可以获取退出码10
    waitpid(-1, &st, 0);
    printf("exit_code: %d\n", (st >> 8) & 0xff); // 10
    printf("sig_code: %d\n", st & 0x7f); // 0
    printf("coredump_code: %d\n", (st >> 7) & 0x1); // 0
    
    // 下面这段代码只是为了验证是否阻塞
    // 如果阻塞，那么这段代码要到子进程退出，父进程等待成功才会打印
    // 如果非阻塞，那么这段代码
    while(1)
    {
      printf("I am father:pid = %d, ppid = %d\n", getpid(), getppid());
      sleep(1);
    }
  }

  return 0;
}

在这里插入图片描述
2. waitpid非阻塞等待：一般要搭配循环使用

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>

int main()
{
  pid_t pid = fork();
  if(pid < 0)
  {
    perror("fork");
    return 0;
  }
  else if(pid == 0)
  {
    int count = 10;
    while(1)
    {
      if(count < 1)
      {
        break;
      }
      printf("I am child: pid = %d, ppid = %d\n", getpid(), getppid());
      count--;
      sleep(1);
    }
    exit(10);
  }
  else{
    printf("BEGIN...i am father: pid = %d, ppid = %d\n", getpid(), getppid());

    int st;
    // 非阻塞等待
    // 此时，如果子进程未执行完毕，父进程的waitpid直接返回并报错
    // 非阻塞一般会搭配循环使用
    while((waitpid(-1, &st, WNOHANG)) == 0);
    printf("exit_code: %d\n", (st >> 8) & 0xff); 

    // 异常退出后边两行代码的值才不会为0
    printf("sig_code: %d\n", st & 0x7f); 
    printf("coredump_code: %d\n", (st >> 7) & 0x1);

    // 下面这段代码只是为了验证是否阻塞
    // 如果阻塞，那么这段代码要到子进程退出，父进程等待成功才会打印
    // 如果非阻塞，那么这段代码
    while(1)
    {
      printf("I am father:pid = %d, ppid = %d\n", getpid(), getppid());
      sleep(1);
    }
  }

  return 0;
}

在这里插入图片描述

  • wait和waitpid的关系
  1. waitpid(pid>0, status, 0)相当于wait函数
  2. wait函数就是调用waitpid函数实现的

3、获取子进程status
1）status的类型是int，但是它只用到后两个字节；
2）进程正常退出时，高8位被使用，低8位为0；高8位保存的是程序的退出码；
获取退出码：(ststus >> 8) & 0xFF
在这里插入图片描述

3）进程异常退出时，只用到低8位；其中低7位表示进程收到的终止信号，第8位是coredump标志位
获取coredump标志位：(status>>7) & 0x1
获取进程终止信号：(status) & 0x7f
在这里插入图片描述
代码示例：被等待进程正常终止情况可参考上面代码；这里只验证异常终止的status(用wait函数测试)

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

// 异常终止时，coredump标志位的获取及终止信号的获取
int main()
{
  pid_t pid = fork();
  if(pid < 0)
  {
    perror("fork");
    return 0;
  }
  else if(pid == 0)
  {
    // 空指针赋值，会产生段错误，异常终止信号为11
    int* p = NULL;
    *p = 7;

    // 下边代码用来判断异常终止时，代码是未执行完的
    while(1)
    {
      printf("child pid = %d\n", getpid());
      sleep(1);
    }
  }
  else{
    int status;
    waitpid(-1, &status, 0);

    printf("coredump_code : %d\n", (status >> 7) & 0x1);
    printf("sig_code : %d\n", status & 0x7f);
  }

  return 0;
}

在这里插入图片描述

进程程序替换

1、替换原理
原因：父进程创建出来的子进程的虚拟地址空间拷贝了一份父进程的虚拟地址空间，所以父子进程执行相同的代码，但是，创建子进程往往是为了让子进程去干和父进程不同的事情，所以就有了进程程序替换。
原理：进程替换并不是新创建了一个进程，而是将已经存在的进程替换为别的可执行程序，然后执行替换后的程序的代码，所以进程号没有改变

2、替换函数：exec函数簇

  • 先简单介绍下函数名：
    函数名中带v表示，参数采用vector来保存；带l表示，参数用list来保存
    函数名中带p表示，会自动搜索环境变量，只传入可执行程序名称即可；不带p表示，不会自动搜索环境变量，所以要传递带路径的可执行程序名称
    函数名中带e表示，需要程序员自己组织环境变量；不带e表示，不需要自己组织环境变量
  • 返回值：
    调用成功：则加载新的程序，从启动代码执行，不再返回；调用失败：返回-1
  • 除了execve是系统调用函数外，其余五个(execl、execlp、execle、execv、execvp)都是库函数

1）execl函数

#include <unistd.h>

int execl(const char* path, const char* arg, ...);
// path：带路径的可执行程序 带替换的程序
// arg：给替换的可执行程序传递参数，相当于在命令行中给可执行程序传递命令行参数
//     ...：可变参数列表
//         规定：
//             a.第一个传递的参数必须是可执行程序的名称
//             b.如果后面还有要传递的参数，使用","进行间隔，依次传递
//             c.以NULL结尾，告诉execl函数，参数传递完毕

2）execlp函数

#include <unistd.h>

int execlp(const char* file, const char* arg, ...);
// file：待替换的可执行程序名称
//       注意：替换的可执行程序必须是在PATH环境变量中可以找到的；也可以传递带路径的可执行程序

3）execle函数

#include <unistd.h>

int execle(const char* path, const char* arg, ..., char* const envp[]);
// path：带路径的可执行程序
// envp：程序员自己组织环境变量，如果不传入，则认为当前替换后的进程没有环境变量

4）execv函数

#include <unistd.h>

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

5）execvp函数

#include <unistd.h>

int execvp(const char* file, char* const argv[]);

6）execve函数

#include <unistd.h>

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

代码示例：进程替换函数的使用

#include <stdio.h>
#include <unistd.h>

int main()
{
  // 函数名中带e的需要自己组织环境变量
  char* const envp[] = {"PATH = /bin:/usr/bin", "TERM = console", NULL};
  // execl系列函数，参数用列表
  execl("/bin/ps", "ps", "-ef", NULL);

  execlp("ps", "ps", "-ef", NULL);

  execle("/bin/ps", "ps", "-ef", NULL, envp);

  // execv系列函数中，参数用数组保存，传递时直接传数组
  char* const argv[] = {"ps", "-ef", NULL};

  execv("/bin/ps", argv);

  execvp("ps", argv);

  execve("bin/ps", argv, envp);

  return 0;
}
weixin_43766018
关注
专栏目录
Linux和Windows系统线程间的区别
ozdazm的专栏
01-24 717
WIN32里同一个进程里各个线程之间是共享数据段的。是与Linux的进程最大的不同。 linux的线程也可以成为轻量级进程。 linux中，pid_tfork( void);返回值：若成功调用一次则返回两个值，子进程返回0，父进程返回子进程ID；否则，出错返回-1 由于在复制时复制了父进程的堆栈段，所以两个进程都停留在fork函数中，等待返回。因为fork函数会返回两次，一次是在父进
LinuxC应用开发学习笔记（十四）—管道算法和进程间通信
梅山
01-12 452
管道算法和进程间通信 管道的实现 #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/wait.h> #define BUFSIZE 1024 int main() { int pd[2],len = 0; __pid_t pid; char buf[BUFSIZE]; if(pipe(pd)<0) {
进程与线程测试题
qq_58397358的博客
11-11 2947
选择题(40分) 1. 如果键盘输入为abcdef，程序如下所示，打印结果应该是( c) char buffer[6]; …… fgets(buffer, 6, stdin); printf(“%s”, buffer); [A] abcde [B] abcdef [C] abcdef 后出现乱码 [D] 段错误 2. fread()返回值的含义是 ( B) [A] 读取的字节数 [B] 读取的对象数 ...
进程间通信 函数mmap用法 （linux系统编程）
qq_24447809的博客
09-05 329
#include<stdio.h> #include<stdlib.h> #include<unistd.h> #include<fcntl.h> #include<sys/types.h> #include<sys/mman.h> #include<string.h> int main() { int fd,len,ret; char* p=NULL; fd=open("mytest.txt",O_
（20220428）进程控制编程
weixin_53812805的博客
04-28 1311
目录 一、理论基础 1、进程定义 2、进程与程序 3、进程的生命周期 4、查看进程命令 5、父进程与子进程 6、进程的状态 7、Linux 进程 8、Linux下进程地址空间 9、进程ID 10、进程互斥 11、临界资源 12、临界区 13、进程同步 14、进程调度 15、调度算法（多种结合） 16、死锁 17、僵尸进程 二、进程控制编程 1、获取ID 2、创建进程 3、exec函数族 4、进程等待 一、理论基础 1、进程定义 进程是资源分配的最.
linux实验四 进程控制实验
02-09
【进程控制实验】是Linux操作系统课程中的一个重要环节，旨在帮助学生深入理解进程的概念以及进程间的交互。通过实验，学生能够掌握以下关键知识点： 1. **进程的概念与程序的区别**： 进程是操作系统资源分配的...
操作系统进程控制实验报告.doc
最新发布
12-22
操作系统进程控制实验报告 本实验报告主要讲述了操作系统进程控制的实验报告，涵盖了进程概念、并发概念、信号机理、进程控制等知识点。下面是对实验报告的详细解读和知识点总结： 1. 进程概念： 进程是操作系统...
操作系统实验一：进程控制
01-14
操作系统实验一：进程控制 本实验旨在加深对进程概念的理解，掌握 Linux 操作系统的进程创建和终止操作，体会父进程和子进程的关系及进程状态的变化，并编写并发程序。 一、进程概念 在计算机科学中，进程是操作...
操作系统进程控制C++代码实现
05-25
利用简单的结构和控制方法模拟进程结构、进程状态和进程控制。 内容： 1.能够模拟进程的创建与撤销过程； 2.可对进程的状态进行全面的控制； 3.按先进先出方式管理就绪和阻塞队列，能够按队列形式输出进程状态 4....
进程控制习题（考试必备）
05-22
一、什么是进程控制 进程控制的主要功能是对系统中的所有进程实施有效的管理，它具有创建新进程、撤销已有进程、实现进程状态之间的转换等功能。 简而言之就是：进程控制就是实现进程状态的转换。 二、如何实现...
南邮操作系统——实验二——进程控制
qq_43808588的博客
03-04 3225
实验要求： 学习和了解进程控制的基本和常用的系统调用 fork wait sleep exit exec 等等。 查看 /usr/src/include/sched.h中的task_struct 数据结构，并分析Linux 操作系统进程状态。 通过进程创建的应用实例，深刻理解进程创建的过程。 思考题： 1、当首次调用新创建进程时，其入口在哪里？ 2、可执行文件加载时进行了哪些处理？ ...
一些函数的头文件<stdio.h><unistd.h><sys/types.h><stdlib.h><sys/wait.h>头文件的作用
u013176681的专栏
08-22 2764
不用说，大家都懂得，就是一堆输入输出
Linux系统编程——进程的控制：结束进程、等待进程结束
热门推荐
秋叶原 && Mike || 麦克
05-22 5万+
当一个进程正常或异常终止时，内核就向其父进程发送 SIGCHLD 信号，相当于告诉父亲他哪个儿子挂了，而父进程可以通过 wait() 或 waitpid() 函数等待子进程结束，获取子进程结束时的状态，同时回收他们的资源（相当于，父亲听听死去儿子的遗言同时好好安葬它）。
Linux系统编程（进程相关知识点）
weixin_48321071的博客
05-16 261
一.进程相关概念 1.1 什么是程序？什么是进程？有什么区别？ 程序是静态的概念，gcc xxx.c -o pro，磁盘中生成的pro，叫做程序 进程是程序的一次运行活动，就是程序跑起来了，系统中就多了一个进程 1.2 如何查看系统中有哪些进程？ 1.使用ps指令查看 实际工作中，配合grep 来查找程序中是否存在某一进程 ps -aux:查看所有进程 ps -aux|grep xxx:用grep管道过滤出我们想要的进程信息 2.使用top指令查看，类似于windows的任务管理器 1.3 什么是进程标
Linux进程的详细内容
weixin_46068274的博客
09-11 1141
Linux的进程极为重要！俗称连环！内存 进程 线程
南京邮电大学操作系统——实验一：进程、线程的创建与并发执行
weixin_42559271的博客
10-08 3448
实验环境 Ubuntu 18.04 Visual Code 实验记录 实验一：观察进程标识符 所用代码如下： #include <stdio.h> #include <sys/types.h> #include <unistd.h> int main() { //pid_t是数据类型，实际上是一个整型，通过typedef重新定义了一个名字，用于存储进程id pid_t pid; //scanf("%d",&i);//让进程等待，方便使用shell观
printf行缓冲的概念以及刷新缓冲区的条件
乐行僧的博客
05-18 4438
什么是输出缓冲区？ 引入缓冲区的目的是什么？ 输出缓冲区的概念： 缓冲区刷新的条件： 1.缓冲区满。 2.遇到\n。 3.手动刷新缓冲区fflush(stdout)。 4.程序结束时。...
嵌入式Linux进程控制详解
"国嵌进程控制文档主要涵盖了进程控制的基础理论和编程实践，旨在帮助读者理解和掌握如何在Linux系统中有效地进行进程管理。文档强调了进程的动态性、并发性、独立性和异步性等核心特点，并介绍了进程的状态、标识符...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值