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

操作系统课程设计报告专业计算机科学与技术学生姓名班级学号指导教师完成日期博雅学院ﻬ题目:进程调度的模拟实现的模拟实现一、设计目的本课程设计是学习完“操作系统原理”课程后进行的一次全面的综合训练,通过课程设计,更好地掌握操作系统的原理及实现方法,加深对操作系统基础理论和重要算法的理解,加强学生的动手能力。
在多道程序和多任务系统中,系统内同时处于就绪状态的进程可能有若干个。
也就是说能运行的进程数大于处理机个数。
为了使系统中的进程能有条不紊地工作,必须选用某种调度策略,选择一进程占用处理机。
要求学生设计一个模拟处理机调度算法,以巩固和加深处理机调度的概念.二、设计内容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最高响应比优先的动态优先级调度算法优先权调度算法是为了照顾紧迫型作业,使之在进入系统后便获得优先处理,引入最高优先权优先调度算法。
操作系统课程设计进程调度模拟设计

课程设计课程名字系统软件开发实训A题目进程调度模拟设计一一先来先服务、优先级法学院计算机科学与技术学院专业计算机科学与技术专业班级姓名指导教师李玉强2014 年01月13 日天天天天天天课程设计任务书学生姓名: _________ 专业班级: ______________ 指导教师:李玉强工作单位: 计算机科学与技术学院题目:进程调度模拟设计一一先来先服务、优先级法初始条件:1 •预备内容:阅读操作系统的处理机管理章节内容,对进程调度的功能以及进程调度算法有 深入的理解。
2 •实践准备:掌握一种计算机高级语言的使用。
要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求)1 •模拟进程调度,能够处理以下的情形:⑴ 能够选择不同的调度算法(要求中给出的调度算法);⑵ 能够输入进程的基本信息, 如进程名、优先级、到达时间和运行时间等; ⑶根据选择的调度算法显示进程调度队列;⑷ 根据选择的调度算法计算平均周转时间和平均带权周转时间。
2 •设计报告内容应说明: ⑴课程设计目的与功能;⑵需求分析,数据结构或模块说明 (功能与框图); ⑶ 源程序的主要部分;⑷ 测试用例,运行结果与运行情况分析; ⑸自我评价与总结。
时间安排:设计安排3周:查阅、分析资料 1 系统软件的分析与建模 4系统软件的设计 5 系统软件的实现 3 撰写文档 1课程设计验收答辩1 设计验收安排:设计周的第三周的指定时间到实验室进行上机验收 设计报告书收取时间:课程设计验收答辩完结时。
(注意事项:严禁抄袭,一旦发现,抄与被抄的一律按0分记)指导教师签名:2013 年12月10日系主任(或责任教师)签名:2013 年12月10日课程设计报告书1•需求分析1.1设计目的(1) 阅读操作系统的处理机管理章节内容,对进程调度的功能以及进程调度算法有深入的理解。
(2) 掌握一种计算机高级语言的使用。
要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求) 1.2程序流程图1.3设计要求(1) 能够选择不同的调度算法(要求中给出的调度算法);(2) 能够输入进程的基本信息,如进程名、优先级、到达时间和运行时间等;(3) 根据选择的调度算法显示进程调度队列;(4) 根据选择的调度算法计算平均周转时间和平均带权周转时间。
《 操作系统C 》操作系统进程调度模拟

(5)进程的阻塞时间STARTBLOCK,表示当进程再运行STARTBLOCK个时间片后,进程将进入阻塞状态。
(6)进程被阻塞的时间BLOCKTIME,表示已阻塞的进程再等待BLOCKTIME个时间片后,将转换成就绪状态。
1)、进程添加,如图:
2)、正常运行情况下,如图:
图(1)
3)、发生中断情况下,如图:
4.实验结果分析
在时间按片轮转算法(RR)中,时间片的大小对系统性能有着很大的影响,如果选择很小的时间片将有利于短作业,因为它能较快地完成任务,但会频繁的发生中断、进程上下文的切换,从而增加系统的开销;反之,如果选择太长的时间片,使每个进程都能在一个时间片内完成,时间按片轮转算法(RR)就退化成先来先服务(FCFS)算法了,从而无法满足交互式用户的需求。一个较为可取的大小是,时间片大小略大于一次典型的交互式需要所需求的时间。这样可以使大多数进程在一个时间片内完成。
booleanSusp=false; /*增加进程标志*/
publicRR(){
/*线程*/
myThread=newThread(this);
myThread.start();
/*程序窗口初始化*/
JFrame f=newJFrame();
f.setTitle("时间片轮转调度算法(RR)");
f.setSize(650,450);
if(e.getSource() == jbBegin){
if(Continue==false)
Continue=true;
}
if(e.getSource() == jbAdd){
操作系统课程设计报告模拟进程调度程序(一)

操作系统课程设计报告模拟进程调度程序(一) 此设计报告是对操作系统中进程调度的两种算法,即静态优先权调度算法和需要时间片的转法进行了描述,并分析了它们的工作机理。
最高优先权调度算法的基本思想是把CPU分配给就绪队列中优先权最高的进程。
静态优先数是在创建进程时确定的,并在整个进程运行期间不再改变。
简单轮转法的基本思想是:所有就绪进程按FCFS排成一个队列,总是把处理机分配给队首的进程,各进程占用CPU的时间片相同。
如果运行进程用完它的时间片后还未完成,就把它送回到就绪队列的末尾,把处理机重新分配给队首的进程,直至所有的进程运行完毕。
然后用具体语言模拟了一个进程调度的程序。
用户可以自己输入产生进程,然后选择调度方式进行调度。
所用的语言为,结果显示了调度运行过程。
问题描述和分析………………………………………………4算法设计............................................................5源代码及说明.........................................................5结果与分析...............................................................17参考文献 (18)一、问题描述和分析问题描述CPU调度是多道程序操作系统的基础,几乎所有计算机资源在使用前都要被调度,因此,CPU调度对于操作系统来说非常重要。
假如操作系统中存在若干进程,这些进程,将会被按照指定的调度方式,由CPU进行调度。
本程序,用来模拟实现操作系统中的两种调度方法,即:优先权调度和轮转法调度。
下面对四种调度方法进行描述优先权调度(priority-schedulingalgorithm):在这种方式下,每一个进程都有一个优先权与其关联,具有最高优先权的进程会被分配到CPU,具有相同优先权的进程按FCFS顺序调度。
综合设计多进程并发与调度仿真环境

综合设计多进程并发与调度仿真环境一、课程设计目的进行操作系统课程设计主要是在学习操作系统课程的基础上,在完成操作系统各部分实验的基础上,对操作系统的整体进行一个模拟,通过实践加深对各个部分的管理功能的认识,还能进一步分析各个部分之间的联系,最后达到对完整系统的理解。
同时,可以提高运用操作系统知识解决实际问题的能力;锻炼实际的编程能力、创新能力及团队组织、协作开发软件的能力;还能提高调查研究、查阅技术文献、资料以及编写软件设计文档的能力。
二、课程设计内容综合设计多进程并发与调度仿真环境,分析比较各种调度算法的性能。
三、系统分析与设计1、系统分析:在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。
当就绪状态进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。
本实验就这一问题给出了四种调度算法。
分别为先来先服务、短作业优先、高优先权调度和时间片轮转算法。
2、系统设计:(1)设计一个生成有几个互斥的待处理进程的主界面。
(2)再设计一个按钮可实现随机重新生成这几个进程的各种属性(这里用到了随机函数)(3)再分别设置四个按钮分别用四个算法对上诉诸进程进行调度。
(4)对于上诉四个算法再分别为每种算法相应对应的对话框,用来加以区别和独立。
3、模块设计:4、数据结构说明:struct Process{CString Name ;int ArriveTime;int NeedTime ;int RealTime ;int FinishTime;int Level ;CString State ;};struct Queue{CString Name ;int ArriveTime;int NeedTime ;int Level ;CString State ;};5、算法流程图:处理器调度算法流图如下:四、模块调试与系统测试1、模块调试:输入的形式和输入值的范围输出的形式程序所能达到的功能2、系统测试:测试方法:由于软件错误的复杂性,软件测试需要综合应用测试技术,软件测试步骤为单元测试、集成测试、确认测试和系统测试。
操作系统课程设计——进程调度模拟算法(5种)

福建农林大学计算机与信息学院课程设计报告课程名称:操作系统实习题目:进程调度算法模拟姓名:***系:计算机专业:计算机科学与技术年级:2011级学号:**指导教师:***职称:***2014年1月16日福建农林大学计算机与信息学院信息工程类课程设计报告结果评定目录1.进程调度算法模拟课程设计的目的 (1)2.进程调度算法模拟课程设计的要求 (1)3.进程调度算法模拟课程设计报告内容 (1)3.1前言 (1)3.2进程调度算法模拟设计的环境 (1)3.3系统流程图及各模块 (2)4.总结 (18)参考文献 (19)参考网站 (19)进程调度算法模拟1.进程调度算法模拟课程设计的目的和意义2013-2014学年,在学习了《操作系统》这门课后,对当中的进程调度算法产生了浓厚的兴趣。
各种调度算法,理论上比较好理解。
为了加深印象,我决定把各种调度算法用C语言写出来。
于是便产生这份从头到尾都让我绞尽脑汁的课程设计。
做这份课程设计,对从事系统开发的人员来说,是必要的,可以在一定程度上为自己以后的发展铺路。
虽然用处不是特别明显,但对加深系统调用算法的理解无疑用处是巨大的。
2.进程调度算法模拟课程设计的要求1.用C语言写出至少两种进程调度算法。
2.画出大概流程图。
3.对算法过程出现的bug进行调试。
4.展示最后的算法结果3.1前言:目前比较常见的几种进程调度算法有:1.先到先服务(FCFS)2.短进程优先(非抢占和抢占)算法(SPF)3.高响应比优先算法4.时间片轮转算法我选出其中三种即先到先服务,短进程优先(2种)和时间片轮转算法进行C语言描述以加深对这三种算法的理解。
3.2进程调度算法模拟设计的环境VC++6.0及CodeBlocks,32位计算机WIN7操作系统。
3.3流程图定义进程结构体:struct Pro{int num; //进程号int time_in; //进程到达时间int work_time; //进程服务时间int btime;//用于抢占式进程优先记录该进程开始时间int l_w_time;//用于抢占式进程优先记录剩余服务时间int end_time; //记录该进程结束时间,(需要时时监测)int judge; //用于需要时的标记}pro[10]; //进程结构体1先到先服务算法描述:把所有进程按到达先后排序,每次取最先到的进程执行后淘汰,再取下一个,直到所有进程调度完毕。
操作系统课程设计-进程调度的模拟实现

课程设计题目进程调度算法模拟编程学生姓名学号专业计算机科学与技术班级指导教师完成日期2012年12月18日进程调度的模拟实现摘要:进程管理是操作系统中的重要功能,用来创建进程、撤消进程、实现进程状态转换,它提供了在可运行的进程之间复用CPU的方法。
在进程管理中,进程调度是核心,因为在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态,当就绪进程个数大于处理器数目时,就必须依照某种策略决定哪些进程优先占用处理器。
本文通过两种算法模拟实现了进程之间的调度。
关键词:进程创建,先来先服务,优先级调度。
一.前言在操作系统中,调度的实质是一种资源分配,调度算法即指:根据系统的资源分配策略所规定的资源分配算法。
对于不同的系统和系统目标,通常采用不同的调度算法,如在批处理系统中,为照顾为数众多的短作业,采用短作业有限调度算法;在分时系统中,为保证系统具有合理的响应时间,采用轮转法进行调度。
采用算法时,则要考虑多方面因素,以便达到最佳效果。
做好这个课程设计,有利于加深对操作系统进程调度知识的理解。
二. 系统总体框架设计本程序采用两种算法(最高优先级数优先的调度算法和先来先服务算法)对多个进程进行调度,每个进程有三个状态,初始状态为就绪状态。
最高优先级数优先的调度算法中,程序的某进程运行时间以时间片为单位计算。
各进程的优先数或轮转时间数以及进程需运行的时间片数的初始值均由用户给定。
在优先级数优先的调度算法中,优先级数的值设计为100与运行时间的差值,即Pro_time-process->needtime。
进程每执行一次,优先数减3,CPU时间片数加1,进程还需要的时间片数减1。
对于遇到优先数一致的情况,采用先来先服务策略解决。
程序设计组成框图程序流程图1.可强占优先调度算法实现过程流程图:开始创建进程及属性先来先服务算法优先数调度算法显示进程执行状态结束2先来先服务调度算法实现过程流图三.数据结构设计1.设计创建进程的结构类型定义和结构变量说明struct ProcessPcb,定义PCB相关变量:ProcessPcb(){next=NULL;}charpro_name[20]; //进程的名字ﻩint time_submit ; //提交时间,从时间为1开始计时inttime_exe ; //进程所需的运行时间ﻩintpro_id ;//进程ID(系统生成)ﻩint pro_priority ; //进程优先级ﻩint time_start ; //开始执行的时间ﻩint time_end ; //结束的时间ﻩint time_wait ; //等待的时间ﻩint pro_state; //进程的状态(就绪,执行,完成) int time_left ; //还需多少时间单位,初始化为所需的执行时间int time_turn;ﻩ //周转时间ﻩdouble time_aver ; //带权周转时间2.创建PCB类class CpuModel,定义程序中使用的各函数:CpuModel{CpuModel(){pcbnum=0;}voidcpurun(); //cpu模拟运行函数ﻩbool GetPcb(); //进程输入函数ﻩvoid ShowPcb(); //将输入的进程展示出来voidPriModel(); //可强占的优先进程调度模式void FcfsModel(); //先到先服务调度模式ProcessPcb PcbList[100];ﻩ//按提交时间排的未就绪进程队列()}四.测试结果及分析1.开始运行,显示:2.输入进程数,各进程属性:关于提交时间执行时间等,将检测输入是否数字,不是数字即退出程序。
进程模拟课程设计

进程模拟课程设计一、课程目标知识目标:1. 学生能理解进程模拟的基本概念,掌握进程的基本状态和转换条件。
2. 学生能够运用流程图、伪代码等方式描述进程的运行过程。
3. 学生了解操作系统中进程管理的基本原理,并能够解释进程调度、同步和互斥等相关知识。
技能目标:1. 学生能够运用所学知识,设计简单的进程模拟程序,实现进程的创建、运行和终止。
2. 学生通过实际操作,学会使用至少一种编程工具进行进程模拟,提高编程实践能力。
3. 学生能够分析并解决进程管理中可能出现的问题,如死锁、饥饿等。
情感态度价值观目标:1. 培养学生对计算机科学和操作系统的兴趣,激发他们探索未知、积极进取的精神。
2. 增强学生的团队合作意识,使他们学会在团队中沟通、协作,共同完成任务。
3. 培养学生严谨、务实的科学态度,让他们认识到进程管理在计算机系统中的重要性。
本课程针对年级学生的认知特点和学科要求,以实际操作为导向,注重理论与实践相结合。
通过本课程的学习,学生将掌握进程模拟的基本知识和技能,培养他们解决实际问题的能力,同时提升对计算机科学的兴趣和情感态度。
为实现课程目标,后续教学设计和评估将围绕具体学习成果展开,确保教学效果的达成。
二、教学内容本课程教学内容以《计算机操作系统》教材中进程管理章节为基础,涵盖以下要点:1. 进程基本概念:进程的定义、进程与程序的区别、进程的属性。
2. 进程状态及转换:运行、就绪、阻塞状态,状态转换条件。
3. 进程控制块(PCB):作用、内容、管理方式。
4. 进程调度:进程调度算法,如FCFS、SJF、优先级调度等。
5. 进程同步与互斥:同步机制、互斥概念、生产者-消费者问题、哲学家就餐问题。
6. 死锁与饥饿:死锁的定义、预防、避免、检测与解除;饥饿现象及其解决方案。
7. 进程通信:进程间通信方式,如管道、消息队列、共享内存等。
教学大纲安排如下:第一课时:进程基本概念、进程状态及转换。
第二课时:进程控制块、进程调度。
计算机操作系统实验-进程与并发执行

重庆交通大学综合性设计性实验报告班级:计科专业2010级四班*名:***实验项目名称:模拟进程并发执行实验项目性质:操作系统多任务实验所属课程:计算机操作系统实验室(中心):语音大楼8 楼801 ****:**实验完成时间:2012 年11 月 4 日一、实验目的1、通过实验来模拟进程的并发执行,来深入了解什么事操作系统的进程,以及进程有些什么特性。
2、了解进程间是如何做到并发执行的,进程间是如何做到资源共享的。
以及验证进程在运行过程中的进度是随机的,不可控制的。
3、通过实验来了解进程的三种状态以及状态间的转换条件。
4、加深对进程概念的理解;5、认识进程并发执行的实质6、分析进程争用资源的现象,学习解决进程互斥的方法。
二、实验内容及要求用直观的方式模拟进程执行时的过程,显示在屏幕上。
实现一个能够直观反应单个进程执行与多个进程并发执行时由于资源竞争而引起的进程执行速度变化的过程。
且进程的初始状态和进度都是随机的,不可控制的。
三、实验设备PC机1台、JCreator LE开发环境四、设计方案㈠设计主要思想(1)、每个进程能够随机暂停和开始。
(2)、用Java的多线程来实现。
模拟多线程并发性。
通过进度条来表示进程的运行,通过进度条的运行速度来表示程序的运行速度。
而要体现多进程并发,所以需要在实验中至少定义两个以上的进程,在实验中定义3个进程并发执行。
为了使3个进程的属性和调度方法都是顺利执行,则可以通过三个进程类来分别控制进程对象。
进程的启动时进程的速度是随机性。
要模拟这样一个效果,则可以使用一个随机数对象产生一个随机的数来定义进程运行的位置。
而某个进程的运行速度也是随机的,由进程获得资源的多少来实现。
㈡设计的主要步骤本实验用java语言实现(1)在Jcreator中新建一个ThreadProcess类,分别建立三个公共的线程类,Thread1,Thread2,Thread3.(2)在ThreadProcess类的主函数啊中新建三个线程和和窗口。
模拟进程调度功能的设计与实现操作系统课程设计(JAVA版本)

模拟进程调度功能的设计与实现操作系统课程设计(J A V A版本)本页仅作为文档页封面,使用时可以删除This document is for reference only-rar21year.March操作系统课程设计--进程调度子系统模拟实现一、设计内容及意义1.课程设计内容使用java语言或C++语言编程实现模拟操作系统进程调度子系统的基本功能;实现先来先服务、时间片轮转、多级反馈轮转法对进程进行的调度过程;掌握各个调度算法的特点。
2.该课程设计意义理解进程调度的概念深入了解进程控制块的功能、进程的创建、删除以及进程各个状态间的转换过程从实用的角度对《数据结构》课程内容进行更深入理解和更熟练的应用进一步练习对Java及C++语言的熟练使用二、设计方案1.硬件环境PC一台2.开发语言及工具操作系统:MS windows XPC++版:Visual Studio 2008 + MFCJava版:Eclipse + Java Swing3.设计思路系统设备表用于存取调度过程中进程可申请的资源进程控制块主要负责具体进程信息的保存等待队列、就绪队列、完成队列用于保存执行过程的状态信息进程调度进程(类、线程)在就绪队列与等待队列之间进行调度主界面显示调度过程的三个队列的状态信息用户创建进程放入就绪队列等待调度三、功能模块设计1.进程状态转换等待就绪执行创建进程进程结束2.PCB信息主要负责保存各进程基本信息提供外部状态设置和读取接口3.系统设备类系统设备的基本信息设备状态设置、读取接口4.调度类向就绪队列添加新创建进程从就绪队列取相应进程执行将执行阻塞进程放入等待队列检测系统设备表,分配、释放设备、唤醒等待进程执行完成程序放入完成队列(仅为保存状态,非系统部分)提供获取执行状态的外部接口,即各个队列数据的获取5.视图类提供用户操作接口(调度策略选择、进程创建)显示各队列状态信息创建进程调度类线程,调用调度类的接口四、程序总控流程图1.用户接口、调度算法、进程状态转换关系示意系统总体设计页面 12.调度算法基本工作流程示意用户选择进程调度算法创建进程根据算法从就绪队列调度某一时刻需要资源从就绪队列取出执行放入等待队列Y执行完毕资源满足YY就绪队列是否有进程等待执行N初始化进程基本信息将进程放入就绪队列页面 1进程调度框架五、 数据结构设计1. PCB (进程基本信息)类结构ProcessPCB--------Pid Pname userName Priotity subtime totalTime runTimeDcRequestLst: int : String : String : int : int : int : int: List<DeviceReq>说明1. pid 进程ID2.pName进程名erName进程用户4.priority进程优先级5.subtime进程提交时间6.totalTime进程需要执行的总时间7.runtime进程已经运行时间8.dcReqlst当前进程所需要的设备请求表2.Dispatcher(进程调度进程)类结构Dispatcher-------SystimeisContentionpreLstwaitLstfinishLstexecutingsysDcLst: int: boolean: List<Process>: List<Process>: List<Process>: Process: List<Process>说明1.sysTime系统时间2.isContention当前调度是否为抢占方式3.prelst就绪队列4.waitlst等待队列5.finishlst完成队列6.executing正在执行的进程7.sysDclst系统设备表3.Device(系统设备)类结构Device------dcIddcTypedcDiscdcTimedcPiddcleftTime: int: int: String: int: int: int说明1. dcid 设备标识2. dcType 设备类型3. dcTime 该设备一次I/O 服务需要时间4. dcPid 使用该设备的进程5. dcDisc 设备描述6. dcLefTime 设备剩余服务时间六、 程序代码结构1. 类层次关系0..10..*0..10..*0..10..*DispatcherFIFODispatcherPLevelDispatcherRRDispatcherMRDispatcherProcessPCBDeviceDeviceReq2. 详细说明Dispatcher 定义进程调度进程的基本信息和接口FIFODispatcher 、PLevelDispatcher 、RRDispatcher 、MRDispatcher 分别实现相应的调度算法 Device 为系统设备DeviceReq 为进程设备请求,包括请求设备ID 和时间七、 代码实现分析1. 算法分析(各算法过程见下流程图)设备的分配释放先来先服务优先级调度时间片轮转多级反馈轮转设备分配释放页面 1先进先出进程调度算法页面 1优先级进程调度算法(抢占式)页面 1时间片轮转调度算法页面 1多级反馈轮转调度算法(抢占式)页面 12.具体实现(代码部分有详细注释)进程的插入@Overridepublic void addPreProc(Process proc) { 3.算机操作系统教程第2版.清华大学出版社2000年4.著作:[2] 张尧学.计算机操作系统教程第2版习题与实验指导. 清华大学出版21。
操作系统实验一:并发程序设计

操作系统实验⼀:并发程序设计---恢复内容开始---⼀、实验⽬的(1)加深对进程并发执⾏的理解,认识多进程并发执⾏的实质。
(2)观察进程共享资源的现象,学习解决进程互斥和同步的⽅法。
⼆、实验要求:本实验要求⽤⾼级语⾔,启动多进程并发运⾏,设计相应代码,显⽰进程⽆关并发、进程共享变量并发的运⾏结果。
并完成实验报告。
三、实验内容:分别实现以下四种情况的并发:1.并发的进程之间⽆关,显⽰进程名称,开始与结束时间。
模拟多终端售票情况,并发的多个终端进程之间共享剩余票数这个共享变量。
2.⽤全局变量实现。
3.⽤进程间共享数据机制实现。
4.⽤进程间共享数据机制和加锁机制实现。
四、实验过程与结果1. 算法思想与设计2. 算法实现代码3. 运⾏结果public class ThreadTest3 {public static void main(String[] args) {Shop shop = new Shop();for (int i = 1; i <= 5; i++) {new Thread(shop,"").start();}}}class Shop implements Runnable{String name;ticket t;public Shop() {t.total = 100;t.count = 0;}public void run() {while (t.total>0) {synchronized (this) {try {Thread.sleep(new Random().nextInt(1000));} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"_____"+t.count);t.total--;t.count++;}}}}class ticket {int total;int count;}通过共享变量实现import osimport threadingtickis=1000lock=threading.Lock()def sale_tickis(thread_name):global tickisglobal lockwhile 1:lock.acquire()if tickis!=0:tickis-=1print(thread_name,"余票为:",tickis)else:print(thread_name,"票卖完了")os._exit(0)lock.release()class my_thread(threading.Thread):def__init__(self,name=""):threading.Thread.__init__(self)=namedef run(self):sale_tickis()if__name__=="__main__":for i in range(1,21):thread = my_thread("线程" + str(i))thread.start()。
- 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所示。