操作系统 进程转换_多任务操作系统中,引起操作系统切换进程 有新进程 - CSDN
  • 对于调度进程,只需要等待就绪队列里的进程,因为阻塞状态可以转换到就绪队列里去。   2. 进程五状态   1) 新状态:进程已经创建,但未被OS接纳为可执行进程。(还没有申请到相应的资源)。 2)

    1.    为什么要分开就绪和阻塞状态

           答:因为就绪态只需要等待处理机,而阻塞态可能在等待输入输出,即使分配给处理机也是徒劳,所以两状态图不妥。对于调度进程,只需要等待就绪队列里的进程,因为阻塞状态可以转换到就绪队列里去。

     

    2.    进程五状态

     

    1)       新状态:进程已经创建,但未被OS接纳为可执行进程。(还没有申请到相应的资源)。

    2)       就绪态:进程做好了准备,准备执行(只等待处理机)。

    3)       执行状态:该进程正在执行(单处理机,某一时刻仅一个进程占用处理机)。

    4)       阻塞状态:等待某事件发生才能执行,如等待I/O完成。

    5)       终止状态.

     

    3.    问题:多个进程竞争内存资源

    l  内存资源紧张

    l  无就绪队列,处理机空闲:I/O速度比处理机速度慢的多,可能出现全部进程阻塞等待I/O。

    解决方法

    l  交换技术:换出一部分暂时不能运行的进程(阻塞进程)到外存(只换出程序和数据,PCB不换出去),以腾出内存空间,可以调用新进程来执行。

    l  虚拟存储技术:每个进程只能装入一部分程序和数据

     

    4.      挂起:进程被交换到外存,状态变为挂起状态

    4.1   进程挂起的原因(p91)

    l  进程全部阻塞,处理机空闲。

    l  系统负荷过重,内存空间紧张。(让其他进程先执行完)

    l  操作系统的需要。操作系统可能需要挂起后台进程或一些服务进程,或者某些可能导致故障的进程。

    l  终端用户请求。

    l  父进程的需求。

    4.2  挂起进程的特征

    l  不能立即执行

    l  可能是等待某事件发生,若是,则阻塞条件独立于挂起条件,即使阻塞事件发生,该进程也不能执行。

    n  阻塞和挂起没有联系。

    n  如果A进程现在要求输入数据,此时A进程属于阻塞状态,在选择挂起进程的时候,可能先选择阻塞进程(A进程),此时A进程挂起,正在输入数据,输入到内存缓冲区内。当数据输完了,向处理机发送命令数据已经输入完成,阻塞事件解除,但实际上还是挂起,所以仍是挂起态。

    l  使之挂起的进程为:自身、父进程、OS。

    l  只有挂起它的进程才能使之由挂起状态转换为其他状态。

     

    4.3  阻塞与挂起

    l  进程是否等待时间:阻塞与否。

    l  进程是否被换出内存:挂起与否。

     

    4.4  四种状态组合

    l  就绪:进程在内存,准备执行。

    l  阻塞:进程在内存,等待事件。

    l  就绪/挂起:进程在外存,只要调入内存即可执行。

    l  阻塞/挂起:进程在外存,等待事件。

     

    4.5  处理机可调度执行的进程有两种

    l  新创建的进程

    l  或换入一个以前挂起的进程

    通常为避免增加系统负载,系统会换入一个以前挂起的进程执行。

     

    4.6  具有挂起状态的进程状态转换


    l  阻塞 → 阻塞/挂起:OS通常将阻塞进程换出,以腾出内存空间

    l  阻塞/挂起→ 就绪/挂起:当阻塞/挂起进程等待的事件发生时,可以将其转换为就绪/挂起。

    l  就绪/挂起→ 就绪:OS需要调入一个进程执行。

    l  就绪 → 就绪/挂起:一般,OS挂起阻塞进程。但是有时也会挂起就绪进程,释放足够的内存空间。

    l  新 → 就绪/挂起(新→ 就绪):新进程创建后,可以插入到就绪队列或就绪,挂起队列,若无足够的内存分配给新进程,则需要新→ 就绪/挂起。

    展开全文
  • 操作系统的第一个实验,此程序是为了模拟进程转换过程,实现进程间的相互转换。 源代码: #include <iostream> #include <stdlib.h> #include <time.h> using namespace std; /*类型定义...

    操作系统的第一个实验,此程序是为了模拟进程转换过程,实现进程间的相互转换。

     

     源代码:

    #include <iostream>
    #include <stdlib.h>
    #include <time.h>
    using namespace std;
    
    /*类型定义和函数定义*/
    struct PCB {
    	int process; //进程标识符
    	int now;//当前状态(1.就绪,2.运行,3.阻塞,4.终止)
    	int time;//要求运行的时间片
    	int greater;//优先级
    };//进程控制块
    
    struct Queue{
    	int a[100];//存进程的序号
    	int front;//头指针
    	int rear;//尾指针
    };//队列
    
    /*队列初始化*/
    void Init(Queue &Q){
    	Q.front=0;
    	Q.rear=0;
    }
    
    /*进栈*/
    void EnQueue(Queue &Q,int &i){
    	Q.a[Q.rear]=i;
    	Q.rear++;
    }
    
    /*出栈*/
    void DeQueue(Queue &Q,int &i){
    	i=Q.a[Q.front];
    	Q.front++;
    }
    
    /*进程调度,时间减1,优先级减1*/
    void Act(PCB &p){
    	p.time--;
    	p.greater--;
    }
    
    /*就绪队列按优先级排序*/
    void Sort(Queue &Q,PCB pcb[]){
    	int i,j,m,n;
    	int t,index;
    	for(i=Q.front;i<Q.rear-1;i++){
    		index=i;
    		for(j=i+1;j<Q.rear;j++){
    			m=Q.a[j];n=Q.a[index];
    			if(pcb[n].greater<pcb[m].greater)
    				index=j;
    			if(index!=i){
    				t=Q.a[i];Q.a[i]=Q.a[index];Q.a[index]=t;
    				index=i;
    			}
    
    		}
    	}
    }
    
    /*显示三个队列的信息*/
    void Display(Queue ready,Queue block,Queue end,PCB pcb[]){
    	int i,j;
    	cout<<"就绪队列"<<endl;
    	for(i=ready.front;i<ready.rear;i++){
    		j=ready.a[i];
    		cout<<pcb[j].process<<" "<<pcb[j].now<<" "<<pcb[j].time<<" "<<pcb[j].greater<<endl;
    	}
    	cout<<"阻塞队列"<<endl;
    	for(i=block.front;i<block.rear;i++){
    		j=block.a[i];
    		cout<<pcb[j].process<<" "<<pcb[j].now<<" "<<pcb[j].time<<" "<<pcb[j].greater<<endl;
    	}
    	cout<<"终止队列"<<endl;
    	for(i=end.front;i<end.rear;i++){
    		j=end.a[i];
    		cout<<pcb[j].process<<" "<<pcb[j].now<<" "<<pcb[j].time<<" "<<pcb[j].greater<<endl;
    	}
    	cout<<endl;
    }
    
    
    int main(){
    	int i,n=0,t;
    	int N;//总进程数
    	PCB  pcb[100];
    	Queue Ready,Block,End;//就绪,阻塞,终止队列。
    
    	cout<<"请输入总进程数"<<endl;
    	cin>>N;
    
    	cout<<"请输入每个进程的标识符,当前状态,时间片数,优先级:"<<endl;
    	cout<<"注:状态为1.就绪,2.运行,3.阻塞,4.终止"<<endl;
    	for(i=0;i<N;i++){
    		cin>>pcb[i].process;
    		cin>>pcb[i].now;
    		cin>>pcb[i].time;
    		cin>>pcb[i].greater;
    	}
    	
    	
    	cout<<endl<<"初始进程情况"<<endl;
    	for(i=0;i<N;i++){
    		cout<<pcb[i].process<<" "<<pcb[i].now<<" "<<pcb[i].time<<" "<<pcb[i].greater<<endl;
    	}
    	cout<<endl;
    
    	Init(Ready);Init(Block);Init(End);//初始化三个队列
    
    	for(i=0;i<N;i++){
    		if(pcb[i].now==1)
    			EnQueue(Ready,i);
    		else if(pcb[i].now==3)
    			EnQueue(Block,i);
    		else if(pcb[i].now==4)
    			EnQueue(End,i);
    		else if(pcb[i].now==2){
    			Act(pcb[i]);
    			if(pcb[i].time>0){
    				EnQueue(Ready,i);
    			}
    			else{
    				EnQueue(End,n);
    				pcb[n].now=4;
    			}
    		}
    	}
    	Sort(Ready,pcb);//对初始就绪序列按优先级排序
    	Display(Ready,Block,End,pcb);
    
    
    	/*就绪队列中没有进程时结束调用*/
    	while(Ready.rear!=Ready.front){
    		srand(time(NULL));
    		t=rand()%10;//产生随机数
    
    		DeQueue(Ready,n);
    		if(t==1){//随机阻塞
    			DeQueue(Block,n);
    			pcb[n].now=2;
    			Display(Ready,Block,End,pcb);
    			continue;
    		}
    		Act(pcb[n]);//运行就绪队列中的进程
    		if(pcb[n].time>0){
    			EnQueue(Ready,n);
    			Sort(Ready,pcb);
    		}
    		else{
    			EnQueue(End,n);
    			pcb[n].now=4;
    		}
    		if(t==2){//随机唤醒
    			if(Block.rear!=Block.front){
    				DeQueue(Block,n);
    				EnQueue(Ready,n);
    				Sort(Ready,pcb);
    				pcb[n].now=1;
    			}
    				
    		}
    		Display(Ready,Block,End,pcb);
    	}
    	Display(Ready,Block,End,pcb);//显示现在三个队列状态
    
    	return 0;
    }
    

    代码写的不是很好看,关键地方都有注释,还有待改进。

    展开全文
  • 进行进程切换就是从正在运行的进程中收回处理器,然后再使待运行进程来占用处理器。  这里所说的从某个进程收回处理器,实质上就是把进程存放在处理器的寄存器中的中间数据找个地方存起来,从而把处理器的寄存器腾...
     
    

    进行进程切换就是从正在运行的进程中收回处理器,然后再使待运行进程来占用处理器。

      这里所说的从某个进程收回处理器,实质上就是把进程存放在处理器的寄存器中的中间数据找个地方存起来,从而把处理器的寄存器腾出来让其他进程使用。那么被中止运行进程的中问数据存在何处好呢?当然这个地方应该是进程的私有堆栈。

      让进程来占用处理器,实质上是把某个进程存放在私有堆栈中寄存器的数据(前一次本进程被中止时的中间数据)再恢复到处理器的寄存器中去,并把待运行进程的断点送入处理器的程序指针PC,于是待运行进程就开始被处理器运行了,也就是这个进程已经占有处理器的使用权了。

      这就像多个同学要分时使用同一张课桌一样9说是要收回正在使用课桌同学的课桌使用权,实质上就是让他把属于他的东西拿走;而赋予某个同学课桌使用权,只不过就是让他把他的东西放到课桌上罢了。

      在切换时,一个进程存储在处理器各寄存器中的中间数据叫做进程的上下文,所以进程的 切换实质上就是被中止运行进程与待运行进程上下文的切换。在进程未占用处理器时,进程 的上下文是存储在进程的私有堆栈中的。

      从上面的叙述可知,调度器进程切换的代码应有如下功能:

      ●保存处理器PC寄存器的值到被中止进程的私有堆栈;

      ●保存处理器PSW寄存器的值到被中止进程的私有堆栈;

      ●保存处理器SP寄存器的值到被中止进程的进程控制块;

      ●保存处理器其他寄存器的值到被中止进程的私有堆栈;

      ●自待运行进程的进程控制块取SP值并存入处理器的寄存器SP;

      ●自待运行进程的私有堆栈恢复处理器各寄存器的值;

      ●自待运行进程的私有堆栈中弹出PSW值并送入处理器的PSW;

      ●自待运行进程的私有堆栈中弹出PC值并送入处理器的PC。

      显然,进程的切换可以用中断技术来实现,即当调度器获得了待运行进程的控制块之后,应立即用软中断指令来中止当前进程的运行,并保存当前进程的PC值和PSW值。其后,使 用压栈指令把处理器其他寄存器的值压入进程私有堆栈。接下来,就从待运行进程的进程控 制块中取出私有堆栈指针的值并存入处理器的寄存器SP,至此SP就指向了待运行进程的私 有堆栈,于是下面就自待运行进程的私有堆栈中弹出上下文进人处理器。最后,利用中断返回指令来实现自待运行进程的私有堆栈中弹出PSW值和自待运行进程的私有堆栈中弹出PC值的功能。

      这是一个完整的软中断处理过程,只不过在保护现场和恢复现场工作中,保护的是被中止 运行进程的现场,恢复的是待运行进程的现场,这一切都依赖于堆栈指针的切换。

      进程切换时,被中止进程保护断点和待运行进程保护断点的示意图如图所示:

    展开全文
  • 操作系统进程切换

    2017-06-23 16:35:24
    并不是所有的中断/异常都会引发进程切换

    最近复习操作系统关于进程切换的一些记录。


    一、进程切换

    进程切换指从正在运行的进程中收回处理器,让待运行进程来占有处理器运行。

    实质上就是被中断运行进程与待运行进程的上下文切换。


    二、模式切换

    进程切换必须在操作系统内核模式下完成,这就需要模式切换。

    模式切换又称处理器切换,即用户模式和内核模式的互相切换。


    三、进程切换的工作过程

    1、(中断/异常等触发)正向模式切换并压入PSW/PC 。 (Program Status Word 程序状态字。program counter 程序计数器。指向下一条要执行的指令)

    2、保存被中断进程的现场信息。

    3、处理具体中断、异常。

    4、把被中断进程的系统堆栈指针SP值保存到PCB。(Stack Pointer 栈指针。Process Control Block 进程控制块。)

    5、调整被中断进程的PCB信息,如进程状态)。

    6、把被中断进程的PCB加入相关队列。

    7、选择下一个占用CPU运行的进程。

    8、修改被选中进程的PCB信息,如进程状态。

    9、设置被选中进程的地址空间,恢复存储管理信息。

    10、恢复被选中进程的SP值到处理器寄存器SP。

    11、恢复被选中进程的现场信息进入处理器。

    12、(中断返回指令触发)逆向模式转换并弹出PSW/PC。


    四、那么进程切换何时发生呢?

    进程切换一定发生在中断/异常/系统调用处理过程中,常见的有以下情况:

    1、阻塞式系统调用、虚拟地址异常。

    导致被中断进程进入等待态。

    2、时间片中断、I/O中断后发现更改优先级进程。

    导致被中断进程进入就绪态。

    3、终止用系统调用、不能继续执行的异常。

    导致被中断进程进入终止态。


    五、但是并不意味着所有的中断/异常都会引起进程切换。

    有一些中断/异常不会引起进程状态转换,不会引起进程切换,只是在处理完成后把控制权交还给被中断进程。

    以下是处理流程:

    1、(中断/异常等触发)正向模式切换并压入PSW/PC 。 

    2、保存被中断进程的现场信息。

    3、处理具体中断、异常。

    4、恢复被中断进程的现场信息。

    5、(中断返回指令触发)逆向模式转换并弹出PSW/PC。


    可以分析以上两种流程发现,前三步是一样的,也就是说操作系统要处理中断,并不一定会引发进程切换,有些中断处理完了之后,立即会恢复继续原进程的处理。

    展开全文
  • 操作系统进程管理软件 关键的进程管理软件包括: •系统调用/中断/异常处理程序 •队列管理模块 •进程控制程序 •进程调度程序(独立进程居多) •进程通信程序(多个程序包) •终端登录与作业控制程序、 性能...
  • 进程的状态及切换 就绪态和运行态可以相互转换,运行态下如果时间片耗尽或者被抢占则进入就绪太,其他只能运行态->阻塞态(等待某个事件发生:外部输入等)->就绪态(除了cpu一切就绪) 进程控制就是...
  • 操作系统进程管理

    2018-10-22 21:38:15
    主要内容是程序的并发执行及进程的概念,进程的状态及其转换进程的同步与互斥,进程通信与调度,进程死锁的概念及解决死锁的方法,线程的概念及其实现等。
  • 不同进程切换的时候,操作系统触发什么事件?怎么防止别的进程切换或者获得操作?
  • 进程的状态的转换与PCB详解 ​ 返回主目录 ​ 之前的有博文对进程和线程的区别进行了详细的介绍,并且...​ 注意:本博文中进程均是在传统操作系统中的进程,既是OS进行资源分配的基本单位,也是OS进行调度的一个...
  • 计算操作系统进程管理 一、进程与线程 1.1、进程 进程是资源分配的基本单位。 进程控制块PCB(Process Control Block)描述的是进程的基本信息以及进程的运行状态,我们说的创建及撤销进程都是对进程控制块...
  • 对于调度进程,只需要等待就绪队列里的进程,因为阻塞状态可以转换到就绪队列里去。 进程五状态 新状态:进程已经创建,但未被OS接纳为可执行进程。(还没有申请到相应的资源)。 就绪态:进程...
  • 1.进程上下文切换过程: @1.由中断、异常、系统调用等触发中断,将cpu切换为内核模式,将eip,esp,eflages压入内核堆栈; @2.保存硬件未来得及保存的现场信息; @3.调用中断服务程序; @4.检查need_resched标志...
  • 运行状态:进程正在处理机上运行。在单处理机环境下,每一时刻最多只有一个进程处于运行状态;...创建步骤包括:申请空白的 PCB,向 PCB 中填写一些控制和管理信息,系统进程分配运行时所需的资源。
  • 进程间的状态切换

    2019-05-21 21:31:27
    任何一个进程在它的生命周期内都会处于下面三种状态,使用这三种状态可以简单描述运行在计算机上的进程之间的状态切换进程的一生都处在这三种状态间相互转换。 运行态(Running):指该进程正在被CPU调度运行。 ...
  • 操作系统进程相关知识学习
  • 操作系统在管理内存时,每个进程都有一个独立的进程地址空间,进程地址空间的地址为虚拟地址,对于32位操作系统,该虚拟地址空间为2^32=4GB。其中0-3G是用户空间,3G-4G是内核空间。但4G的地址空间是不存在的,也...
  • 进程的状态和转换三态模型一个进程从创建而产生至撤销而消亡的整个生命周期,可以用一组状态加以刻划,根据三态模型,进程的生命周期可分为如下三种进程状态: 1. 运行态(running):占有处理器正在运行 2. 就绪态...
  • 操作系统4————进程同步 一.目录 操作系统4————进程同步 一.目录 二.进程同步的基本概念 1. 同步机制的引入目的 2. 临界资源 3. 临界区 4. 两种形式的制约关系 5. 同步机制应遵循的...
  • 操作系统实验之基于内核栈切换进程切换
  • 进程管理模拟:实现操作系统进程管理功能,如实现进程的控制(进程创建,状态转换、进程撤销),进程并发执行。 文件管理模拟:实现文件系统的管理,如目录管理,创建文件,打开文件,读写文件,删除文件等功能。 ...
1 2 3 4 5 ... 20
收藏数 493,156
精华内容 197,262
关键字:

操作系统 进程转换