进程的状态与转换、进程控制

最新推荐文章于 2024-01-03 18:34:10 发布
最新推荐文章于 2024-01-03 18:34:10 发布
阅读量973 收藏 2
点赞数 1
分类专栏： 操作系统（OS）学习笔记 文章标签： 操作系统
帅气的HKpeng
本文链接：https://blog.csdn.net/qq_42483691/article/details/104866064
版权

文章目录

1. 进程的状态与转换

1.1 进程的状态1

进程是程序的一次执行。在这个执行的过程中，有时进程正在被CPU处理，有时又需要等待CPU服务，可见，进程的状态是会有各种变化。为了方便对各进程的管理，操作系统需要将进程合理地划分为几种状态。

三种基本运行状态

  • 运行态（Running）：占有CPU，并在CPU上运行

注意：单核处理机（CPU）环境下，每一时刻最多只有一个进程处于运行态。（双核环境下可以同时有两个进程处于运行态）

  • 就绪态（Ready）：已经具备运行条件，但由于没有空闲CPU，而暂时不能运行

该状态下的进程已经拥有了除处理机（CPU）之外所有需要的资源，一旦获得处理机，即可立即进入运行态开始运行。即：万事俱备，只欠CPU。

  • 阻塞状态（Waiting/Blocked，又称：等待态）：因等待某一事件而暂时不能运行

如：等待操作系统分配打印机、等待读磁盘操作的结果。CPU是计算机中最昂贵的部件，为了提高CPU的利用率，需要先将其他进程需要的资源分配到位，才能得到CPU的服务

另外两种状态

  • 创建态（）New，又称：新建态：进程正在被创建，操作系统为进程分配资源、初始化PCB

操作系统需要完成创建进程。操作系统为该进程分配所需的内存空间等系统资源，并为其创建、初始化PCB（如：为进程分配PID）

  • 终止态（Terminated，又称：结束态）：进程正在从系统中撤销，操作系统会回收进程拥有的资源、撤销PCB

进程运行结束（或者由于bug导致进程无法继续执行下去，比如数组越界错误），需要撤销进程。
操作系统需要完成撤销进程的工作。完成将分配给进程的资源回收，撤销进程PCB等工作

1.2 进程状态间的转换

在这里插入图片描述

  • 就绪态—>运行态：进程被调度，需恢复进程运行环境、修改PCB内容和相应队列。
  • 运行态—>就绪态（进程切换）：时间片到，或CPU被其他高优先级的进程抢占，需保存进程运行环境、修改PCB内容和相应队列。
  • 运行态—>阻塞态：等待系统资源分配，或等待某件事发生（主动行为），需保持进程运行环境、修改PCB内容和相应队列。
  • 阻塞态—>就绪态：资源分配到位，等待的事件发生（被动行为），需修改PCB内容和相应队列。如果等到的是资源，则还需为进程分配系统资源。
  • 创建态—>就绪态：系统完成创建进程相关的工作，需修改PCB内容和相应队列。
  • 运行态—>终止态：进程运行结束，或运行过程中遇到不可修复的错误

2. 进程控制

2.1 基本概念

什么是进程控制？
进程控制的主要功能是对系统中所有进程实施有效的管理，它具有创建新进程、撤销已有进程、实现进程状态转换等功能。

简化理解：反正进程控制就是实现进程状态转换如何实现进程控制？用“原语”实现

如何实现进程控制？
用原语实现进程控制。原语的特点是执行期间不允许中断，只能一气呵成。这种不可被中断的操作即原子操作。
原语采用“关中断指令”和“开中断指令”实现
显然，关/开中断指令的权限非常大，必然是只允许在核心态下执行的特权指令

2.2 进程控制的相关原语

学习技巧：进程控制会导致进程状态的转换。无论哪个原语，要做的无非三类事情：

  1. 更新PCB中的信息（如修改进程状态标志、将运行环境保存到PCB、从PCB恢复运行环境）

    a. 所有的进程控制原语一定会修改进程状态标志
    b. 剥夺当前运行进程的CPU使用权必然需要保存其运行环境
    c. 某进程开始运行前必然要恢复其运行环境

  2. 将PCB插入合适的队列
  3. 分配 / 回收资源

  • 进程的创建

    • 创建原语（无—>创建态—>就绪态）
      • 申请空白PCB
      • 为新进程分配所需资源
      • 初始化PCB
      • 将PCB插入就绪队列
    • 引起进程创建的事件
      • 用户登录：分时系统中，用户登录成功，系统会为其建立一个新的进程
      • 作业调度：多道批处理系统中，有新的作业放入内存时，会为其建立一个新的进程
      • 提供服务：用户向操作系统提出某些请求时，会新建一个进程处理该请求
      • 应用请求：由用户进程主动请求创建一个子进程

  • 进程的终止

    • 撤销原语（就绪态 / 阻塞态 / 运行态—>终止态 —>无）
      • 从PCB集合中找到终止进程的PCB
      • 若进程正在运行，立即剥夺CPU，将CPU分配给其他进程
      • 终止其所有子进程
      • 将该进程拥有的所有资源归还给父进程或操作系统
      • 删除PCB
    • 引起进程终止的事件
      • 正常结束
      • 异常结束
      • 外界干预

进程的阻塞和唤醒2

  • 进程的阻塞
    • 阻塞原语（运行态—>阻塞态）
      • 找到要阻塞的进程对应的PCB
      • 保护进程运行现场，将PCB状态信息设置为“阻塞态”，暂时停止进程运行
      • 将PCB插入相应事件的等待序列
    • 引起进程阻塞的事件
      • 需要等待系统分配某种资源
      • 需要等待相互合作的其他进程完成工作
  • 进程的唤醒
    • 唤醒原语（阻塞态—>就绪态）
      • 在事件等待队列中找到PCB
      • 将PCB从等待队列移除，设置进程为就绪态
      • 将PCB插入就绪队列，等待被调度
    • 引起进程唤醒的事件
      • 等待的事件发生：因何事阻塞就应由何事唤醒
  • 进程的切换
    • 切换原语（运行态—>阻塞态/就绪态 就绪态—>运行态）
      • 将运行环境信息存入PCB
      • PCB移入相应队列
      • 选择另外一个进程执行，并更新其PCB
      • 根据PCB恢复新进程所需的运行环境
    • 引起进程切换的事件
      • 当前进程事件片到
      • 有更高优先级的进程到达
      • 当前进程主动阻塞
      • 当前进程终止

  1. 以上笔记均来自王道考研 ↩︎

  2. 阻塞原语唤醒原语必须成对使用 ↩︎

别惹我会变开心
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
进程控制与进程关系
DenzilXu的专栏
04-22 1163
1 进程ID fd分配是对一个进程内部而言的，每个进程内的fd是相互独立的。而进程的ID确实整个系统统一分配的。 每个进程都有一个非负整型的唯一进程ID。因为进程ID标识符总是唯一的，常将其用做其他标识符的一部分以保证其唯一性。 有某些专用的进程：进程ID 0是调度进程，常常被称为交换进程( swapper )。该进程并不执行任何磁盘上的程序—它是内核的一部分，因此也被称为系统进程。进程I
进程控制源代码
06-23
是课程设计的一个题目，对进程进行管理，可以进行十六进制、八进制、二进制之间的转换，输出格式正确
【进程状态与进程控制】
qq_41266147的博客
12-17 234
一、进程状态 1、进程传统五状态模型 总结 ： 进程状态转换并非都可逆 进程状态的唯一性 1.1 线程状态转换图 2、进程七状态模型 二、进程控制 1、进程创建 2、进程终止 3、进程阻塞 4、进程唤醒 ...
进程的状态转换
weixin_42067873的博客
06-16 2381
一、进程状态 1.创建状态 进程由创建而产生。创建进程是一个非常复杂的过程，一般需要通过多个步骤才能完成：如首先由进程申请一个空白的进程控制块(PCB)，并向PCB中填写用于控制和管理进程的信息；然后为该进程分配运行时所必须的资源；最后，把该进程转入就绪状态并插入到就绪队列中。 2.就绪状态 这是指进程已经准备好运行的状态，即进程已分配到除CPU以外所有的必要资源后，只要再获得CPU，便可立即执行。如果系统中有许多处于就绪状态的进程，通常将它们按照一定的策略排成一个队列，该队列称为就绪队列。有执行资格，
（五）进程管理：进程的状态与控制
qq_34912889的博客
12-04 664
对进程的几种基本状态以及系统控制进程使用的几种原语进行介绍
1.进程状态转换模拟.c
05-18
操作系统上机操作实验，进程三种状态转换的模拟，用队列进行的模拟 操作系统上机操作实验，进程三种状态转换的模拟，用队列进行的模拟
pcb.rar_进程 转换 流_进程状态
09-14
本主题将深入探讨“pcb.rar_进程 转换 流_进程状态”的核心概念，包括进程控制块（PCB）、进程状态转换以及流程。 首先，我们需要了解进程控制块（Process Control Block，PCB）。PCB是操作系统用来记录和管理进程...
structDemo1.rar_切换进程_进程状态转换
09-19
在这个"structDemo1.rar_切换进程_进程状态转换"的示例中，我们将深入探讨两个关键概念：进程切换和进程状态转换。这些是操作系统中至关重要的知识点，对理解系统的运行机制至关重要。 首先，我们来解析“切换进程...
操作系统进程控制与通信
06-30
进程控制是操作系统中非常核心的一个部分，它涉及到进程的创建、终止、状态转换等基本操作。在现代操作系统中，进程通常通过以下几种方式进行控制： 1. **fork()**：这是一个用于创建新进程的标准系统调用。当一个...
进程状态模拟转换.docx
07-20
操作系统课程设计的目标是模拟进程状态转换，这涉及到操作系统的核心概念，包括进程管理、资源分配以及进程间的通信。在这个设计中，学生需要理解并实现以下关键知识点： 1. **进程状态**： - **新建态（New）**：...
操作系统实验报告- 进程状态转换及其PCB的变化
05-22
流程图，代码，截图三、程序源代码: #include"stdlib.h" #include"stdio.h" #include"string.h" /********** globle structure and viable ******/ struct PCB { int P_Id; //PCB的ID号 char P_Name[10]; //PCB的名称 char P_State[10]; //PCB状态 int P_Runtime; //PCB的所需要的运行时间 int P_Requiry; //PCB所需要的资源要求 struct PCB * next ; //PCB块的下一个指针 } ; struct PCB * Create_state; //创建状态 struct PCB * Run_state; //运行状态 struct PCB * Ready_state; //就绪状态 struct PCB * Block_state; //阻塞状态 struct PCB * Exit_state; //退出状态 int signal4=0; //标示进程4的完成状态 int signal5=0; //标示进程5的完成状态 void InsertQueue(struct PCB **head,struct PCB *node) /* insert node function */ { struct PCB * p,*q; node->next=NULL; if(*head==NULL) //如果队列为空 { *head=node; } Else //队列不空 { p=*head; q=p->next; while(q!=NULL) //找到最后的元素位置 { p=q; q=q->next; } p->next=node; //将节点插入队列 } } void DeleteQueue(struct PCB **head,struct PCB *node) //撤销进程，从队列中删除元素 { struct PCB *p,*q; q=*head; if(*head==NULL||node==NULL) //如果队列为空，返回 return ; if(*head==node) //如果要删除的元素是队首元素 { *head=(*head)->next; return; } Else //如果不是队列的首元素 { while(q->next!=p&&q->next!=NULL) q=q->next; q=p->next; p->next=NULL; } } void Display_Process(struct PCB * node) //打印进程状态的元素函数 { printf("\n\nthis process Id is : %d \n",node->P_Id); printf("this process name is : %s \n",node->P_Name); printf("this process state is : on %s \n ",node->P_State); printf("this process Runtime is : %d \n",node->P_Runtime); if(node->P_Requiry) printf("this process resource is ready \n"); else printf("this process resource is not ready ! \n"); } void DispatchToBlock(struct PCB *node) // /* dispatch to block function*/ { //调度到阻塞状态的函数 //struct PCB *p=(struct PCB *)malloc(sizeof(struct PCB)); if(!node->P_Requiry) //如果所需要的资源没有满足则，调度到阻塞状态 { strcpy(node->P_State,"block"); InsertQueue(&Block_state,node); //插入到阻塞队列 Display_Process(node); } } void DispatchToReady(struct PCB *node) // dispatch to ready state { //调度到就绪状态的函数 if(node->P_Requiry) //如果所需的资源满足，则调度 { strcpy(node->P_State,"Ready"); InsertQueue(&Ready_state,node); Display_Process(node); } } void DispatchBlockToReady() //dispatch the process to readyqueue { //从阻塞状态调度到就绪状态函数 struct PCB*p,*q; q=Block_state; while(q!=NULL) //如果阻塞状态队列不空 { p=q; q=q->next; if(signal4&&p->P_Id==4) //如果所需要的资源满足 { DeleteQueue(&Block_state,p); strcpy(p->P_State,"ready"); InsertQueue(&Ready_state,p); printf("process4 will be in the state of ready!\n"); Display_Process(p); } if(signal5&&p->P_Id==5) { DeleteQueue(&Block_state,p); strcpy(p->P_State,"ready"); InsertQueue(&Ready_state,p); printf("process5 will be in the state of ready!\n"); Display_Process(p); } } } void Create_Process() //创建进程函数 { int i; struct PCB *p; char name[10]; strcpy(name,"process"); for(i=1;iP_Id=i; name[7]=i+'0'; name[8]='\0'; strcpy(p->P_Name,name); strcpy(p->P_State,"create"); p->P_Runtime=1; //所需要的时间片为1 p->P_Requiry=0; Display_Process(p); sleep(4); printf(" \n process%d will be in the state of Block, waiting the resource ready \n\n",i); DispatchToBlock(p); //同时调度到阻塞队列 } for(i=3;iP_Id=i; name[7]=i+'0'; name[8]='\0'; strcpy(p->P_Name,name); strcpy(p->P_State,"create"); p->P_Requiry=1; if(i==6) //在这里个进程6所需要的时间片为2 p->P_Runtime=2; else p->P_Runtime=1; Display_Process(p); sleep(4); printf(" \n process%d will be in the state of Ready, waiting to run \n\n",i); DispatchToReady(p); } } void display(struct PCB **head) //打印各个状态队列里进程数目 { struct PCB *p,*q; p=*head; while(p!=NULL) { sleep(2); //printf("\n\n///////////////////////////////////\n"); printf("\n\nthis process Id is : %d \n",p->P_Id); printf("this process name is : %s \n",p->P_Name); printf("this process state is : on %s \n ",p->P_State); printf("this process Runtime is : %d \n",p->P_Runtime); if(p->P_Requiry) printf("this process resource is ready \n"); else printf("this process resource is not ready ! \n"); p=p->next; } } void Process_Run() //进程运行函数 { struct PCB *p,*q; p=Ready_state; q=p; while(p!=NULL) //就绪队列不空则继续执行 { if(p->P_RuntimeP_State,"running"); Display_Process(p); p->P_Runtime=p->P_Runtime-1; sleep(4); if(p->P_Runtime>0) //没有完成，则进入就绪队列 { printf("this process is not finished,will be dispatch to the ready queue!!\n"); DeleteQueue(&Ready_state,p); strcpy(p->P_State,"ready"); InsertQueue(&Ready_state,p); Display_Process(p); } Else //执行完成，则跳出，并发送相应的信息 { printf("\n\nProcess%d is finished and will be in the state of exit!\n\n",p->P_Id); if(p->P_Id==4) signal4=1; if(p->P_Id==5) signal5=1; } if(signal4||signal5) DispatchBlockToReady(); //如果资源满足，则将进程调度到就绪队列 q=q->next; p=q; } if(q==NULL) printf("\nthere is no process ready!\n STOP Machine!!!\n"); } int main(int argc,char * argv[]) //主函数 { int i; char c='c'; //界面 printf("\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ \n"); printf("...................................Ding Hai bo\n"); printf("......Press s to start the process.......\n"); scanf("%c",&c); while(1) { if(c=='s')break; scanf("%c",&c); } Create_Process(); //调用创建进程函数 printf("\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n"); printf("\n>>>>>>> Display the Ready queue >>>>>>>>>>>>>>>\n"); sleep(5); display(&Ready_state); ////////////////显示就绪队列里的进程 printf("\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n"); printf("\n>>>>>>>> Display the Block queue >>>>>>>>>>>>\n"); sleep(5); //显示阻塞队列函数 display(&Block_state); ///////////////////// printf("\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n\n\n"); printf("\n>>>>>>>> Now the process start to run >>>>>>>>>>>\n"); sleep(5); Process_Run(); //调用进程运行函数 } 都有
计算机的进程状态怎么区分,电脑进程和线程的区别 二者有什么关系
weixin_35638129的博客
07-22 294
线程和进程都有一些相似之处。一个进程可以创建另一个进程，然后我们称它为子进程，作为它的第一个父进程。但它也可能创建一个线程。在这种情况下，您可能会将线程视为一小段指令。与进程不同，线程可以与其他线程共享相同数量的内存，而每个进程必须有自己的不可共享空间。一旦它们共享内存，我们可以说线程比进程需要更少的资源，避免操作系统为每个正在执行的线程提供一个特殊区域。通常，与进程相比，线程具有“较低的成本”。...
用于进程控制的原语主要由哪几个，每个原语的执行将使进程的状态发生什么变化？...
weixin_30485291的博客
07-21 5092
1、 创建原语：创建一个就绪状态的进程，使进程从创建状态变迁为就绪状态。 2、 撤销原语：使进程从执行状态变迁为完成状态。 3、 阻塞原语：使进程从运行状态变迁为阻塞状态。 4、 唤醒原语：使进程从阻塞状态变迁为就绪状态。 转载于:https://www.cnblogs.com/luo841997665/p/4665589.html...
操作系统 --进程概述（含思维导图）（二）
starchao
03-07 1467
进程的定义 程序段，数据段，PCB三部分组成了进程实体（进程映像），一般情况把进程实体简称为进程 进程控制块（PCB）：系统为每个运行的程序配置的一个数据结构，用来描述进程的各种信息（如代码的存放位置）和运行状态。所谓创建进程和撤销进程都是对PCB的操作 注意：PCB是进程存在的唯一标志！ 进程映像是静态发，进程是动态的 引入进程实体的概念后，可把进程定义为： 进程是进程实体的...
【操作系统】进程的状态及转换
weixin_45893787的博客
07-29 8024
进程的状态及转换有两状态进程模型、三状态进程模型和无状态模型等三种模型，接下来仔细讲解这三种模型。关于什么是进程，至今为止对这一概念都还没有一个非常确切的、令人满意的、统一的定义。我国操作系统方面的研究人员在庐山召开的全国操作系统学术会议上对进程给出了定义：进程是一个可并发执行的、具有独立功能的程序关于某个数据集合的一次执行过程，也是操作系统进行资源分配和调度的基本单位。...
计算机操作系统慕课版第二章课后习题及参考答案
weixin_74103839的博客
09-19 2905
运行时系统，ULT由运行时系统中的线程切换过程来执行切换任务，该过程将线程的CPU状态保存在该线程的堆栈中，然后按照一定的算法选择一个处于就绪状态的新线程运行，并将新线程堆栈中的CPU状态装入CPU相应的寄存器中，一旦将指针和程序计数器切换后，便开始了新的运行，且由于ULT的切换无须进入内核，且操作简单，切换速度因此非常快。创建进程， 终止进程， 挂起进程， 恢复进程， 阻塞进程， 唤醒进程， 进程同步， 进程间通信。且内核不知道用户级线程的存在。
【Linux】关于进程的理解、状态、优先级和进程切换
weixin_60478154的博客
11-12 1940
【Linux】关于进程的理解、状态、优先级以及进程切换
计算机操作系统（慕课版）第二章习题解析
最新发布
Victoriahjy的博客
01-03 2366
在多处理机环境下，对纯粹的用户级线程来说,内核只为一个进程分配一个处理机，即进程无法享用多处理机带来的好处:而当设置有内核支持线程时，内核可调度一个应用中的多个线程同时在多个处理机上井行运行，从而提高程序的执行速度和效率。而对仅设置了用户级线程的系统，内核调度的单位为进程，当进程获得CPU时，求属于该进程的多个线程可通过用户态下的线程调度分享由内核分配给进程的CPU执行时间。在某些系统中，特别是在网络环境下的OS中，往往会设置一定量的系统进程，这种进程每当完成任务后便会把自己阻塞起来，等待新任务的到来。
【Linux】进程状态|优先级|进程切换|环境变量
大三小白C++进阶之路
02-23 3377
进程状态、两种特殊的进程、进程优先级和环境变量
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值