操作系统课程设计并发进程的模拟
操作系统课程设计报告-进程调度的模拟实现

操作系统课程设计报告专业计算机科学与技术学生姓名班级学号指导教师完成日期博雅学院ﻬ题目:进程调度的模拟实现的模拟实现一、设计目的本课程设计是学习完“操作系统原理”课程后进行的一次全面的综合训练,通过课程设计,更好地掌握操作系统的原理及实现方法,加深对操作系统基础理论和重要算法的理解,加强学生的动手能力。
在多道程序和多任务系统中,系统内同时处于就绪状态的进程可能有若干个。
也就是说能运行的进程数大于处理机个数。
为了使系统中的进程能有条不紊地工作,必须选用某种调度策略,选择一进程占用处理机。
要求学生设计一个模拟处理机调度算法,以巩固和加深处理机调度的概念.二、设计内容1)概述选择一个调度算法,实现处理机调度。
设计要求:1)进程调度算法包括:时间片轮转法,短作业优先算法,动态优先级算法。
2)可选择进程数量3)本程序包括三种算法,用C或C++语言实现,执行时在主界面选择算法(可用函数实现),进入子页面后输入进程数,(运行时间,优先数由随机函数产生),执行,显示结果。
调度时总是选取优先数最大的进程优先运行2.每个进程的优先数,运行时间,由程序任意指定.3.为了调度方便,把进程按给定优先级(动态优先级算法中)从小到大排成一个队列。
按给定运行时间(短作业优先)从小到大排成一个队列用一个变量作为队首指针,指向队列的第一个进程。
4.处理机调度总是选队首进程运行。
由于本实验是模拟处理机调度,所以被选中的进程并不实际的启动运行,而是执行:优先数-1(动态优先级算法中)要求运行时间-1来模拟进程的一次运行。
5.进程运行一次后,若要求运行时间不等于0,则再将它加入队列(动态优先级算法中:按优先数大小插入.),且改变队首指针:若要求运行时间=0,则把它的状态改为完成(C)状态,且退出队列。
(5)对于遇到优先数一致的情况,采用FIFO策略解决.3。
概要设计(1)本程序用两种算法对五个进程进行调度,每个进程可有三个状态,并假设初始状态为就绪状态。
操作系统课程设计并发进程的模拟

课程设计说明书题目: 并发进程的模拟院系:计算机科学与工程专业班级:学号:学生姓名:指导教师:2014年 11月 12 日安徽理工大学课程设计(论文)任务书2014年11月21日安徽理工大学课程设计(论文)成绩评定表I目录1问题描述 02需求分析 03概要设计 (1)1. P操作 (1)2. V操作 (2)3. P,V操作实现进程同步 (3)4. 功能模块设计 (4)4详细设计 (6)1.主界面的设计程序 (6)2.进程Pa的执行 (7)3.进程Pb的执行 (8)4.进程Pc的执行 (8)5.按钮的执行 (9)5 调试的分析与运行结果 (10)6 设计体会 (12)参考文献 (13)1问题描述在进程并发执行的过程中,进程之间存在协作的关系,例如,有互斥、同步的关系。
该课程设计的是了解进程同步的概念,理解信号量机制的原理,掌握运用信号量解决进程并发控制问题的方法,进而学会运用进程的同步,利用信号灯的P,V操作实现三个进程的同步。
这三个进程的同步关系如下:从上图中可以看出:任务启动后pa先执行,当它结束后,pb、pc可以开始执行,pb、pc 都执行完毕后,任务终止;设两个同步信号灯sb、sc分别表示进程pb和pc能否开始执行,其初值均为0。
在现代操作系统中,有大量的并发进程在活动,它们都处在不断的申请资源,使用资源以及其它进程的相互制约的活动中,这些进程什么时候停止运行,什么时候该继续向前推进,应根据事先的约定来规范它们的行为,这时我们可以根据同步信号灯来实现进程的同步协调工作。
例如本题中,只有pa进程顺利的进行完,Pb,Pc这两个进程才能正常的进行。
如果进程Pa在进行中出现停止或中断,则Pb和Pc是不会顺利的完成的;而进程Pb,Pc这两个进程是并行执行的,两个进程的进行是互不干扰的,只要进程Pa完成后,进程Pb和Pc才会正常执行,否则只有处在等待就绪中。
2需求分析进程执行的并发性的意义是关于一组进程的执行在是时间上是重叠的,从宏观上看,并发性反应的是一个时间段中几个进程都在同一个处理器上,处于运行还未运行结束状态。
实验三并发进程的多线程模拟

实验三并发进程的多线程模拟本文档主要介绍了并发进程的多线程模拟的相关概念、实现方式以及注意事项。
并发编程是当前软件开发中非常重要的一部分,多线程是实现并发编程的一种常见方式。
通过模拟并发进程,我们可以更好地理解多线程的概念和实现。
1. 多线程模拟的概念多线程模拟是指通过在单个程序中启动多个并发的执行线程来模拟并发进程的执行。
多线程模拟的优点在于可以充分利用多核处理器的并行性能,提高程序的执行效率。
同时,多线程模拟也可以更好地模拟真实的并发场景,测试和调试复杂的并发程序。
多线程模拟通常包括以下几个关键概念:•程序:指的是我们要模拟的并发进程。
•线程:是程序中的最小执行单位,每个线程独立执行指定的任务。
•并发:指的是多个线程在同一时间段内执行。
•互斥:是指多个线程访问共享资源时的一种约束机制,保证同一时间只有一个线程可以访问共享资源,避免产生不确定的结果。
•同步:是指多个线程在某种条件下等待或者唤醒其他线程的一种机制,用于协调线程之间的执行顺序。
2. 多线程模拟的实现方式在多线程模拟中,我们需要使用编程语言提供的多线程库来实现并发执行。
常见的多线程库包括Java的java.util.concurrent、Python的threading、C++的std::thread等。
通过使用这些库,我们可以方便地创建和管理多个线程,实现并发进程的模拟。
在使用多线程库实现多线程模拟时,一般需要考虑以下几个方面:2.1 线程创建与管理通过多线程库,我们可以方便地创建和管理多个线程。
在创建线程时,需要指定线程执行的任务或函数,并可以设置线程的优先级、名称等属性。
在线程执行过程中,可以通过多线程库提供的接口来管理线程的状态,如启动线程、暂停线程、恢复线程、终止线程等。
2.2 互斥与同步在多线程模拟中,由于多个线程可能同时访问同一个共享资源,需要使用互斥与同步机制来保证资源的正确访问。
互斥机制通过使用互斥锁(Mutex)来保证同一时间只有一个线程可以访问共享资源。
操作系统进程调度模拟课程设计(java)

计算机操作系统课程设计实验报告题目名称进程调度模拟系统院系班级完成时间2013.1.8 指导老师本次实验成绩组长联系电话邮件地址组长(姓名、学号)主要任务需求分析,模块设计与代码编写,组织任务分配,PPT制作,实验报告审定,材料汇总等成员(姓名、学号)主要任务代码的编写实验报告的编写、材料查找等题目进程调度:模拟FCFS和SJF进程调度过程实验介绍原理现在的处理机任务量大,多个进程会不同时先后到达,并且各个进程的工作时间也不一定相同,为了使各个进程间不发生冲突,有条不紊的先后运行,并以最短的时间占用处理机,面对这种发展状况,有必要使用进程调度算法来提高处理机的工作效率。
去选择合适的一种进程调度算法达到理想的效果,可以做到信息的规范管理、科学统计和快速运作,从而减少时间上的浪费。
用Java语句设计实现登陆界面,直观显示各种算法和调度结果,直观地显示运行结果,设计进程调度算法实现用不同算法(先来先服务,短作业优先,高响应比优先调度算法,时间片轮转算法)进行进程调度,算出最短周转时间,实现高效率调度算法。
参考资料[1] 黄祥喜,计算机操作系统实验教程。
广州:中山大学出版社,1994.[2] 汤子瀛,《计算机操作系统(修订版)》西安电子科技大学出版社[3] Andrew S.Tanenbaum,现代操作系统,机械工业出版社。
[4] (美)Bruce Eckel. Java编程思想. 陈昊鹏译. 北京:机械工业出版社,2007[5] 王路群.Java高级程序设计.北京:中国水利水电出版社,2006[6] 孙卫琴. 精通Struts:基于MVC的Java Web设计与开发.北京:电子工业出版社,2004.08实验环境(软件和硬件):(1)硬件要求EGA或VGA卡彩显或单显(640×350以上),单机内存2M以上,硬盘40M 以上。
客户端计算机采用586以上机型,客户端应用程序可以稳定的运行在Windows07 xp操作系统之上。
进程模拟课程设计报告

操作系统课程设计报告书课程设计题目:模拟操作系统进程管理专业:计算机科学与技术班级:计算机 * * 班小组成员:成员及分工:1、2、3、4、一、课程设计目的课程设计的目的是模拟操作系统进程管理。
二、课程设计要求课程设计要求使用一种编程语言能够模拟进程创建,进程执行,进程阻塞,进程消亡和进程唤醒。
三、系统环境支持及语言选择Window操作系统,C语言编写。
四、系统框架构成五、系统功能说明本次模拟进程调度使用的是FIFO算法。
main()主函数int init() 进程初始化void drawmat( ) 汉字输入定义int enqueue(PCB *head , PCB *node) 进程入队PCB * dequeue(PCB *head) 进程出队int create() 创建进程int fexcute() 将进程调入运行队列int run() 运行进程int wake() 唤醒进程int block() 阻塞进程int outputqueue(PCB *head) 输出进程状态int help() 帮助菜单int leave() 退出程序六、用户使用说明当用户进入欢迎界面后,输入任意键,系统自动初始化,然后输入您要创建的多个进程,当输入完成后,可以按0 0表示输入结束。
程序会默认创建进程为就绪队列,接着会弹出帮助菜单,用户只要按帮助菜单的字母按钮执行相应的进程调度、进程阻塞、进程运行等操作,以实现操作系统进程管理的模拟。
七、运行界面如下八、源代码#include "stdio.h"#include"graphics.h"#include "dos.h"#include "stdlib.h"#include "conio.h"#define SEC 3#define NULL 0char han1S[]={0x00,0x80,0x00,0x80,0xFC,0x80,0x04,0xFC,0x45,0x04,0x46,0x48,0x28,0x40,0x28, 0x40,0x10,0x40,0x28,0x40,0x24,0xA0,0x44,0xA0,0x81,0x10,0x01,0x08,0x02,0x0E ,0x0C,0x04,};char han2S[]={0x00,0x00,0x41,0x84,0x26,0x7E,0x14,0x44,0x04,0x44,0x04,0x44,0xF4,0x44,0x14, 0xC4,0x15,0x44,0x16,0x54,0x14,0x48,0x10,0x40,0x10,0x40,0x28,0x46,0x47,0xFC, 0x00,0x00,};char han3S[]={0x02,0x20,0x42,0x20,0x22,0x28,0x2F,0xFC,0x02,0x20,0x02,0x20,0xE2,0x20,0x22, 0x28,0x2F,0xFC,0x22,0x20,0x22,0x20,0x22,0x20,0x24,0x20,0x50,0x26,0x8F,0xFC, 0x00,0x00,};char han4S[]={0x04,0x00,0x02,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x02,0x80,0x02,0x80,0x02, 0x80,0x04,0x40,0x04,0x40,0x08,0x20,0x08,0x20,0x10,0x10,0x20,0x10,0x40,0x0E, 0x80,0x04,};char han5S[]={0x10,0x10,0x11,0xF8,0x11,0x10,0x11,0xF0,0xFC,0x04,0x17,0xBE,0x14,0xA4,0x1F, 0xBC,0x30,0x40,0xD0,0x44,0x1F,0xFE,0x10,0xE0,0x11,0x50,0x12,0x4E,0x54,0x44, 0x20,0x40,};char han6S[]={0x09,0x00,0x09,0x00,0x09,0x04,0x11,0xFE,0x12,0x80,0x32,0x80,0x54,0x90,0x98, 0xF8,0x10,0x80,0x10,0x80,0x10,0x88,0x10,0xFC,0x10,0x80,0x10,0x80,0x10,0x80, 0x10,0x80,};char han7S[]={0x00,0x38,0x7F,0xC0,0x04,0x00,0x04,0x10,0x08,0x20,0x3F,0xC0,0x01,0x00,0x02, 0x20,0x04,0x10,0x3F,0xF8,0x01,0x08,0x09,0x20,0x09,0x10,0x11,0x08,0x25,0x08, 0x02,0x00,};char han8S[]={0x10,0x80,0x10,0x40,0x20,0x48,0x27,0xFC,0x48,0x80,0xF9,0x10,0x12,0x08,0x27, 0xFC,0x41,0x24,0xF9,0x20,0x41,0x20,0x01,0x20,0x1A,0x22,0xE2,0x22,0x44,0x1E, 0x08,0x00,};char han9S[]={0x11,0x10,0x11,0x14,0x1F,0xFE,0x11,0x10,0xFD,0x18,0x13,0xFC,0x32,0x08,0x3B, 0xF8,0x56,0x08,0x53,0xF8,0x90,0x40,0x1F,0xFE,0x10,0x40,0x10,0xB0,0x11,0x0E, 0x16,0x04,};char han10S[]={0x10,0x00,0x10,0x08,0x10,0x88,0x12,0x48,0xFE,0x68,0x12,0x28,0x16,0x08,0x1A, 0x08,0x32,0x08,0xD2,0x08,0x12,0x48,0x12,0x88,0x13,0x14,0x12,0x22,0x50,0x42, 0x20,0x80,};char han11S[]={0x02,0x20,0x42,0x20,0x22,0x28,0x2F,0xFC,0x02,0x20,0x02,0x20,0xE2,0x20,0x22, 0x28,0x2F,0xFC,0x22,0x20,0x22,0x20,0x22,0x20,0x24,0x20,0x50,0x26,0x8F,0xFC, 0x00,0x00,};char han12S[]={0x08,0x04,0x1D,0xFE,0xF1,0x04,0x11,0x04,0x11,0x04,0xFF,0x04,0x11,0xFC,0x38, 0x00,0x37,0xFE,0x54,0x20,0x50,0x28,0x91,0xFC,0x10,0x20,0x10,0x24,0x17,0xFE, 0x10,0x00,};char han13S[]={0x10,0x40,0x1F,0x7C,0x28,0x90,0x45,0x08,0x01,0x00,0x7F,0xFE,0x40,0x02,0x9F, 0xF4,0x10,0x10,0x1F,0xF0,0x10,0x00,0x1F,0xF0,0x10,0x10,0x10,0x10,0x1F,0xF0, 0x10,0x00,};char han14S[]={0x00,0x08,0x13,0xFC,0xFA,0x48,0x22,0x48,0x23,0xF8,0x22,0x48,0xFA,0x48,0x23, 0xF8,0x20,0x40,0x20,0x50,0x23,0xF8,0x3C,0x40,0xE0,0x40,0x40,0x44,0x0F,0xFE, 0x00,0x00,};void drawmat(char *mat,int matsize,int x,int y,int color){int i,j,k,n;n=(matsize-1)/8+1;for(j=0;j<matsize;j++)for(i=0;i<n;i++)for(k=0;k<8;k++)if(mat[j*n+i]&(0x80>>k))putpixel(x+i*8+k,y+j,color);}/*定义结构体*/typedef struct PCB{int PID;int UID;struct PCB * next;}PCB;PCB *really , *excute , *wait;/*create queue header *//*queue operation 入队*/int enqueue(PCB *head , PCB *node) {PCB *p;p = head;if(p -> next == NULL){head -> next = node;return 1;}while(p){if(p -> next == NULL){p -> next = node;return 1;}else p = p -> next;}}/*enquue*//*dequeue 出队列 */PCB * dequeue(PCB *head){PCB *p;p = head;if(p -> next == NULL){return NULL;}else{p = p -> next;head -> next = p -> next;p -> next = NULL;return p;}/*head to next*/}/*dequeue*//*PCB operate*//*新建进程*/int create(){PCB *p;p = (PCB*)malloc(sizeof(PCB));p -> next = NULL;printf("input PID and UID to a new process\n");scanf("%d %d",&p -> PID,&p -> UID);if(enqueue(really , p))printf("create a process: PID = %d UID = %d\n", p -> PID , p -> UID);elseprintf("create Failed\n");}/*create*//*执行 fexcute*/int fexcute(){PCB *p = dequeue(really);if(p == NULL){printf("NO process in queue \n");return 0;}else{enqueue(excute , p);printf("add a process into excute queue process: PID = %d UID= %d \n" ,p->PID , p->UID);return 1;}}/*excute*/int wake(){PCB *p = dequeue(wait);if(p == NULL){ printf("NO process in queue \n");return 0;}else{ enqueue(really , p);printf("add a process into wait really process: PID = %d UID= %d \n" ,p->PID , p->UID);return 1;}}int block(){PCB *p = dequeue(excute);if(p == NULL){printf("NO process in queue \n");return 0;}else{enqueue(wait , p);printf("add a process into wait queue process: PID = %d UID= %d \n" ,p->PID , p->UID);return 1;}}/*输出队列 outputqueue*/int outputqueue(PCB *head){PCB *p;if(head -> next == NULL){/*队列为空*/printf("queue is null \n");return 1;}p = head -> next;while(p){printf("PID = %d UID = %d \n" , p -> PID , p -> UID);p = p -> next;}return 0;}/*output输出*/int output(){ printf("REALLLY QUEUE:\n");outputqueue(really);printf("EXCUTE QUEUE: \n");outputqueue(excute);printf("WAIT QUEUE: \n");outputqueue(wait);}/*init 初始化*/int init(){ int i;PCB *p;clrscr();really = (PCB*)malloc(sizeof(PCB));really -> next=NULL;excute = (PCB*)malloc(sizeof(PCB));excute -> next=NULL;wait = (PCB*)malloc(sizeof(PCB));wait -> next = NULL;printf("_________________________PROCESSSECHUDLE___________________________ \n");printf("now is initing");for(i=0;i<18;i++){printf(". ");delay(10000000000);}printf("\ninput PID and UID as integer , 0 0 as over\n");while(1){p = (PCB*)malloc(sizeof(PCB));p -> next = NULL;scanf("%d %d",&p -> PID , &p -> UID);if(p -> PID == 0 && p -> UID == 0)break;else{if(enqueue(really , p)){printf("new process PID = %d UID = %d added!\n",p -> PID , p -> UID); }else return 0;}}return 1;}/*init*//*运行一个process*/int run(){ PCB *p = excute;int s = SEC;if(excute -> next == NULL){printf("no process in excute queue \n");return 0;}else{p = excute -> next;printf("system will sleep %ds as process running\n",s);sleep(3);printf("process: PID = %d UID= %d excute successed..\n" , p -> PID , p -> UID ); excute -> next = p -> next;free(p);}}/*run*//*离开*/int leave(){ int COMMAND;printf("Are you sure to leave? YES-(1), NO-(2)\n");scanf("%d",&COMMAND);if(COMMAND==1){clrscr();exit(0);}if(COMMAND==2){printf("\n");help();}}int help(){ printf("__________________________HELP MENU____________________________\n");printf("\t-h HELP show help option\n");printf("\t-c CREATE create a new process , and put to really queue\n"); printf("\t-b BLOCK block a process in excute queue\n");printf("\t-w WAKE wake a process in wait queue\n");printf("\t-e EXCUTE excute a process in really queue\n");printf("\t-s SUSPEND suspend a process in excute queue\n");printf("\t-o OUTPUT output all processes in queues\n");printf("\t-r RUN excute a process in excute queue\n");printf("\t-x EXIT exit this program\n");printf("_______________________________________________________________\n") ;printf("\t type 'H' will show this menu\n");}int main(){char COMMAND = NULL;int i;int gdriver=DETECT,gmode;initgraph(&gdriver,&gmode,"");setbkcolor(LIGHTBLUE);setcolor(21);for(i=40;i<=600;i+=12){rectangle(i,40,i+10,49);rectangle(i,451,i+10,460);}for(i=40;i<=450;i+=12){rectangle(40,i,49,i+10);rectangle(601,i,610,i+10);}setcolor(19);rectangle(150,100,480,410);rectangle(145,95,475,405);drawmat(han1S,16,200,230,BLUE); drawmat(han2S,16,230,230,BLUE); drawmat(han3S,16,260,230,BLUE); drawmat(han4S,16,290,230,BLUE); drawmat(han5S,16,320,230,BLUE); drawmat(han6S,16,350,230,BLUE); drawmat(han7S,16,380,230,BLUE); drawmat(han8S,16,410,230,BLUE); drawmat(han9S,16,220,300,BLUE); drawmat(han10S,16,250,300,BLUE); drawmat(han11S,16,280,300,BLUE); drawmat(han12S,16,310,300,BLUE); drawmat(han13S,16,340,300,BLUE); drawmat(han14S,16,370,300,BLUE); getch();closegraph();if( init() != 1){printf("init falied ! \n ");getch();exit(0);}else{printf("init...OK\n");output();help();}while(1){/*当三队列都不空执行调度 */ printf(">");scanf("%c",&COMMAND);switch(COMMAND){ case '\n': break;case 'H':case 'h': help(); break;case 'C':case 'c': create(); break; case 'B':case 'b': block(); break; case 'W':case 'w': wake(); break;case 'E':case 'e': fexcute(); break; case 'O':case 'o': output(); break; case 'X':case 'x': leave(); break; case 'R':case 'r': run(); break;}}}。
进程调度模拟程序课程设计

《操作系统》课程设计报告专业:计算机科学与技术班级:09计本班学号姓名成绩200981010118刘利刚题目名称:进程调度模拟程序完成日期:2012年6月20日甘肃政法学院计算机科学学院目录第一章课程设计目的 (3)第二章课程设计要求 (3)第三章设计思想 (5)3.1 基本概念 (5)3.2 进程控制块 (6)3.3 算法思想 (7)第四章详细设计 (8)4.1 程序设计流程图 (8)4.2 程序各模块功能介绍 (9)第五章运行结果及分析 (18)5.1 程序调试 (18)5.2 运行结果 (19)5.3 结果分析 (21)第六章总结 (22)参考文献 (22)进程调度模拟程序第一章课程设计目的深入掌握进程调度的概念原理和实现方法,理解操作系统进程管理中进行进程调度的过程和编程方法,掌握先来先服务调度算法和最高优先数优先的调度算法,创建进程控制块PCB。
理解进程的状态及变化,动态显示每个进程的当前状态及进程的调度情况。
进程调度是处理机管理的核心内容。
本次课程设计用C 语言编写模拟进程调度程序,以便加深理解有关进程控制快、进程队列等概念,并体会最高优先数优先与按时间片轮转调度结合算法的优缺点。
第二章课程设计要求编写一个进程调度程序,允许多个进程并行执行。
1、进程调度算法:采用最高优先数优先与按时间片轮转调度结合算法。
2、每个进程有一个进程控制块(PCB)表示。
进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
3、进程的优先数及需要的运行时间可在运行时输入,进程的到达时间为输入进程的时间。
4、进程的运行时间以时间片为单位进行计算。
5、每个进程的状态可以是就绪W(Wait)、运行R(Run)、或完成F(Finish)三种状态之一。
6、就绪进程获得CPU后都只能运行一个时间片。
7、如果运行一个时间片后,进程的已占用CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待CPU。
实验二-多进程并发环境及调度算法的仿真设计

课外实验二多道进程并发环境及调度算法的仿真设计一、实验目的通过程序仿真掌握处理机执行进程、进程切换及调度算法的原理、过程与步骤;二、实验内容1、仿真设计CPU、寄存器、时钟中断等硬件部件(1)C PU抽象设计CPU可抽象为一个类或结构体。
关键寄存器可抽象为类的属性或结构体成员,至少包括:程序计数器(PC)、指令寄存器(IR)、状态寄存器(PSW)等,寄存器内容的表示方式自行设计。
CPU模式切换的现场保护、现场恢复操作可封装为方法。
(2)时钟中断抽象设计可抽象为一个整数或一个类或结构体,也可用计时器、线程等方法仿真。
读取当前机内时间、将时间转换为秒为单位的整数等操作可以封装为方法。
本实验:假设计算机1s发生一次时钟中断。
进程调度时间片长短是1s的整数倍。
本实验仿真时钟中断是为了仿真并发进程请求,模拟并发环境。
2、仿真设计进程PCB、PCB表的数据结构(1)进程控制块PCB设计参照Linux task_struct的数据结构内容设计;至少包含:进程编号(ProID),进程优先数(Priority)、进程创建时间(InTimes)、进程状态(ProState)、进程运行时间(RunTimes)、进程包含的指令数目(InstrucNum)、编号指令(Instruc_ID)、每条指令的状态标志(Instruc_State,0表示核心态、1表示用户态)、单指令运行时间(Instruc_Times)、进程当前状态(PSW)等信息。
例如:说明:★请求运行的并发进程个数可以随机产生,也可以事先设定★进程创建时间(InTimes):根据当前机内时间,在10分钟内随机生成时间递增序列。
★进程运行时间(RunTime):统计进程当前已运行了时间★进程包含的指令数目(InstrucNum)用100以内的随机数产生;★编号指令(Instruc_ID):进程编号与指令序号的合并,例如ProID=1的进程的第1条指令编号为Instruc_ID=0101★每条指令的类型标志(Instruc_State,0表示系统调用、1表示用户态操作、2表示I/O数据通信):用随机数产生0、1、2。
操作系统课程设计报告进程调度算法模拟大学论文

1.课程设计的目的《操作系统原理》课程设计我们专业实践性环节之一,是学习完《操作系统原理》课程后进行的一次较全面的综合练习。
其目的在于加深对操作系统的理论、方法和基础知识的理解,掌握操作系统结构、实现机理和各种典型算法,系统地了解操作系统的设计和实现思路,培养学生的系统设计能力,并了解操作系统的发展动向和趋势。
2.课程设计的内容及要求先来先服务、短作业优先、时间片轮转、基于静态优先级的调度,基于高响应比优先的动态优先级调度算法实现,能够输出调度情况,并计算周转时间和平均周转时间。
要求使用链表,进程个数由用户提供,按照进程的实际个数生成PCB,程序能够让用户选择使用哪种调度算法,能够在Linux环境运行并验证结果。
程序要考虑用户界面的友好性和使用方便性。
进程基本信息可从文件读入,也可手动输入。
3、设计原理3.1先来先服务调度算法每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业,将它们调入内存,为它们分配资源创建进程,然后放入就绪队列3.2短作业优先调度算法短作业优先调度算法是从就绪队列中选出一个估计运行时间最短的进程,将处理机分配给它,使它立即执行并一直执行到完成,或发生某事件而被阻塞放弃处理机时再重新调度。
3.3时间片轮转调度算法系统将所有的就绪进程按先来先服务的原则排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片。
时间片的大小从几ms到几百ms。
当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片。
3.4静态优先级调度算法把处理机分配给优先级最高的进程,使之执行。
但在其执行期间,只要出现了另一个比其优先级更高的进程,调度程序就将处理机分配给新到的优先级最高的进程。
这样就可以保证紧迫性作业优先运行。
3.5最高响应比优先的动态优先级调度算法优先权调度算法是为了照顾紧迫型作业,使之在进入系统后便获得优先处理,引入最高优先权优先调度算法。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
课程设计说明书题目: 并发进程的模拟院系:计算机科学与工程专业班级:学号:学生姓名:指导教师:2014年 11月 12 日安徽理工大学课程设计(论文)任务书2014年11月21日安徽理工大学课程设计(论文)成绩评定表目录1问题描述 (1)2需求分析 (1)3概要设计 (2)1. P操作 (2)2. V操作 (3)3. P,V操作实现进程同步 (4)4. 功能模块设计 (5)4详细设计 (7)1.主界面的设计程序 (7)2.进程Pa的执行 (8)3.进程Pb的执行 (9)4.进程Pc的执行 (9)5.按钮的执行 (10)5 调试的分析与运行结果 (11)6 设计体会 (13)参考文献 (14)1问题描述在进程并发执行的过程中,进程之间存在协作的关系,例如,有互斥、同步的关系。
该课程设计的是了解进程同步的概念,理解信号量机制的原理,掌握运用信号量解决进程并发控制问题的方法,进而学会运用进程的同步,利用信号灯的P,V操作实现三个进程的同步。
这三个进程的同步关系如下:从上图中可以看出:任务启动后pa先执行,当它结束后,pb、pc可以开始执行,pb、pc 都执行完毕后,任务终止;设两个同步信号灯sb、sc分别表示进程pb和pc能否开始执行,其初值均为0。
在现代操作系统中,有大量的并发进程在活动,它们都处在不断的申请资源,使用资源以及其它进程的相互制约的活动中,这些进程什么时候停止运行,什么时候该继续向前推进,应根据事先的约定来规范它们的行为,这时我们可以根据同步信号灯来实现进程的同步协调工作。
例如本题中,只有pa进程顺利的进行完,Pb,Pc这两个进程才能正常的进行。
如果进程Pa在进行中出现停止或中断,则Pb和Pc是不会顺利的完成的;而进程Pb,Pc这两个进程是并行执行的,两个进程的进行是互不干扰的,只要进程Pa完成后,进程Pb和Pc才会正常执行,否则只有处在等待就绪中。
2需求分析进程执行的并发性的意义是关于一组进程的执行在是时间上是重叠的,从宏观上看,并发性反应的是一个时间段中几个进程都在同一个处理器上,处于运行还未运行结束状态。
从微观上看,任何一个时刻仅有一个进程在处理器上运行。
并发的实质是一个处理器在几个进程之间的多路复用,并发是对有限的物理资源强制行驶多用户共享,消除计算机部件之间的乎等现象,以提高系统资源利用率。
并发进程分为无关的和交往的,无关的并发进程是一组并发进程分别在不同的变量集合上操作,一个进程的执行与其他并发进程的进展无关。
引入进程是为了更好的解决实际中存在的竞态问题,进程同步的主要任务是对多个相关的进程在执行次序上进行协调,以便并发执行的诸进程之间能有效的共享资源和相互合作,从而使执行更具有可再现性。
利用进程同步可以更好地解决生活中有先后执行顺序的问题,进程的交往包括金正与写作,多个进程之间彼此相关或者是无关,二资源金正的两个控制问题一个是死锁(Deadlock)问题,一个是饥饿(Starvation)问题,系统中既要解决饥饿问题,又要解决死锁问题。
解决进程间的竞争关系(简介制约关系)的手段是进程互斥,进程互斥指的的就是资源的共享问题,以往内在同一时刻最多允许一个进程使用,其他进程必须等待,我们这个任务所需要的就是先执行其中的一个任务,在结束之后进行另外的进程。
所以我们解决这个问题的同时学习并发进程。
3概要设计1.P操作对信号灯的P操作记为P(s)。
P(s)是一个不可分割的原语操作,即取信号灯值减一,若相减结果为负,则调用P(s)的进程被阻,并插入到信号灯的等待队列中,否则可以继续执行。
P操作的主要动作:a)s值减一;b)若相减结果大于或等于0,则进程继续执行;c)若相减结果小于0,则进程被封锁,并将它插入到该信号灯的等待队列中,然后转进进程调度程序。
P操作的流程图:2.V操作对信号灯的V操作记为V(s)。
V(s)一个不可分割的原语操作,即取信号灯值加1,若相加结果大于0,进程继续执行,否则,唤醒在信号灯等待队列上的一个进程。
V操作的主要动作a)s值加一;b)若相减结果大于0,则进程继续执行;c)若相减结果小于或等于0,则从该信号灯的等待队列中移出一个进程,解除它的等待状态,然后返回本进程继续执行。
V操作的流程图:3.P,V操作实现进程同步(1)编程用信号灯的p、v操作实现这三个进程的同步。
(2)任务启动后pa先执行,当它结束后,pb、pc可以开始执行,pb、pc 都执行完毕后,任务终止。
(3)设两个同步信号灯sb、sc分别表示进程pb和pc能否开始执行,其初值均为0。
其题目的算法描述如下:4.功能模块设计本实验用JAVA语言实现(1)在Frame工程中新建一个ThreadProcess类,定义一些静态变量;主函数main()中定义一个ThreadFrame类,并构造一个对象thFrame,通过调用函数将界面,窗口展示出来;创建三个线程threadPa, threadPb, threadPc。
(2)ThreadFrame类继承JFrame类,设置每个界面的长宽,调用类方法ThreadFrame()显示一些信息。
(3)threadPanel类继承JPanel类,调用paintComponent()方法设置进程长宽以及字体等,还有threadPanel()类方法设置进程前景与背景颜色,从而展示出进程动态变化,重要一点是开始Start和暂停Stop按钮设置,控制进程开始与暂停效果。
(4)在类外分别添加三个进程类threadPa, threadPb, threadPc,都继承线程Thread类,其中各自有的控制函数run()。
程序执行能够达到实验的要求效果,程序运行后,点击Start按钮进程执行,首先进程Pa先执行,Pa结束后进程Pb和进程Pc启动开始执行,而且能够达到系统资源共享的效果,最后所有结束后告知程序结束。
如果一开始点击Stop按钮,那么进程没响应,等待点击Start按钮,这是并发进程的模拟过程并发进程的模拟中定义四个模块,实现界面进程运行过程。
程序执行能够达到实验的要求效果,程序运行后,点击Start按钮进程执行,首先进程Pa先执行,Pa结束后进程Pb和进程Pc启动开始执行,而且能够达到系统资源共享的效果,最后所有结束后告知程序结束。
并发进程的模拟功能模块流程图如图5所示。
4详细设计1.主界面的设计程序class ThreadFrame extends JFrame {public int WIDTH = 820;public int HEIGHT = 500;public threadPanel threadPanel = new threadPanel();public Container container;public ThreadFrame() {this.setTitle("模拟进程并发的过程图");this.setSize(WIDTH, HEIGHT);this.setLocation(250, 150);this.setResizable(false);container = getContentPane();container.add(threadPanel);setVisible(true);}}2.进程Pa的执行class threadPa extends Thread {public static boolean flag = true;// JProgressBar progressBar;private static int i = 0;/** public threadPa(JProgressBar progressBar) { ThreadProcess.progressBar1 = * progressBar; }*/@Overridepublic void run() {ThreadProcess.sb--;ThreadProcess.sc--;while (i <= 100) {i += 1;ThreadProcess.progressBar1.setValue(i);//System.out.println(i);try {Thread.sleep(30);// threadPa.interrupted();} catch (InterruptedException e) {e.printStackTrace();}}ThreadProcess.sb++;ThreadProcess.sc++;if (ThreadProcess.sb >= 0 && ThreadProcess.sc >= 0 ) {ThreadProcess.threadPb.start();ThreadProcess.threadPc.start();}//System.out.println(ThreadProcess.progressBar1.getValue());//System.out.println(ThreadProcess.sb);}}3.进程Pb的执行class threadPb extends Thread {public static boolean flag = true;// JProgressBar progressBar;private static int i = 0;/** public threadPb(JProgressBar progressBar) { this.progressBar =* progressBar; }*/@Overridepublic void run() {while (i <= 100) {i += 1;ThreadProcess.progressBar2.setValue(i);try {Thread.currentThread().sleep(30);} catch (InterruptedException e) {e.printStackTrace();}}}}4.进程Pc的执行class threadPc extends Thread {public static boolean flag = true;// JProgressBar progressBar;private static int i = 0;/** public threadPc(JProgressBar progressBar) { this.progressBar =* progressBar; }*/@Overridepublic void run() {while (i <= 100) {i += 1;ThreadProcess.progressBar3.setValue(i);try {Thread.currentThread().sleep(30);} catch (InterruptedException e) {e.printStackTrace();}}}5.按钮的执行public threadPanel() {setLayout(null);// 设置边框按钮的起始左上点的坐标setSize(800, 400);ThreadProcess.progressBar1 = new JProgressBar();ThreadProcess.progressBar2 = new JProgressBar();ThreadProcess.progressBar3 = new JProgressBar();// 设置start与stop按钮buttonstart1 = new JButton("Start");buttonstop1 = new JButton("Stop");ThreadProcess.progressBar1.setBackground(new Color(255, 50, 255));ThreadProcess.progressBar1.setForeground(new Color(10, 90, 90));ThreadProcess.progressBar1.setBounds(100, 70, 480, 40);buttonstart1.setBounds(600, 10, 80, 40);buttonstop1.setBounds(700, 10, 80, 40);add(ThreadProcess.progressBar1);add(buttonstart1);add(buttonstop1);buttonstart1.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent arg0) {// ThreadProcess.pa();ThreadProcess.threadPa.start();/*try {ThreadProcess.threadPa.join();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}*///System.out.println(ThreadProcess.sb+"kl");/*boolean t1=ThreadProcess.threadPa.isAlive();int t2=ThreadProcess.sb;int t3=ThreadProcess.sc;int t4=ThreadProcess.progressBar1.getValue();*//*System.out.println(t1);System.out.println(t2);System.out.println(t3);*///System.out.println(ThreadProcess.temp);//if(!ThreadProcess.threadPa.isAlive()) ;//}// threadPa.flag = true;}});buttonstop1.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent arg0) {threadPa.flag = false;}});ThreadProcess.progressBar2.setBackground(new Color(255, 90, 100));ThreadProcess.progressBar2.setForeground(new Color(90, 50, 90));ThreadProcess.progressBar2.setBounds(100, 190, 480, 40);add(ThreadProcess.progressBar2);ThreadProcess.progressBar3.setBackground(new Color(100, 100, 255));ThreadProcess.progressBar3.setForeground(new Color(100, 90, 90));ThreadProcess.progressBar3.setBounds(100, 300, 480, 40);add(ThreadProcess.progressBar3);}}5 调试的分析与运行结果1.初次运行程序界面运行并发进程模拟程序出现初次界面,如图6所示。