精华内容
下载资源
问答
  • 1.进程状态转换模拟.c

    2020-05-18 18:25:44
    操作系统上机操作实验,进程三种状态转换的模拟,用队列进行的模拟 操作系统上机操作实验,进程三种状态转换的模拟,用队列进行的模拟
  • 2、 定义进程状态转换方式:进程的状态转换是由进程内部操作或操作系统的控制引起,由于无法实现这些功能,学生可以采用随机数方法或键盘控制方法模拟,并实现对应的控制程序。随机方法指产生1-6的随机数,分别代表...
  • 进程状态模拟转换课程设计代码,使用python编写,设计要求:模拟两种系统资源,每种资源的初始数目有自己设定 ...至少模拟四种条件下的进程状态转换,即进程调度、时间片用完、I/O请求和I/O完成等四种条件
  • 1) 设计并实现一个模拟进程状态转换及其相应PCB内容、组织结构变化的程序。 2) 独立编写、调试程序。进程的数目、进程的状态模型(三状态、五状态、七状态或其它)以及PCB的组织形式可自行选择。 3) 合理设计与进程...
  • 进程状态转换

    2013-03-31 16:03:42
    一个模拟系统,模拟进程间的状态转换,操作系统的入门实验,也是比较重要的吧!主要是涉及到进程同步问题
  • 进程状态转换模拟

    千次阅读 2020-07-16 20:40:58
    进程状态转换模拟 1、题目 针对进程五状态图,设计一个进程管理的模拟仿真系统。系统中,CPU有2个,输入设备1个,输出设备1个,进程上限为100个。 (1)设计每个进程的PCB结构(至少应该有进程号等信息),设计每个...

    进程状态转换模拟

    1、题目

    针对进程五状态图,设计一个进程管理的模拟仿真系统。系统中,CPU有2个,输入设备1个,输出设备1个,进程上限为100个。
    (1)设计每个进程的PCB结构(至少应该有进程号等信息),设计每个进程的代码指令集合(可以用输出语句模拟指令,这样程序的执行可以用输出结果来模拟),如某个程序的代码可以如下:
    printf(”执行计算指令XXX; \n”);
    printf(”执行输入指令III; \n”);
    printf(”执行输出指令OOO; \n”);
    (2)设计就绪队列、运行队列、阻塞队列;
    (3)进程调度为时间片轮转调度,时间片自行设定大小(静态或者动态)。
    (4)进程根据自身的指令集合中是否包含I/O指令分为纯计算型进程和I/O型进程,纯计算型进程时间片结束后,进入就绪转态,I/O型进程执行I/O指令会进入阻塞状态。
    (5)输入设备和输出设备的管理采用先进先出调度。
    (6)进程随机产生进入系统。
    (7)其他自行设定的约束条件。
    为了使参与并发执行的每个程序都能独立地运行,在操作系统中必须为之配置一个专门的数据结构,称为进程控制块(PCB)。系统利用PCB来描述进程的基本情况和活动过程,进而控制和管理进程。这样,由程序段、相关的数据段和PCB三部分构成了进程。

    2、进程五种基本状态及转换

    创建状态:如果进程所需的资源尚不能得到满足,比如系统尚无足够的内存使进程无法装入其中,此时,创建工作尚未完成,进程不能被调度运行,于是把此时进程所处的状态称为创建状态。
    就绪状态:这里指进程已处于准备好运行的状态,即进程已分配到除CPU以外的所有必要资源后,只要在获得CPU,便可立即执行。
    执行状态:这里指进程已获得CPU,其程序正在执行的状态。
    阻塞状态:这里指正在执行的进程由于发生某事件暂时无法继续执行的状态,亦即进程的执行受到阻塞。
    终止状态:当一个进程到达了自然结束点,或是出现了无法克服的错误,或是被操作系统所终结,或是被其他有终止权的进程所终结,它将进入终止状态。

    在这里插入图片描述
    图1:进程的五种基本状态及转换图

    对于处于创建状态的进程,当其获得了所需的资源以及对其PCB的初始化工作完成后,即可由创建状态转入就绪状态。处于就绪状态的进程,在调度程序为之分配了处理机之后便可执行,相应地,其状态就由就绪状态转变为执行状态。正在执行的进程如果因分配给它的时间片已完而被剥夺处理机暂停执行时,其状态便由执行状态转为就绪状态。如果因发生某事件,致使当前进程的执行受阻,使之无法继续执行,即该进程状态将由执行状态转变为阻塞状态。当一个进程到达了自然结束点,或是出现了无法克服的错误,或是被操作系统所终结,或是被其他有终止权的进程所终结,它将进入终止状态。如图1所示。

    3、设备

    IDE:DEV-c++
    操作系统:Windows

    4、题目内容

    (1)CPU有2个为别为:cpu_1、cpu_2;
    进程数(进程上限):L 100;
    时间片:T 10;
    类型:type 1:计算,2:输入,3:输出;
    进程号:pid;
    运行时间:runtime;
    进程:p;
    进程控制块:PCB;
    (2)就绪队列、阻塞队列:ready、wait;
    线程(多线程):三个线程,分别为两个CPU,输入输出设备 pthread_t tids[3];
    锁:pthread_mutex_t lock
    由于有2个CPU,防止2个CPU同时访问一个进程,需锁住就绪队列,从就绪队列头部取出到执行,判断类型,如果是输入或者输出,则执行io请求,进入阻塞状态;若时间片大于0并且运行时间大于0,则进程执行计算指令XXX,若运行时间等于0,进程执行完成。否则,进程时间用完,时间片轮转调度。判断阻塞队列是否为空,从阻塞队列拿出(先进先出),进程执行输入指令III或执行输出指令OOO,最后结束。

    5、代码及运行结果

    5.1.代码:

    #include <iostream>
    #include <queue>
    #include <time.h>
    #include <stdlib.h>
    #include <pthread.h> 
    #include <windows.h>
    #define T 10 // 时间片 
    #define L 100 // 进程数 
    using namespace std; 
    struct PCB
    {
    	int pid;  
    	int runtime; // 运行时间 
    	int type; // 类型 1:计算,2:输入,3:输出 
    };
    
    queue<PCB*> ready, wait; // 就绪队列、阻塞队列 
    pthread_mutex_t lock; // 锁住就绪队列 
    
    void *cpu_1(void *)
    {
    	int time_length = T;
    	PCB *pcb = NULL;
    	while(1)
    	{
    		if(pcb == NULL) // 就绪->执行 
    		{
    			pthread_mutex_lock(&lock);
    			if(!ready.empty())
    			{
    				pcb = ready.front();
    				ready.pop();
    			}
    			pthread_mutex_unlock(&lock);
    		}
    		else // 执行 
    		{
    			if(pcb->type==2 || pcb->type==3)
    			{
    				printf("第1个CPU 进程%d 执行io请求\n", pcb->pid);
    				wait.push(pcb); 
    				pcb = NULL;
    				continue;
    			}
    			if(time_length>0) // 当前时间片 > 0 
    			{
    				time_length --;
    				
    				if(pcb->type==1 && pcb->runtime>0)
    				{
    					pcb->runtime --;
    					printf("第1个CPU 进程%d 执行计算指令XXX\n", pcb->pid);
    					if(pcb->runtime == 0)
    					{
    						printf("第1个CPU 进程%d 执行完成\n", pcb->pid);
    						time_length = T; 
    						pcb = NULL;
    					}
    				}
    			}
    			else
    			{
    				printf("第1个CPU 进程%d 时间用完\n", pcb->pid);
    				ready.push(pcb);
    				time_length = T;
    				pcb = NULL;
    				continue;
    			} 
    		} 
    		Sleep(5); 
    	}
    }
    
    void *cpu_2(void *)
    {
    	int time_length = T;
    	PCB *pcb = NULL;
    	while(1)
    	{
    		if(pcb == NULL) // 就绪->执行 
    		{
    			pthread_mutex_lock(&lock);
    			if(!ready.empty())
    			{
    				pcb = ready.front();
    				ready.pop();
    			}
    			pthread_mutex_unlock(&lock);
    		}
    		else // 执行 
    		{
    			if(pcb->type==2 || pcb->type==3)
    			{
    				printf("第2个CPU 进程%d 执行io请求\n", pcb->pid);
    				wait.push(pcb); 
    				pcb = NULL;
    				continue;
    			}
    			if(time_length>0) // 当前时间片 > 0 
    			{
    				time_length --;
    				
    				if(pcb->type==1 && pcb->runtime>0)
    				{
    					pcb->runtime --;
    					printf("第2个CPU 进程%d 执行计算指令XXX\n", pcb->pid);
    					if(pcb->runtime == 0)
    					{
    						printf("第2个CPU 进程%d 执行完成\n", pcb->pid);
    						time_length = T; 
    						pcb = NULL;
    					}
    				}
    			}
    			else
    			{
    				printf("第2个CPU 进程%d 时间用完\n", pcb->pid);
    				ready.push(pcb);
    				time_length = T;
    				pcb = NULL;
    				continue;
    			} 
    		} 
    		Sleep(5); 
    	}
    }
    
    void *io(void *)
    {
    	while(1)
    	{
    		if(wait.empty())
    		{
    			Sleep(1000);
    			continue;
    		}
    		else
    		{
    			PCB *pcb = wait.front();
    			wait.pop();
    			if(pcb->type == 2)
    				printf(" 输入设备 进程%d 执行输入指令III\n", pcb->pid);
    			else if(pcb->type == 3)
    				printf(" 输出设备 进程%d 执行输出指令OOO\n", pcb->pid);
    		}
    		Sleep(5);
    	}
    }
    
    int main()
    {
    	pthread_mutex_init(&lock, NULL);
    	srand((unsigned)time(NULL)); 
    	
    	for(int i=0; i<L; i++)
    	{
    		PCB *p = new PCB();
    		p->pid = i+1;
    		p->runtime = rand()%60 + 1; 
    		p->type = rand()%3+1;
    		ready.push(p);
    	}
    	
    	// 三个线程:分别为两个CPU,输入输出设备 
    	pthread_t tids[3];
    	pthread_create(&tids[0], NULL, cpu_1, NULL);
    	pthread_create(&tids[1], NULL, cpu_2, NULL);
    	pthread_create(&tids[2], NULL, io, NULL);
    	pthread_join(tids[0], NULL);
    	pthread_join(tids[1], NULL);
    	pthread_join(tids[2], NULL);	
    	pthread_mutex_destroy(&lock);
    	return 0;
    }
    
    
    

    5.2.运行结果:

    在这里插入图片描述

    展开全文
  • 进程状态转换源代码+报告,绝对是可以用的。。。。。。。。
  • 操作系统-进程状态转换

    万次阅读 多人点赞 2019-03-23 11:30:01
    对于调度进程,只需要等待就绪队列里的进程,因为阻塞状态可以转换到就绪队列里去。 进程状态状态进程已经创建,但未被OS接纳为可执行进程。(还没有申请到相应的资源)。 就绪态:进程...

    一、进程状态

    1.创建状态
    进程由创建而产生。创建进程是一个非常复杂的过程,一般需要通过多个步骤才能完成:如首先由进程申请一个空白的进程控制块(PCB),并向PCB中填写用于控制和管理进程的信息;然后为该进程分配运行时所必须的资源;最后,把该进程转入就绪状态并插入到就绪队列中。

    2.就绪状态
    这是指进程已经准备好运行的状态,即进程已分配到除CPU以外所有的必要资源后,只要再获得CPU,便可立即执行。如果系统中有许多处于就绪状态的进程,通常将它们按照一定的策略排成一个队列,该队列称为就绪队列。有执行资格,没有执行权的进程。

    3.运行状态
    这里指进程已经获取CPU,其进程处于正在执行的状态。对任何一个时刻而言,在单处理机的系统中,只有一个进程处于执行状态而在多处理机系统中,有多个进程处于执行状态。既有执行资格,又有执行权的进程。

    4.阻塞状态
    这里是指正在执行的进程由于发生某事件(如I/O请求、申请缓冲区失败等)暂时无法继续执行的状态,即进程执行受到阻塞。此时引起进程调度,操作系统把处理机分配给另外一个就绪的进程,而让受阻的进程处于暂停的状态,一般将这个暂停状态称为阻塞状态

    5.终止状态
    进程的终止也要通过两个步骤:首先,是等待操作系统进行善后处理,最后将其PCB清零,并将PCB空间返还给系统。当一个进程到达了自然结束点,或是出现了无法克服的错误,或是被操作系统所终结,或是被其他有终止权的进程所终结,它将进入终止状态。进入终止态的进程以后不能在再执行,但是操作系统中任然保留了一个记录,其中保存状态码和一些计时统计数据,供其他进程进行收集。一旦其他进程完成了对其信息的提取之后,操作系统将删除其进程,即将其PCB清零,并将该空白的PCB返回给系统。

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

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

    2. 进程五状态

    在这里插入图片描述

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

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

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

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

    5. 终止状态.

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

    l 内存资源紧张

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

    解决方法

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

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

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

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

    展开全文
  • 实验:模拟进程状态转换程序 一、实验内容完成情况(请写明自己已完成的项目功能): 完成进程控制块结构体的编写 创建就绪队列、阻塞队列、运行队列、完成队列、挂起队列 初始化操作系统的原始进程:可静态设置也...

    实验:模拟进程状态转换程序

    一、实验内容完成情况(请写明自己已完成的项目功能):

    1. 完成进程控制块结构体的编写
    2. 创建就绪队列、阻塞队列、运行队列、完成队列、挂起队列
    3. 初始化操作系统的原始进程:可静态设置也可动态添加
    4. 编写新建进程函数
    5. 系统开始调度
    6. 当前运行进程请求 I/O 事件
    7. 某进程 I/O 完成
    8. 时间片到期
    9. 其他阻塞事件
    10. 挂起
    11. 完成先来先服务算法
    12. 完成优先级调度算法
    13. 完成时间片轮转算法
    14. 查看当前所有进程的 PCB 信息
    15. 查看当前时刻就绪队列和阻塞队伍信息
    16. 查看当前正在运行的进程信息
    17. 计算当前时刻,每个进程的周转时间。

    三、模块说明及相应代码:
    1、 初始化操作系统(请文字写明思路并给出核心代码):
    1) 创建PCB的结构体:
    思路:根据实验要求完成结构体的创建
    代码:
    typedef struct node
    {
    char name[20]; //进程名
    int id = 0; //进程ID
    int priority = 0; //优先级
    int ArriTime = 0; //进程到达时间
    int serviceTime=0; //进程总需要时间
    int needTime = 0; //还需要运行时间
    int CPUTime = 0; //已用CPU时间
    char state[20]; //进程状态 1.Ready 2.Run 3.Wait 4.Finish
    int finishTime = 0; //完成时间
    char blockCause[30]; //阻塞原因
    int aroundTime=0; //周转时间
    } PCB;
    2) 创建就绪队列、阻塞队列、运行队列:采用队列的方式/其他方式也可以
    思路:用队列的方式
    代码:
    queue processQueue, readyQueue, blockQueue, runQueue, finishQueue,hungQueue;//临时队列、就绪队列、阻塞队列、运行队列、完成队列、挂起队列
    3)编写创建进程函数:
    思路:分为手动输入还是自动输入,手动输入为用户自己创建,自动输入为调入我自己初始化的进程。
    代码:
    //初始化进程
    void Init()
    {
    PCB p1, p2, p3,p4,p5;
    strcpy(p1.name, “a”);
    p1.id = 1;
    p1.priority = 8;
    p1.ArriTime = 2;
    p1.needTime = 4;
    p1.serviceTime=4;
    processQueue.push(p1);
    strcpy(p2.name, “b”);
    p2.id = 2;
    p2.priority = 4;
    p2.ArriTime = 6;
    p2.needTime = 4;
    p2.serviceTime=4;
    processQueue.push(p2);
    strcpy(p3.name, “c”);
    p3.id = 3;
    p3.priority = 7;
    p3.ArriTime = 3;
    p3.needTime = 9;
    p3.serviceTime=9;
    processQueue.push(p3);
    strcpy(p4.name, “d”);
    p4.id = 4;
    p4.priority = 1;
    p4.ArriTime = 0;
    p4.needTime = 1;
    p4.serviceTime=1;
    processQueue.push(p4);
    strcpy(p5.name, “e”);
    p5.id = 5;
    p5.priority = 2;
    p5.ArriTime = 2;
    p5.needTime = 2;
    p5.serviceTime=2;
    processQueue.push(p5);
    }

    //添加进程
    void addProcess()
    {
    int n;
    cout << “请输入要添加的进程数:” << endl;
    cin >> n;
    for (int i = 0; i < n; i++)
    {
    PCB p;
    cout << “请输入第”<<i+1<<“个进程名、进程优先级、进程到达时间、进程需要运行时间:” << endl;
    cin >> p.name>>p.priority>> p.ArriTime>> p.serviceTime;
    p.id=i+1;
    p.needTime=p.serviceTime;
    processQueue.push§;
    }
    }
    2、 进程在其生命周期的都处于不断变换的过程,处理至少四种事件:(请文字写明思路并给出核心代码)

    1. 设置调度算法
      思路:设置菜单,让用户自己选择使用算法,设置调度算法。
      代码:
      int e;
      cout << “请输入算法” << endl;
      cout << “1.先来先服务 2.优先级抢占 3.时间片轮转” << endl;
      cin >> e;
      switch (e)
      {
      case 1:
      FCFS();
      break;
      case 2:
      SJF();
      break;
      case 3:
      RR();
      break;
      }
    2. 调度开始
      思路:调度开始,程序先判断运行队列是否为空,如果为空,就将就绪队列的队头元素压入运行队列中,如果就绪队列为空,则判断阻塞队列是否为空,再判断挂起队列是否为空,若都为空则结束程序。
      代码:
      //系统开始调度
      void beginDispatch()
      {
      if (runQueue.empty())
      {
      if (!readyQueue.empty())
      {
      strcpy(readyQueue.front().state,“Run”);
      runQueue.push(readyQueue.front());
      readyQueue.pop();
      runQueue.front().CPUTime++;
      runQueue.front().needTime–;
      time++;
      }
      else if(!blockQueue.empty())
      {
      char chance=‘p’;
      cout<<endl;
      cout<<“就绪队列不为*************”<<endl;
      cout<<“若结束序请按y,若不结束请按n"<<endl;
      cin>>chance
      if(chance=‘y’)
      {
      finish = true;
      return;
      }
      }
      else if(!hungQueue.empty())
      {
      char chance=‘p’;
      cout<<endl;
      cout<<"挂起队列不为空
      ***********”<<endl;
      cout<<"**若结束程序请按y,若不结束请按n"<<endl;
      cin>>chance;
      if(chance==‘y’)
      {
      finish = true;
      return;
      }
      }
      else
      {
      finish = true;
      return;
      }
      }
      else if (!runQueue.empty())
      {
      if (runQueue.front().needTime == 0)
      {
      runQueue.front().finishTime = time;
      strcpy(runQueue.front().state,“Finish”);
      finishQueue.push(runQueue.front());
      runQueue.pop();
      if (!readyQueue.empty())
      {
      strcpy(readyQueue.front().state,“Run”);
      runQueue.push(readyQueue.front());
      readyQueue.pop();
      }
      }
      //先来先服务
      if (algorithm == 1)
      {
      time++;
      runQueue.front().CPUTime++;
      runQueue.front().needTime–;
      }
      //优先级
      if (algorithm == 2)
      {
      time++;
      runQueue.front().CPUTime++;
      runQueue.front().needTime–;
      }
      //时间片轮转算法
      if(algorithm == 3)
      {
      time++;
      runQueue.front().CPUTime++;
      runQueue.front().needTime–;
      if (runQueue.front().needTime != 0)
      {
      if ((runQueue.front().CPUTime >= timeslice) &&(runQueue.front().CPUTime % timeslice == 0))
      {
      strcpy(runQueue.front().state,“Ready”);
      readyQueue.push(runQueue.front());
      runQueue.pop();
      if (!readyQueue.empty())
      {
      strcpy(readyQueue.front().state,“Run”);
      runQueue.push(readyQueue.front());
      readyQueue.pop();
      }
      }
      }
      }
      }
    3. CPU运行时间
      思路:用一个全局变量time计算CPU的运行时间,每运行一次time++;
    4. I/O事件
      思路:若用户在菜单键选择请求I/O事件,先判断运行队列是否为空,若为空则提示当前无进程运行,反之则将当前正在运行的进程压入阻塞队列,状态改为“wait”,阻塞原因改为“请求I/O事件”。
      代码:
      //当前运行进程请求 I/O 事件
      void IORequest()
      {
      if (!runQueue.empty())
      {
      if (runQueue.front().needTime != 0)
      {
      strcpy(runQueue.front().blockCause, “请求 I/O 事件”);
      strcpy(runQueue.front().state,“Wait”);
      blockQueue.push(runQueue.front());
      runQueue.pop();
      }
      }
      else
      {
      cout << “当前无运行进程” << endl;
      }
      }
    5. I/O完成
      思路:若用户在菜单键选择I/O完成,先判断阻塞队列是否为空,若为空则提示当前无进程阻塞,反之用户输入I/O完成的队列的id,遍历一遍阻塞队列中id与输入id匹配的进程,则将当前正在运行的进程压入阻塞队列,状态改为“wait”,阻塞原因改为“请求I/O事件”。
      代码:
      //某进程I/O完成
      void IOFinish()
      {
      //空
      if (blockQueue.empty())
      {
      cout << “目前无阻塞进程” << endl;
      }
      //不空
      else
      {
      int id;
      cout << “请输入I/O完成的进程ID” << endl;
      cin >> id;
      for (int i = 0; i < blockQueue.size(); i++)
      {
      if (blockQueue.front().id == id)
      {
      strcpy(blockQueue.front().blockCause, " ");
      strcpy(blockQueue.front().state,“Ready”);
      readyQueue.push(blockQueue.front());
      blockQueue.pop();
      if (algorithm == 1)//先来先服务
      {
      //排序
      PCB temp[readyQueue.size()];
      int n = 0;
      while (!readyQueue.empty())
      {
      temp[n] = readyQueue.front();
      readyQueue.pop();
      n++;
      }
      sort(temp, temp + n, cmp1());
      for (int i = 0; i < n; i++)
      {
      readyQueue.push(temp[i]);
      }
      }
      if (algorithm == 2)//优先级
      { if (algorithm == 1)//先来先服务
      {
      //排序
      PCB temp[readyQueue.size()];
      int n = 0;
      while (!readyQueue.empty())
      {
      temp[n] = readyQueue.front();
      readyQueue.pop();
      n++;
      }
      sort(temp, temp + n, cmp1());
      for (int i = 0; i < n; i++)
      {
      readyQueue.push(temp[i]);
      }
      //排序
      PCB temp[readyQueue.size()];
      int n = 0;
      while (!readyQueue.empty())
      {
      temp[n] = readyQueue.front();
      readyQueue.pop();
      n++;
      }
      sort(temp, temp + n, cmp2());
      for (int i = 0; i < n; i++)
      {
      readyQueue.push(temp[i]);
      }
      }
      if (algorithm == 3)//时间片轮转
      {
      //排序
      PCB temp[readyQueue.size()];
      int n = 0;
      while (!readyQueue.empty())
      {
      temp[n] = readyQueue.front();
      readyQueue.pop();
      n++;
      }
      for (int i = 0; i < n; i++)
      {
      readyQueue.push(temp[i]);
      }
      }
      }
      else
      {
      blockQueue.push(blockQueue.front());
      blockQueue.pop();
      }
      }
      }
      3写函数查看当前系统状态:(请文字写明思路并给出核心代码)
    6. 如何查看系统信息
      思路:打印相应队列中的信息
      代码:
      //显示就绪队列
      void displayReady()
      {
      cout << “----------------就绪队列----------------” << endl;
      queue temp = readyQueue;
      while (!temp.empty())
      {
      if(algorithm == 1)
      {
      cout << “进程名” <<" 进程ID"<< " 到达时间"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<< " 周转时间"<< " 状态"<< endl;
      while (!temp.empty())
      {
      cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().ArriTime<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<<temp.front().CPUTime<<” “<<temp.front().CPUTime-temp.front().ArriTime<<” “<<temp.front().state<<endl;
      temp.pop();
      cout << endl;
      }
      }
      if(algorithm == 2)
      {
      cout << “进程名” <<” 进程ID"<< " 优先级"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<< " 周转时间"<< " 状态"<< endl;
      while (!temp.empty())
      {
      cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().priority<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<< temp.front().CPUTime<<” “<<temp.front().finishTime-temp.front().ArriTime<<” “<< temp.front().state<<endl;
      temp.pop();
      cout << endl;
      }
      }
      if(algorithm == 3)
      {
      cout << “进程名” <<” 进程ID"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<< " 周转时间"<< " 状态"<< endl;
      while (!temp.empty())
      {
      cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<<temp.front().CPUTime<<” “<<temp.front().finishTime-temp.front().ArriTime<<” "<<temp.front().state<<endl;
      temp.pop();
      cout << endl;
      }
      }
      }

    }
    //显示运行队列
    void displayRun()
    {
    cout << “----------------运行队列----------------” << endl;
    queue temp = runQueue;
    while (!temp.empty())
    {
    if(algorithm == 1)
    {
    cout << “进程名” <<" 进程ID"<< " 到达时间"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<<" 周转时间"<< " 状态"<< endl;
    while (!temp.empty())
    {
    cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().ArriTime<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<<temp.front().CPUTime<<” “<<temp.front().CPUTime-temp.front().ArriTime<<” “<<temp.front().state<<endl;
    temp.pop();
    cout << endl;
    }
    }
    if(algorithm == 2)
    {
    cout << “进程名” <<” 进程ID"<< " 优先级"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<< " 周转时间"<< " 状态"<< endl;
    while (!temp.empty())
    {
    cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().priority<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<< temp.front().CPUTime<<” “<< temp.front().finishTime-temp.front().ArriTime<<” “<< temp.front().state<<endl;
    temp.pop();
    cout << endl;
    }
    }
    if(algorithm == 3)
    {
    cout << “进程名” <<” 进程ID"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<< " 周转时间"<< " 状态"<< endl;
    while (!temp.empty())
    {
    cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<<temp.front().CPUTime<<” “<<temp.front().finishTime-temp.front().ArriTime<<” “<<temp.front().state<<endl;
    temp.pop();
    cout << endl;
    }
    }
    }
    }
    //显示阻塞队列
    void displayBlock()
    {
    cout << “----------------阻塞队列----------------” << endl;
    queue temp = blockQueue;
    while (!temp.empty())
    {
    if(algorithm == 1)
    {
    cout << “进程名” <<” 进程ID"<< " 到达时间"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<<" 周转时间"<< " 状态"<< " 阻塞原因"<< endl;
    while (!temp.empty())
    {
    cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().ArriTime<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<<temp.front().CPUTime<<” “<<temp.front().CPUTime-temp.front().ArriTime<<” “<<temp.front().state<<” “<<temp.front().blockCause<<endl;
    temp.pop();
    cout << endl;
    }
    }
    if(algorithm == 2)
    {
    cout << “进程名” <<” 进程ID"<< " 优先级"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<<" 周转时间"<< " 状态"<< " 阻塞原因"<< endl;
    while (!temp.empty())
    {
    cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().priority<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<< temp.front().CPUTime<<” “<< temp.front().finishTime-temp.front().ArriTime<<” “<< temp.front().state<<” “<<temp.front().blockCause<<endl;
    temp.pop();
    cout << endl;
    }
    }
    if(algorithm == 3)
    {
    cout << “进程名” <<” 进程ID"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<<" 周转时间"<< " 状态"<< " 阻塞原因"<< endl;
    while (!temp.empty())
    {
    cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<<temp.front().CPUTime<<” “<<temp.front().finishTime-temp.front().ArriTime<<” “<<temp.front().state<<” “<<temp.front().blockCause<<endl;
    temp.pop();
    cout << endl;
    }
    }
    }
    }
    //显示完成队列
    void displayFinish()
    {
    cout << “----------------完成队列----------------” << endl;
    queue temp = finishQueue;
    while (!temp.empty())
    {
    if(algorithm == 1)
    {
    cout << “进程名” <<” 进程ID"<< " 到达时间"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<< " 完成时间"<< " 周转时间"<< " 状态"<< endl;
    while (!temp.empty())
    {
    cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().ArriTime<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<<temp.front().CPUTime<<” “<< temp.front().finishTime<<” “<< temp.front().finishTime-temp.front().ArriTime<<” “<<temp.front().state<<endl;
    temp.pop();
    cout << endl;
    }
    }
    if(algorithm == 2)
    {
    cout << “进程名” <<” 进程ID"<< " 优先级"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<< " 周转时间"<< " 完成时间"<< " 状态"<< endl;
    while (!temp.empty())
    {
    cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().priority<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<< temp.front().CPUTime<<” “<< temp.front().finishTime-temp.front().ArriTime<<” “<< temp.front().finishTime<<” “<< temp.front().state<<endl;
    temp.pop();
    cout << endl;
    }
    }
    if(algorithm == 3)
    {
    cout << “进程名” <<” 进程ID"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<< " 周转时间"<< " 完成时间"<< " 状态"<< endl;
    while (!temp.empty())
    {
    cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<<temp.front().CPUTime<<” “<<temp.front().finishTime-temp.front().ArriTime<<” “<< temp.front().finishTime<<” "<<temp.front().state<<endl;
    temp.pop();
    cout << endl;
    }
    }
    }

    }
    //显示挂起队列
    void displayHung()
    {
    cout << “----------------挂起队列----------------” << endl;
    queue temp = hungQueue;
    while (!temp.empty())
    {
    if(algorithm == 1)
    {
    cout << “进程名” <<" 进程ID"<< " 到达时间"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<<" 周转时间"<< " 状态"<< " 挂起原因"<< endl;
    while (!temp.empty())
    {
    cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().ArriTime<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<<temp.front().CPUTime<<” “<<temp.front().CPUTime-temp.front().ArriTime<<” “<<temp.front().state<<” “<<temp.front().blockCause<<endl;
    temp.pop();
    cout << endl;
    }
    }
    if(algorithm == 2)
    {
    cout << “进程名” <<” 进程ID"<< " 优先级"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<<" 周转时间"<< " 状态"<< " 挂起原因"<< endl;
    while (!temp.empty())
    {
    cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().priority<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<< temp.front().CPUTime<<” “<< temp.front().finishTime-temp.front().ArriTime<<” “<< temp.front().state<<” “<<temp.front().blockCause<<endl;
    temp.pop();
    cout << endl;
    }
    }
    if(algorithm == 3)
    {
    cout << “进程名” <<” 进程ID"<< " 服务时间"<< " 需要时间" << " 已用CPU时间"<<" 周转时间"<< " 状态"<< " 挂起原因"<< endl;
    while (!temp.empty())
    {
    cout<<temp.front().name<<" “<<temp.front().id<<” “<< temp.front().serviceTime<<” “<<temp.front().needTime<<” “<<temp.front().CPUTime<<” “<<temp.front().finishTime-temp.front().ArriTime<<” “<<temp.front().state<<” "<<temp.front().blockCause<<endl;
    temp.pop();
    cout << endl;
    }
    }
    }
    }
    2) 周转时间的计算。
    思路:周转事件=完成时间-到达时间。
    代码:
    temp.front().finishTime-temp.front().ArriTime

    3、 需要实现的调度算法:(请文字写明思路并给出核心代码)

    1. 先来先服务调度算法
      思路:详细过程在见开始调度algorithm == 1。
      代码:
      void FCFS()
      {
      algorithm = 1;
      PCB temp[processQueue.size()];
      int n = 0;
      while (!processQueue.empty())
      {
      temp[n] = processQueue.front();
      processQueue.pop();
      n++;
      }
      sort(temp, temp + n, cmp1());
      for (int i = 0; i < n; i++)
      {
      strcpy(temp[i].state,“Ready”);
      readyQueue.push(temp[i]);
      }
      }

    2. 时间片轮转调度算法
      思路:详细过程在见开始调度algorithm == 3。
      代码:
      //时间片轮转
      void RR()
      {
      cout << “请输入时间片大小” << endl;
      cin >> timeslice;
      algorithm = 3;
      readyQueue = processQueue;
      for (int i = 0; i < readyQueue.size(); i++)
      {
      strcpy(readyQueue.front().state,“Ready”);
      readyQueue.push(readyQueue.front());
      readyQueue.pop();
      }
      }

    3. 优先级调度算法
      思路:详细过程在见开始调度algorithm == 2。
      代码:
      //优先级调度算法
      void SJF()
      {
      algorithm = 2;
      PCB temp[processQueue.size()];
      int n = 0;
      while (!processQueue.empty())
      {
      temp[n] = processQueue.front();
      processQueue.pop();
      n++;
      }
      sort(temp, temp + n, cmp2());
      for (int i = 0; i < n; i++)
      {
      strcpy(temp[i].state,“Ready”);
      readyQueue.push(temp[i]);
      }
      }

    完整的代码献上:

    #include <iostream>
    #include <queue>
    #include <algorithm>
    #include <cstdio>
    #include <cstring>
    #include <cstdlib>
    using namespace std;
    const int MAXN = 1000; //假设能够容纳的进程最多的个数
    typedef struct node
    {
        char name[20];       //进程名
        int id = 0;          //进程ID
        int priority = 0;    //优先级
        int ArriTime = 0;    //进程到达时间
        int serviceTime=0;   //进程总需要时间
        int needTime = 0;    //还需要运行时间
        int CPUTime = 0;     //已用CPU时间
        char state[20];       //进程状态 1.Ready 2.Run 3.Wait 4.Finish
        int finishTime = 0;  //完成时间
        char blockCause[30]; //阻塞原因
        int aroundTime=0;    //周转时间
    } PCB;
    
    queue<PCB> processQueue, readyQueue, blockQueue, runQueue, finishQueue,hungQueue;
    int time = 0;      //系统时间
    int algorithm = 0; //算法选择标志
    int timeslice = 0; //时间片大小
    bool finish;       //是否完成
    
    struct cmp1
    {
        bool operator()(const PCB &p1, const PCB &p2)
        {
            return p1.ArriTime < p2.ArriTime; //到达时间从小到大排序
        }
    };
    
    struct cmp2
    {
        bool operator()(const PCB &p1, const PCB &p2)
        {
            return p1.priority > p2.priority; //优先级从大到小排序
        }
    };
    
    //初始化进程
    void Init()
    {
        PCB p1, p2, p3,p4,p5;
        strcpy(p1.name, "a");
        p1.id = 1;
        p1.priority = 8;
        p1.ArriTime = 2;
        p1.needTime = 4;
        p1.serviceTime=4;
        processQueue.push(p1);
        strcpy(p2.name, "b");
        p2.id = 2;
        p2.priority = 4;
        p2.ArriTime = 6;
        p2.needTime = 4;
        p2.serviceTime=4;
        processQueue.push(p2);
        strcpy(p3.name, "c");
        p3.id = 3;
        p3.priority = 7;
        p3.ArriTime = 3;
        p3.needTime = 9;
        p3.serviceTime=9;
        processQueue.push(p3);
        strcpy(p4.name, "d");
        p4.id = 4;
        p4.priority = 1;
        p4.ArriTime = 0;
        p4.needTime = 1;
        p4.serviceTime=1;
        processQueue.push(p4);
        strcpy(p5.name, "e");
        p5.id = 5;
        p5.priority = 2;
        p5.ArriTime = 2;
        p5.needTime = 2;
        p5.serviceTime=2;
        processQueue.push(p5);
    }
    
    //添加进程
    void addProcess()
    {
        int n;
        cout << "请输入要添加的进程数:" << endl;
        cin >> n;
        for (int i = 0; i < n; i++)
        {
            PCB p;
            cout << "请输入第"<<i+1<<"个进程名、进程优先级、进程到达时间、进程需要运行时间:" << endl;
            cin >> p.name>>p.priority>> p.ArriTime>> p.serviceTime;
            p.id=i+1;
            p.needTime=p.serviceTime;
            processQueue.push(p);
        }
    }
    
    //系统开始调度
    void beginDispatch()
    {
        if (runQueue.empty())
        {
            if (!readyQueue.empty())
            {
                strcpy(readyQueue.front().state,"Run");
                runQueue.push(readyQueue.front());
                readyQueue.pop();
                runQueue.front().CPUTime++;
                runQueue.front().needTime--;
                time++;
            }
            else if(!blockQueue.empty())
            {
                char chance='p';
                cout<<endl;
                cout<<"********就绪队列不为空*********************"<<endl;
                cout<<"********若结束程序请按y,若不结束请按n******"<<endl;
                cin>>chance;
                if(chance=='y')
                {
                    finish = true;
                return;
                }
            }
            else if(!hungQueue.empty())
            {
                char chance='p';
                cout<<endl;
                cout<<"********挂起队列不为空*********************"<<endl;
                cout<<"********若结束程序请按y,若不结束请按n******"<<endl;
                cin>>chance;
                if(chance=='y')
                {
                    finish = true;
                return;
                }
            }
            else
            {
                finish = true;
                return;
            }
        }
        else if (!runQueue.empty())
        {
            if (runQueue.front().needTime == 0)
            {
                runQueue.front().finishTime = time;
                strcpy(runQueue.front().state,"Finish");
                finishQueue.push(runQueue.front());
                runQueue.pop();
                if (!readyQueue.empty())
                {
                    strcpy(readyQueue.front().state,"Run");
                    runQueue.push(readyQueue.front());
                    readyQueue.pop();
                }
            }
            //先来先服务
            if (algorithm == 1)
            {
                time++;
                runQueue.front().CPUTime++;
                runQueue.front().needTime--;
            }
            //优先级
            if (algorithm == 2)
            {
                time++;
                runQueue.front().CPUTime++;
                runQueue.front().needTime--;
            }
            //时间片轮转算法
            if(algorithm == 3)
            {
                time++;
                runQueue.front().CPUTime++;
                runQueue.front().needTime--;
                if (runQueue.front().needTime != 0)
                {
                    if ((runQueue.front().CPUTime >= timeslice) && (runQueue.front().CPUTime % timeslice == 0))
                    {
                        strcpy(runQueue.front().state,"Ready");
                        readyQueue.push(runQueue.front());
                        runQueue.pop();
                        if (!readyQueue.empty())
                        {
                            strcpy(readyQueue.front().state,"Run");
                            runQueue.push(readyQueue.front());
                            readyQueue.pop();
                        }
                    }
                }
            }
        }
    }
    
    //当前运行进程请求 I/O 事件
    void IORequest()
    {
        if (!runQueue.empty())
        {
            if (runQueue.front().needTime != 0)
            {
                strcpy(runQueue.front().blockCause, "请求 I/O 事件");
                strcpy(runQueue.front().state,"Wait");
                blockQueue.push(runQueue.front());
                runQueue.pop();
            }
        }
        else
        {
            cout << "当前无运行进程" << endl;
        }
    }
    
    //某进程I/O完成
    void IOFinish()
    {
        //空
        if (blockQueue.empty())
        {
            cout << "目前无阻塞进程" << endl;
        }
        //不空
        else
        {
            int id;
            cout << "请输入I/O完成的进程ID" << endl;
            cin >> id;
            for (int i = 0; i < blockQueue.size(); i++)
            {
                if (blockQueue.front().id == id)
                {
                    strcpy(blockQueue.front().blockCause, " ");
                    strcpy(blockQueue.front().state,"Ready");
                    readyQueue.push(blockQueue.front());
                    blockQueue.pop();
                    if (algorithm == 1)//先来先服务
                    {
                        //排序
                        PCB temp[readyQueue.size()];
                        int n = 0;
                        while (!readyQueue.empty())
                        {
                            temp[n] = readyQueue.front();
                            readyQueue.pop();
                            n++;
                        }
                        sort(temp, temp + n, cmp1());
                        for (int i = 0; i < n; i++)
                        {
                            readyQueue.push(temp[i]);
                        }
                    }
                    if (algorithm == 2)//优先级
                    { if (algorithm == 1)//先来先服务
                    {
                        //排序
                        PCB temp[readyQueue.size()];
                        int n = 0;
                        while (!readyQueue.empty())
                        {
                            temp[n] = readyQueue.front();
                            readyQueue.pop();
                            n++;
                        }
                        sort(temp, temp + n, cmp1());
                        for (int i = 0; i < n; i++)
                        {
                            readyQueue.push(temp[i]);
                        }
                        //排序
                        PCB temp[readyQueue.size()];
                        int n = 0;
                        while (!readyQueue.empty())
                        {
                            temp[n] = readyQueue.front();
                            readyQueue.pop();
                            n++;
                        }
                        sort(temp, temp + n, cmp2());
                        for (int i = 0; i < n; i++)
                        {
                            readyQueue.push(temp[i]);
                        }
                    }
                    if (algorithm == 3)//时间片轮转
                    {
                        //排序
                        PCB temp[readyQueue.size()];
                        int n = 0;
                        while (!readyQueue.empty())
                        {
                            temp[n] = readyQueue.front();
                            readyQueue.pop();
                            n++;
                        }
                        for (int i = 0; i < n; i++)
                        {
                            readyQueue.push(temp[i]);
                        }
                    }
                }
                else
                {
                    blockQueue.push(blockQueue.front());
                    blockQueue.pop();
                }
            }
        }
    }
    //时间片到期
    void timesliceDaoqi()
    {
        if (!runQueue.empty())
        {
            if (runQueue.front().needTime != 0)
            {
                strcpy(runQueue.front().state,"Ready");
                readyQueue.push(runQueue.front());
                runQueue.pop();
            }
        }
        else
        {
            cout << "当前无运行进程" << endl;
        }
    }
    //其他阻塞事件
    void ElseZC()
    {
        if (!runQueue.empty())
        {
            if (runQueue.front().needTime != 0)
            {
                strcpy(runQueue.front().blockCause, "其他阻塞事件");
                strcpy(runQueue.front().state,"Wait");
                blockQueue.push(runQueue.front());
                runQueue.pop();
            }
        }
        else
        {
            cout << "当前无运行进程" << endl;
        }
    }
    void ElseZCFinish()
    {
        //空
        if (blockQueue.empty())
        {
            cout << "目前无阻塞进程" << endl;
        }
        //不空
        else
        {
            int id;
            cout << "请输入其他阻塞事件完成的进程ID" << endl;
            cin >> id;
            for (int i = 0; i < blockQueue.size(); i++)
            {
                if (blockQueue.front().id == id)
                {
                    strcpy(blockQueue.front().blockCause, " ");
                    strcpy(blockQueue.front().state,"Ready");
                    readyQueue.push(blockQueue.front());
                    blockQueue.pop();
                   if (algorithm == 1)//先来先服务
                    {
                        //排序
                        PCB temp[readyQueue.size()];
                        int n = 0;
                        while (!readyQueue.empty())
                        {
                            temp[n] = readyQueue.front();
                            readyQueue.pop();
                            n++;
                        }
                        sort(temp, temp + n, cmp1());
                        for (int i = 0; i < n; i++)
                        {
                            readyQueue.push(temp[i]);
                        }
                    }
                    if (algorithm == 2)//优先级
                    { if (algorithm == 1)//先来先服务
                    {
                        //排序
                        PCB temp[readyQueue.size()];
                        int n = 0;
                        while (!readyQueue.empty())
                        {
                            temp[n] = readyQueue.front();
                            readyQueue.pop();
                            n++;
                        }
                        sort(temp, temp + n, cmp1());
                        for (int i = 0; i < n; i++)
                        {
                            readyQueue.push(temp[i]);
                        }
                        //排序
                        PCB temp[readyQueue.size()];
                        int n = 0;
                        while (!readyQueue.empty())
                        {
                            temp[n] = readyQueue.front();
                            readyQueue.pop();
                            n++;
                        }
                        sort(temp, temp + n, cmp2());
                        for (int i = 0; i < n; i++)
                        {
                            readyQueue.push(temp[i]);
                        }
                    }
                    if (algorithm == 3)//时间片轮转
                    {
                        //排序
                        PCB temp[readyQueue.size()];
                        int n = 0;
                        while (!readyQueue.empty())
                        {
                            temp[n] = readyQueue.front();
                            readyQueue.pop();
                            n++;
                        }
                        for (int i = 0; i < n; i++)
                        {
                            readyQueue.push(temp[i]);
                        }
                    }
                }
                else
                {
                    blockQueue.push(blockQueue.front());
                    blockQueue.pop();
                }
            }
        }
    }
    //挂起
    void Hung()
    {
        if (!runQueue.empty())
        {
            if (runQueue.front().needTime != 0)
            {
                strcpy(runQueue.front().blockCause, "请求挂起");
                strcpy(runQueue.front().state,"Hung");
                hungQueue.push(runQueue.front());
                runQueue.pop();
            }
        }
        else
        {
            cout << "当前无运行进程" << endl;
        }
    }
    //某进程挂起完成
    void HungFinish()
    {
        //空
        if (hungQueue.empty())
        {
            cout << "目前无挂起进程" << endl;
        }
        //不空
        else
        {
            int id;
            cout << "请输入挂起完成的进程ID" << endl;
            cin >> id;
            for (int i = 0; i < hungQueue.size(); i++)
            {
                if (hungQueue.front().id == id)
                {
                    strcpy(hungQueue.front().blockCause, " ");
                    strcpy(hungQueue.front().state,"Ready");
                    readyQueue.push(hungQueue.front());
                    hungQueue.pop();
                    if (algorithm == 1)//先来先服务
                    {
                        //排序
                        PCB temp[readyQueue.size()];
                        int n = 0;
                        while (!readyQueue.empty())
                        {
                            temp[n] = readyQueue.front();
                            readyQueue.pop();
                            n++;
                        }
                        sort(temp, temp + n, cmp1());
                        for (int i = 0; i < n; i++)
                        {
                            readyQueue.push(temp[i]);
                        }
                    }
                    if (algorithm == 2)//优先级
                    { if (algorithm == 1)//先来先服务
                    {
                        //排序
                        PCB temp[readyQueue.size()];
                        int n = 0;
                        while (!readyQueue.empty())
                        {
                            temp[n] = readyQueue.front();
                            readyQueue.pop();
                            n++;
                        }
                        sort(temp, temp + n, cmp1());
                        for (int i = 0; i < n; i++)
                        {
                            readyQueue.push(temp[i]);
                        }
                        //排序
                        PCB temp[readyQueue.size()];
                        int n = 0;
                        while (!readyQueue.empty())
                        {
                            temp[n] = readyQueue.front();
                            readyQueue.pop();
                            n++;
                        }
                        sort(temp, temp + n, cmp2());
                        for (int i = 0; i < n; i++)
                        {
                            readyQueue.push(temp[i]);
                        }
                    }
                    if (algorithm == 3)//时间片轮转
                    {
                        //排序
                        PCB temp[readyQueue.size()];
                        int n = 0;
                        while (!readyQueue.empty())
                        {
                            temp[n] = readyQueue.front();
                            readyQueue.pop();
                            n++;
                        }
                        for (int i = 0; i < n; i++)
                        {
                            readyQueue.push(temp[i]);
                        }
                    }
                }
                else
                {
                    hungQueue.push(hungQueue.front());
                    hungQueue.pop();
                }
            }
        }
    }
    
    
    //显示就绪队列
    void displayReady()
    {
        cout << "----------------就绪队列----------------" << endl;
        queue<PCB> temp = readyQueue;
        while (!temp.empty())
        {
            if(algorithm == 1)
            {
                cout << "进程名" <<"  进程ID"<< "  到达时间"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<< "  周转时间"<< "  状态"<< endl;
                while (!temp.empty())
                {
                    cout<<temp.front().name<<"       "<<temp.front().id<<"       "<< temp.front().ArriTime<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<<temp.front().CPUTime<<"           "<<temp.front().CPUTime-temp.front().ArriTime<<"           "<<temp.front().state<<endl;
                    temp.pop();
                    cout << endl;
                }
            }
            if(algorithm == 2)
            {
                cout << "进程名" <<"  进程ID"<< "  优先级"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<< "  周转时间"<< "  状态"<< endl;
                while (!temp.empty())
                {
                    cout<<temp.front().name<<"       "<<temp.front().id<<"       "<< temp.front().priority<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<< temp.front().CPUTime<<"           "<<temp.front().finishTime-temp.front().ArriTime<<"           "<< temp.front().state<<endl;
                    temp.pop();
                    cout << endl;
                }
            }
            if(algorithm == 3)
            {
                cout << "进程名" <<"  进程ID"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<< "  周转时间"<< "  状态"<< endl;
                while (!temp.empty())
                {
                    cout<<temp.front().name<<"       "<<temp.front().id<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<<temp.front().CPUTime<<"           "<<temp.front().finishTime-temp.front().ArriTime<<"           "<<temp.front().state<<endl;
                    temp.pop();
                    cout << endl;
                }
            }
        }
    
    }
    //显示运行队列
    void displayRun()
    {
        cout << "----------------运行队列----------------" << endl;
        queue<PCB> temp = runQueue;
       while (!temp.empty())
        {
            if(algorithm == 1)
            {
                cout << "进程名" <<"  进程ID"<< "  到达时间"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<<"  周转时间"<< "  状态"<< endl;
                while (!temp.empty())
                {
                    cout<<temp.front().name<<"       "<<temp.front().id<<"       "<< temp.front().ArriTime<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<<temp.front().CPUTime<<"           "<<temp.front().CPUTime-temp.front().ArriTime<<"           "<<temp.front().state<<endl;
                    temp.pop();
                    cout << endl;
                }
            }
            if(algorithm == 2)
            {
                cout << "进程名" <<"  进程ID"<< "  优先级"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<< "  周转时间"<< "  状态"<< endl;
                while (!temp.empty())
                {
                    cout<<temp.front().name<<"       "<<temp.front().id<<"       "<< temp.front().priority<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<< temp.front().CPUTime<<"           "<< temp.front().finishTime-temp.front().ArriTime<<"           "<< temp.front().state<<endl;
                    temp.pop();
                    cout << endl;
                }
            }
            if(algorithm == 3)
            {
                cout << "进程名" <<"  进程ID"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<< "  周转时间"<< "  状态"<< endl;
                while (!temp.empty())
                {
                    cout<<temp.front().name<<"       "<<temp.front().id<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<<temp.front().CPUTime<<"           "<<temp.front().finishTime-temp.front().ArriTime<<"           "<<temp.front().state<<endl;
                    temp.pop();
                    cout << endl;
                }
            }
        }
    }
    //显示阻塞队列
    void displayBlock()
    {
        cout << "----------------阻塞队列----------------" << endl;
        queue<PCB> temp = blockQueue;
        while (!temp.empty())
        {
            if(algorithm == 1)
            {
                cout << "进程名" <<"  进程ID"<< "  到达时间"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<<"  周转时间"<< "  状态"<< "  阻塞原因"<< endl;
                while (!temp.empty())
                {
                    cout<<temp.front().name<<"       "<<temp.front().id<<"       "<< temp.front().ArriTime<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<<temp.front().CPUTime<<"           "<<temp.front().CPUTime-temp.front().ArriTime<<"           "<<temp.front().state<<"      "<<temp.front().blockCause<<endl;
                    temp.pop();
                    cout << endl;
                }
            }
            if(algorithm == 2)
            {
                cout << "进程名" <<"  进程ID"<< "  优先级"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<<"  周转时间"<< "  状态"<< "  阻塞原因"<< endl;
                while (!temp.empty())
                {
                    cout<<temp.front().name<<"       "<<temp.front().id<<"       "<< temp.front().priority<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<< temp.front().CPUTime<<"           "<< temp.front().finishTime-temp.front().ArriTime<<"           "<< temp.front().state<<"      "<<temp.front().blockCause<<endl;
                    temp.pop();
                    cout << endl;
                }
            }
            if(algorithm == 3)
            {
                cout << "进程名" <<"  进程ID"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<<"  周转时间"<< "  状态"<< "  阻塞原因"<< endl;
                while (!temp.empty())
                {
                    cout<<temp.front().name<<"       "<<temp.front().id<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<<temp.front().CPUTime<<"           "<<temp.front().finishTime-temp.front().ArriTime<<"           "<<temp.front().state<<"      "<<temp.front().blockCause<<endl;
                    temp.pop();
                    cout << endl;
                }
            }
        }
    }
    //显示完成队列
    void displayFinish()
    {
        cout << "----------------完成队列----------------" << endl;
        queue<PCB> temp = finishQueue;
        while (!temp.empty())
        {
            if(algorithm == 1)
            {
                cout << "进程名" <<"  进程ID"<< "  到达时间"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<< "  完成时间"<< "  周转时间"<< "  状态"<< endl;
                while (!temp.empty())
                {
                    cout<<temp.front().name<<"       "<<temp.front().id<<"       "<< temp.front().ArriTime<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<<temp.front().CPUTime<<"         "<< temp.front().finishTime<<"         "<< temp.front().finishTime-temp.front().ArriTime<<"           "<<temp.front().state<<endl;
                    temp.pop();
                    cout << endl;
                }
            }
            if(algorithm == 2)
            {
                cout << "进程名" <<"  进程ID"<< "  优先级"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<< "  周转时间"<< "  完成时间"<< "  状态"<< endl;
                while (!temp.empty())
                {
                    cout<<temp.front().name<<"       "<<temp.front().id<<"       "<< temp.front().priority<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<< temp.front().CPUTime<<"           "<< temp.front().finishTime-temp.front().ArriTime<<"         "<< temp.front().finishTime<<"           "<< temp.front().state<<endl;
                    temp.pop();
                    cout << endl;
                }
            }
            if(algorithm == 3)
            {
                cout << "进程名" <<"  进程ID"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<< "  周转时间"<< "  完成时间"<< "  状态"<< endl;
                while (!temp.empty())
                {
                    cout<<temp.front().name<<"       "<<temp.front().id<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<<temp.front().CPUTime<<"           "<<temp.front().finishTime-temp.front().ArriTime<<"         "<< temp.front().finishTime<<"           "<<temp.front().state<<endl;
                    temp.pop();
                    cout << endl;
                }
            }
        }
    
    }
    //显示挂起队列
    void displayHung()
    {
        cout << "----------------挂起队列----------------" << endl;
        queue<PCB> temp = hungQueue;
        while (!temp.empty())
        {
            if(algorithm == 1)
            {
                cout << "进程名" <<"  进程ID"<< "  到达时间"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<<"  周转时间"<< "  状态"<< "  挂起原因"<< endl;
                while (!temp.empty())
                {
                    cout<<temp.front().name<<"       "<<temp.front().id<<"       "<< temp.front().ArriTime<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<<temp.front().CPUTime<<"           "<<temp.front().CPUTime-temp.front().ArriTime<<"           "<<temp.front().state<<"      "<<temp.front().blockCause<<endl;
                    temp.pop();
                    cout << endl;
                }
            }
            if(algorithm == 2)
            {
                cout << "进程名" <<"  进程ID"<< "  优先级"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<<"  周转时间"<< "  状态"<< "  挂起原因"<< endl;
                while (!temp.empty())
                {
                    cout<<temp.front().name<<"       "<<temp.front().id<<"       "<< temp.front().priority<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<< temp.front().CPUTime<<"           "<< temp.front().finishTime-temp.front().ArriTime<<"           "<< temp.front().state<<"      "<<temp.front().blockCause<<endl;
                    temp.pop();
                    cout << endl;
                }
            }
            if(algorithm == 3)
            {
                cout << "进程名" <<"  进程ID"<< "  服务时间"<< "  需要时间" << "  已用CPU时间"<<"  周转时间"<< "  状态"<< "  挂起原因"<< endl;
                while (!temp.empty())
                {
                    cout<<temp.front().name<<"       "<<temp.front().id<<"         "<< temp.front().serviceTime<<"         "<<temp.front().needTime<<"           "<<temp.front().CPUTime<<"           "<<temp.front().finishTime-temp.front().ArriTime<<"           "<<temp.front().state<<"      "<<temp.front().blockCause<<endl;
                    temp.pop();
                    cout << endl;
                }
            }
        }
    }
    //先来先服务
    void FCFS()
    {
        algorithm = 1;
        PCB temp[processQueue.size()];
        int n = 0;
        while (!processQueue.empty())
        {
            temp[n] = processQueue.front();
            processQueue.pop();
            n++;
        }
        sort(temp, temp + n, cmp1());
        for (int i = 0; i < n; i++)
        {
            strcpy(temp[i].state,"Ready");
            readyQueue.push(temp[i]);
        }
    }
    //优先级调度算法
    void SJF()
    {
        algorithm = 2;
        PCB temp[processQueue.size()];
        int n = 0;
        while (!processQueue.empty())
        {
            temp[n] = processQueue.front();
            processQueue.pop();
            n++;
        }
        sort(temp, temp + n, cmp2());
        for (int i = 0; i < n; i++)
        {
            strcpy(temp[i].state,"Ready");
            readyQueue.push(temp[i]);
        }
    }
    //时间片轮转
    void RR()
    {
        cout << "请输入时间片大小" << endl;
        cin >> timeslice;
        algorithm = 3;
        readyQueue = processQueue;
        for (int i = 0; i < readyQueue.size(); i++)
        {
            strcpy(readyQueue.front().state,"Ready");
            readyQueue.push(readyQueue.front());
            readyQueue.pop();
        }
    }
    
    int main()
    {
        cout<<"********进程状态转换系统********"<<endl;
        int chance;
        cout << "1:自动添加进程    2:手动添加进程" << endl;
        cin>>chance;
        switch(chance)
        {
        case 1:
            Init();
            break;
        case 2:
            addProcess();
            break;
        }
        int e;
        cout << "请输入算法" << endl;
        cout << "1.先来先服务 2.优先级抢占 3.时间片轮转" << endl;
        cin >> e;
        switch (e)
        {
        case 1:
            FCFS();
            break;
        case 2:
            SJF();
            break;
        case 3:
            RR();
            break;
        }
        while (true)
        {
            int e;
            cout << "请输入操作" << endl;
            cout << "1.开始调度 2.IO请求 3.IO完成 4.时间片到期 5.其他阻塞事件 6.其他阻塞事件完成 7.挂起 8.挂起完成 0.退出" << endl;
            cin >> e;
            switch (e)
            {
            case 1:
                beginDispatch();
                break;
            case 2:
                IORequest();
                break;
            case 3:
                IOFinish();
                break;
            case 4:
                timesliceDaoqi();
                break;
            case 5:
                ElseZC();
                break;
           case 6:
                ElseZCFinish();
                break;
            case 7:
                Hung();
                break;
            case 8:
                HungFinish();
                break;
            case 0:
                exit(0);
            }
            displayReady();
            displayRun();
            displayBlock();
            displayFinish();
            displayHung();
            cout << "当前系统CPU时间:" << time << endl;
            if (finish)
            {
                cout << "当前进程全部完成" << endl;
                cout << "当前时间:" << time << endl;
                break;
            }
            system("pause");
        }
        system("pause");
        return 0;
    }
    
    
    展开全文
  • 进程状态转换 操作系统实验报告,文件的格式word格式的文件,进程状态转化和pcb表的变化
  • #include #include<stdio.h> #include<stdlib.h> #include<string.h> #include using namespace std; ///就绪->执行 ///执行->就绪(时间片完)、阻塞(等待) ...“进程”<<

    操作系统–进程状态转换

    (SDIBT 计科181)

    用数组模拟的

    我的代码有些bug,望大家提出宝贵意见

    #include<iostream>
    #include<stdio.h>
    using namespace std;
    ///就绪->执行
    ///执行->就绪(时间片完)、阻塞(等待)
    ///阻塞->就绪
    struct PCB//进程结构体
    {
        int id;//进程编号
        int time;//运行总时间
        int runtime;//运行一次的时间
        int pid;//优先级
        int flag;//是否被创建的标志
    } t;
    int SumRun=0;//最多可以同时运行多少进程
    int cntRun=0;//正在运行的进程数目
    int cntWait=0;//正在等待(阻塞)的进程数目
    PCB Run[1000];//用来存储正在运行的进程
    PCB Wait[1000];//用来存储正在等待(阻塞)的进程
    PCB Cre[1000]= {0};//用来存储已经创建的进程
    void init()//初始化
    {
        t.runtime=1;
        t.pid=1000;
    }
    bool Create(int n)//创建
    {
        if(Cre[n].flag==0)
        {
            Cre[n].flag=1;
            cout<<"进程"<<n<<"创建成功!"<<endl;
            return true;
        }
        cout<<"已有进程"<<n<<"!"<<endl;
        return false;
    }
    void input()
    {
        cout<<"请输入进程编号id:";
        cin>>t.id;
        cout<<"请输入优先级pid:";
        cin>>t.pid;
        cout<<"请输入运行时间time:";
        cin>>t.time;
        while(1)
        {
            if(Create(t.id)==true)
            {
                if(cntRun>=SumRun)
                {
                    Wait[cntWait++]=t;
                }
                else
                {
                    Run[cntRun++]=t;
                }
                break;
            }
            else
            {
                cout<<"请重新输入!"<<endl;
                cout<<"请输入进程编号id:";
                cin>>t.id;
                cout<<"请输入优先级pid:";
                cin>>t.pid;
                cout<<"请输入运行时间time:";
                cin>>t.time;
            }
        }
    }
    void Ready(int n)//就绪
    {
        cout<<"进程"<<n<<"处于就绪状态"<<endl;
    }
    void Sort()
    {
        for(int i=0; i<cntWait; i++)
        {
            for(int j=i+1; j<cntWait; j++)
            {
                if(Wait[i].pid>Wait[j].pid)
                {
                    int a,b,c,d,e;
                    c=Wait[i].id;
                    a=Wait[i].pid;
                    b=Wait[i].runtime;
                    d=Wait[i].time;
                    e=Wait[i].flag;
                    Wait[i].id=Wait[j].id;
                    Wait[i].pid=Wait[j].pid;
                    Wait[i].runtime=Wait[j].runtime;
                    Wait[i].time=Wait[j].time;
                    Wait[i].flag=Wait[j].flag;
                    Wait[j].id=c;
                    Wait[j].pid=a;
                    Wait[j].runtime=b;
                    Wait[j].time=d;
                    Wait[j].flag=e;
                }
            }
        }
    }
    void Blocked()//阻塞
    {
        cout<<"正在等待(阻塞)的进程有:"<<endl;
        cout<<"+++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;
        for(int i=0; i<cntWait; i++)
            cout<<"id为"<<Wait[i].id<<"的进程,优先级为"<<Wait[i].pid<<endl;
        cout<<"+++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;
        cout<<endl;
    }
    void Running()//执行
    {
        cout<<"正在运行的进程有:"<<endl;
        cout<<"+++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;
        for(int i=0; i<cntRun; i++)
            cout<<"id为"<<Run[i].id<<"的进程,已经运行了 "<<Run[i].runtime<<",总运行时间为 "<<Run[i].time<<endl;
        cout<<"+++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;
        cout<<endl;
        Blocked();
        Sort();
        for(int j=0; j<cntWait; j++)//排序之后等待的顺序
        {
            printf("wait1.id=%d,pid=%d,time=%d\n",Wait[j].id,Wait[j].pid,Wait[j].time);
        }
        for(int i=0; i<cntRun; i++)
        {
            Run[i].runtime++;
            if(Run[i].time<Run[i].runtime)//运行总时间小于运行时间
            {
                cout<<"id为"<<Run[i].id<<"的进程运行结束。"<<endl;
                for(int j=i; j<cntRun-1; j++)
                {
                    Run[j]=Run[j+1];//将后面的进程赋给前面的
                }
                cntRun--;
                if(cntWait>0)
                {
                    cout<<"id为"<<Wait[0].id<<"的进程开始运行。"<<endl;
                    Run[cntRun++]=Wait[0];
                    cntWait--;
                    for(int j=0; j<cntWait; j++)
                    {
                        Wait[j]=Wait[j+1];//将后面等待的进程赋给前面的
                    }
                }
            }
        }
        if(cntWait)
        {
            for(int i=0; i<cntRun; i++)
            {
                if(Wait[0].pid<Run[i].pid)//优先级高的开始运行,优先级低的进入阻塞状态
                {
                    cout<<"id为"<<Wait[0].id<<"的进程开始运行,id为"<<Run[i].id<<"的进程进入阻塞状"<<endl;
                    t=Run[i];
                    Run[i].pid=Wait[0].pid;
                    Run[i]=Wait[0];
                    cntWait--;//等待的减少一个
                    for(int i=0; i<cntWait; i++)
                    {
                        Wait[i]=Wait[i+1];//将后面等待的进程赋给前面的
                    }
                    Wait[cntWait++]=t;//将进入阻塞状态的赋给等待的数组
                }
            }
        }
    }
    int main()
    {
        char c;
        init();//初始化
        cout<<"请输入可以同时运行的进程数目为:";
        cin>>SumRun;
        cout<<"请输入进程的相关信息:"<<endl;
        while(1)
        {
            input();
            cout<<"cntRun="<<cntRun<<",cntWait="<<cntWait<<endl;
            cout<<"是否继续输入进程( Y(y)/N(n)): ";
            cin>>c;
            if(c=='y'||c=='Y')
                continue;
            else if(c=='n'||c=='N')
                break;
        }
        while(1)
        {
            if(cntRun==0&&cntWait==0)//进程全部运行结束
            {
                cout<<"所有进程运行结束!"<<endl;
                break;
            }
            Running();
            system("pause");
        }
        return 0;
    }
    
    
    展开全文
  • 封闭性:程序在封闭环境下运行,即程序运行时独占全机资源,资源的状态只有本程序才能改变它。程序一旦开始执行,其执行结果不受外界因素影响。 可再现性:只要程序执行时的环境和初始条件相同,当程序重复执行时,...
  • Linux进程状态转换

    2019-09-11 20:57:37
    Linux进程状态 Linux内核中的进程状态 ◆运行状态(TASK_RUNNING) 指正在被CPU运行或者就绪的状态。这样的进程被成为runnning进程。运行态的进程可以分为3种情况:内核运行态、用户运行态、就绪态。 ...
  • 操作系统进程状态转换

    千次阅读 2019-03-19 19:09:35
    操作系统的第一个实验,此程序是为了模拟进程转换过程,实现进程间的相互转换。 源代码: #include <iostream> #include <stdlib.h> #include <time.h> using namespace std; /*类型定义...
  • 由图可知,最开始,操作系统只有三种状态,运行态,就绪态,等待态,运行态就是指CPU正在执行该段代码的状态,而就绪态则是指,万事具备只欠东风的状态,这个东风就是指CPU的时间轮片将CPU资源分到该处时,就可以...
  • 实验一: 进程状态转换及PCB的模拟

    万次阅读 多人点赞 2018-04-07 17:16:58
    2)深入了解进程控制块和进程状态之间的转换。3)掌握进程调度算法。实验预备知识1)进程的状态2)进程的结构——PCB进程都是由一系列操作(动作)所组成,通过这些操作来完成其任务。因此,不同的进程,其内部操作也...
  • 系统按照进程的需求进行适当处理后,启动“进程阻塞原语”将该进程阻塞起来。 引起进程阻塞(运行受阻)的原因 等待I/O 请求资源得不到满足 进程同步约束 服务进程无事可做 阻塞原语Block() 合时调用唤醒原语...
  • 操作系统实验一模拟进程状态转换.docx
  • 操作系统实验一模拟进程状态转换.doc
  • 操作系统课程设计文档,内容为进程状态转换模拟,设计技术参数1)系统中进程的数目; (2)系统资源的种类和数目; (3)系统作业或进程的对每类资源的需求数目; (4)进程运行所需的时间片大小 设计要求:模拟两种...
  • 实验二进程状态转换及其PCB的变化.pdf
  • 进程状态转换,包括创建进程,挂起进程,唤醒进程,结束进程
  • 进程状态查看 ps aux | pa axj 命令 进程状态转换 僵死进程 1、僵死进程是一个比较特殊的状态。当进程退出并且父进程没有读取到子进程退出的返回代码时就会产生僵死(尸)进程。 2、僵死进程会以终止状态保持在进程表...
  • linux 什么是进程和进程状态转换

    千次阅读 2018-08-17 10:23:58
    什么是进程? 从程序角度: 计算机中正在运行在内存中的程序就是进程 从操作系统角度: 进程是一个术语,在UNIX、Linux和其他一些操作系统中,当程序启动时(由用户输入shell命令...进程的几种状态 running ...
  • C#实现进程状态转换

    2011-12-15 16:57:58
    用C#实现进程基本状态转换 Winform界面形式 对学习C#很有帮助
  • 进程状态转换

    千次阅读 2015-08-07 14:47:43
    进程调度 死锁 信号量 时间片轮转调度算法 内存管理 软中断 共享内存 进程间通信
  • 其中,P_Id,和P_Name用来标示一个进程,而P_State用来标示进程的五种状态:Create_state,Ready_state,Block_state,Run_state,Exit_state。P_Runtime标示要完成一个进程所需要的时间。P_Requiry标示一个进程的执行所...
  • 进程状态转换及其PCB的变化

    千次阅读 2017-04-23 15:48:31
    代码实现了模拟进程状态转换及其相应PCB内容、组织结构的变化。 #include using namespace std; typedef struct pcb{ int id; struct pcb *next; }pcb; pcb *ready,*run,*block; pcb* cre()//创建带头结点的...
  • 自行编制模拟程序,通过形象化的状态显示,使学生理解进程的概念、进程之间的状态转换及其所带来的PCB内容 、组织的变化,理解进程与其PCB间的一一对应关系。
  • 操作系统进程状态状态转换详解

    千次阅读 多人点赞 2019-11-01 10:28:55
    进程的状态的转换与PCB详解 ...本文除了进程状态转换,还穿插着对进程的控制的说明。 ​ 注意:本博文中进程均是在传统操作系统中的进程,既是OS进行资源分配的基本单位,也是OS进行调度的一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 286,880
精华内容 114,752
关键字:

进程状态转换

友情链接: 2006 C++.zip