进程状态转换

最新推荐文章于 2024-08-02 14:14:02 发布
原创 最新推荐文章于 2024-08-02 14:14:02 发布 · 5.4k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#任务 #数据结构 #linux #up

本文详细介绍了Linux系统中进程的各种状态，包括运行状态、可中断睡眠状态、不可中断睡眠状态等，并解释了进程状态之间的转换机制。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一个进程在其生存期内，可处于一组不同的状态下，称为进程状态，如图所示。进程状态保存在进程任务结构的state字段中。
当进程正在等待 系统中的资源而处于等待状态时，则称其处于睡眠等待状态。
在Linux系统中，睡眠等待状态分为可中断的和不可中断的等待状态。
 
 进程状态及转换关系
（1）    运行状态（TASK_RUNNING）。当进程正在被CPU执行，或已经准备就绪随时可由调度程序执行，则称该进程为处于运行状态 （running）。若此时进程没有被CPU执行，则称其处于就绪运行状态。见图中3个标号为0的状态。
进程可以在内核态运行，也可以在用户态运 行。
当一个进程在内核代码中运行时，我们称其处于内核运行态，或简称为内核态；
当一个进程正在执行用户自己的代码时，我们称其为处于用户运行态（用户 态）。当系统资源已经可用时，进程就被唤醒而进入准备运行状态，该状态称为就绪态。这些状态（图中中间一列）在内核中表示方法相同，都被称为处于 TASK_RUNNING状态。当一个新进程刚被创建出后就处于本状态中（最下一个0处）。
（2）    可中断睡眠状态（TASK_INTERRUPTIBLE）。当进程处于可中断等待（睡眠）状态时，系统不会调度该进程执行。
当系统产生一个中断或者释放了进程正在等待的资源，或者进程收到一个信号，都可以唤醒进程转换到就绪状态（即可运行状态）。
（3）不可中断睡眠状态（TASK_UNINTERRUPTIBLE）。除了不会因为收到信号而被唤醒，该状态与可中断睡眠状态类似。但处于该状态 的进程只有被使用wake_up()函数明确唤醒时才能转换到可运行的就绪状态。该状态通常在进程需要不受干扰地等待或者所等待事件会很快发生时使用。
（4）暂停状态（TASK_STOPPED）。当进程收到信号SIGSTOP、SIGTSTP、SIGTTIN或SIGTTOU时就会进入暂停状 态。可向其发送SIGCONT信号让进程转换到可运行状态。进程在调试期间接收到任何信号均会进入该状态。在Linux 0.12中，还未实现对该状态的转换处理。处于该状态的进程将被作为进程终止来处理。
（5）僵死状态（TASK_ZOMBIE）。当进程已停止运行，但其父进程还没有调用wait()询问其状态时，则称该进程处于僵死状态。为了了让 父进程能够获取其停止运行的信息，此时子进程的任务数据结构信息还需要保留着。一旦父进程调用wait()取得了子进程的信息，则处于该状态进程的任务数 据结构就会被释放。
当一个进程的运行时间片用完，系统就会使用调度程序强制切换到其他的进程去执行。
另外，如果进程在内核态执行时需要等待系统的某个资源，此时该进程 就会调用sleep_on()或interruptible_sleep_on()自愿地放弃CPU的使用权，而让调度程序去执行其他进程。进程则进入睡 眠状态（TASK_UNINTERRUPTIBLE或TASK_INTERRUPTIBLE）。
只有当进程从"内核运行态"转移到"睡眠状态"时，内核才会进行进程切换操作。在内核态下运行的进程不能被其他进程抢占，而且一个进程不能改变另一个进程的状态。为了避免进程切换时造成内核数据错误，内核在执行临界区代码时会禁止一切中断

进程运行状态
weixin_33713503的博客
11-09 238
一个进程在其生存期内，可处于一组不同的状态下，称为进程状态，如图5-21所示。进程状态保存在进程任务结构的state字段中。当进程正在等待 系统中的资源而处于等待状态时，则称其处于睡眠等待状态。在Linux系统中，睡眠等待状态分为可中断的和不可中断的等待状态。 （点击查看大图）图5-21  进程状态及转换关系     （1）运行状态（TASK_RUNNING）。当进程正在被CPU执行，或...
进程的三种基本状态与切换
前方的征途是星辰大海
10-27 225
进程执行时间的间断性决定了进程可能具有多种状态，事实上，运行上的进程可能有以下三种状态。 1）就绪状态 当进程已分配到除了CPU以外的所有必要资源后，只要再获得CPU，便可以立即执行，进程的这时的状态称为就绪状态。在一个系统中处于就绪状态的进程可能有多个，通常将他们排成一个队列，称为就绪队列。 2）执行状态 进程获得CPU资源，其程序正在执行，在单片机系统中，只有一个进程处于执行状态，在多
进程的状态与转换
devil_166的博客
05-28 4594
文章目录前言一、进程的三种基本状态二、进程状态的转换 前言 进程是程序的一次执行，在执行过程中有些进程正在被cpu处理，有时需等待CPU服务 一、进程的三种基本状态 运行态：占有CPU，并在CPU运行。 就绪态：已具备运行的条件，但由于没有空闲的CPU而暂时不能运行。 阻塞态：因等待某一事件而暂时不能运行 ps： 1.单核处理机下，每一时刻最多有一个进程处于运行态（双核环境下可同时有两个进程处于运行态）。 2.进程在就绪态下，已经拥有了除CPU之外所有需要的资源，一旦获取CPU可立即进入运行态运行。 3.
操作系统——进程的状态与转换
weixin_43774841的博客
09-10 2476
运行状态：进程正在处理机上运行。在单处理机环境下，每一时刻最多只有一个进程处于运行状态； 就绪状态：进程已处于准备运行的状态，获得了除处理机之外的一切所需资源，一旦得到处理机即可运行。 阻塞状态，又称等待状态：进程正在等待某一事件而暂停运行，如等待某资源为可用（不包括处理机）或等待输入/输出完成。即使处理机空闲，该进程也不能运行。 创建状态：进程正在被创建，尚未转到就绪状态。创建步骤包括：申请空白的 PCB，向 PCB 中填写一些控制和管理信息，系统向进程分配运行时所需的资源。 结束状态：进程正常结束、发.
图解进程都有哪些状态及状态之间关系转换
晓康的博客
09-05 2133
就绪状态：已获除处理机(CPU)以外所需资源，等待分配处理机资源。 运行状态：占用处理机资源运行，此状态 进程数 <= CPU数。 阻塞状态：进程等待某种条件，在条件满足之前无法执行。 图解：new 新启动进程，ready 就绪态，runing 运行态，waiting 阻塞态，terminated 进程终止。 new新启动进程已获除CPU以外资源后被准许(admitted)进...
1.进程状态转换模拟.c
05-18
操作系统上机操作实验，进程三种状态转换的模拟，用队列进行的模拟 操作系统上机操作实验，进程三种状态转换的模拟，用队列进行的模拟
《操作系统导论》实验一：模拟进程状态转换 代码
09-28
OS实验程序 环境python2(别的不行) Linux建议用unbatu虚拟机 文件夹最外边的process代码是修改的 文件夹里边的代码可能不能运行 或者上这个网站下载https://pages.cs.wisc.edu/~remzi/OSTEP/Homework/homework.html
structDemo1.rar_切换进程_进程状态转换
09-19
在这个"structDemo1.rar_切换进程_进程状态转换"的示例中，我们将深入探讨两个关键概念：进程切换和进程状态转换。这些是操作系统中至关重要的知识点，对理解系统的运行机制至关重要。 首先，我们来解析“切换进程...
操作系统实验一模拟进程状态转换.pdf
11-24
进程状态转换的模拟实现 操作系统实验一模拟进程状态转换是operating system中一个重要的实验，旨在模拟进程状态转换的过程。下面是对该实验的知识点总结。 一、进程状态转换的概念 在操作系统中，进程状态转换是...
模拟操作系统(C#编写，包括进程管理，设备管理，文件管理)
12-30
C#设计模拟操作系统，包括进程管理，设备管理，文件管理！
操作系统实验报告- 进程状态转换及其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(); //调用进程运行函数 } 都有
操作系统进程状态模拟
04-10
用java写的一个操作系统进程状态模拟，界面化处理，简单。
linux进程从就绪到运行时间,linux系统进程状态理解
weixin_42541463的博客
05-11 1233
1、为了对进程从产生到消亡的整个过程进行跟踪和描述，就需要定义各种进程的各种状态并制定相应的状态转换策略，以此来控制进程的运行。不同的操作系统对进程的状态解释不同，但是最基本的状态都是一样的。包括一下三种：运行态：进程占用CPU，并在CPU上运行；就绪态：进程已经具备运行条件，但是CPU还没有分配过来；阻塞态：进程因等待某件事发生而暂时不能运行；进程在一生中，都处于上述3中状态之一。下面是3种状态...
进程状态（一）---- 运行，阻塞，挂起
最新发布
CPPER
08-02 4630
凡是处于运行队列当中的进程，这些进程的状态，称之为 运行状态 （也即运行态）( R )。 将正在等待特定设备的进程，其状态称为阻塞状态！ 只有 pcb 在内存中，而它的代码和数据被换出到外设的进程，我们称为 **挂起状态**
线程学习二
qq_37664264的博客
11-03 418
1.线程生命周期 1.1新建 new关键字创建了一个线程之后，该线程就处于新建状态 JVM为线程分配内存，初始化成员变量值 1.2就绪 当线程对象调用了start（）方法之后，线程就处于就绪状态 JVM为线程创建方法栈和程序计数器，等待线程调度器调度 1.3运行 就绪状态的线程获取CPU资源，开始运行run（）方法，该线程进入运行状态 1.4阻塞 当发生如...
进程切换与中断
人总是要有梦想的QAQ的博客
03-21 8291
进程切换指从正在运行的进程中收回处理器，让待运行进程来占有处理器运行。 实质上就是被中断运行进程与待运行进程的上下文切换。 进程切换必须在操作系统内核模式下完成，这就需要模式切换。 模式切换又称处理器切换，即用户模式和内核模式的互相切换。 进程切换一定发生在中断／异常／系统调用处理过程中，常见的有以下情况： 1、阻塞式系统调用、虚拟地址异常。 导致被中断进程进入等待态。 2、时间片中断、I/O中断...
[进程]进程的状态转换
超越
04-28 4491
进程的三态模型 按进程在执行过程中的不同情况至少要定义三种状态： 运行（running）态：进程占有处理器正在运行的状态。 进程已获得CPU，其程序正在执行。在单处理机系统中，只有一个进程处于执行状态； 在多处理机系统中，则有多个进程处于执行状态。 就绪（ready）态：进程具备运行条件，等待系统分配处理器以便运行的状态。 当进程已分配到除CPU以外的所有...
linux进程状态及转换关系
热门推荐
deep_explore的专栏
11-02 1万+
linux中的进程状态： ◆运行状态（TASK_RUNNING） 指正在被CPU运行或者就绪的状态。这样的进程被成为runnning进程。运行态的进程可以分为3种情况：内核运行态、用户运行态、就绪态。 ◆可中断睡眠状态（TASK_INTERRUPTIBLE） 处于等待状态中的进程，一旦被该进程等待的资源被释放，那么该进程就会进入运行状态。 ◆不可中断睡眠状态（TASK_U
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值