操作系统课程设计报告网络教学系统

《操作系统课程设计报告网络教学系统》由会员分享，可在线阅读，更多相关《操作系统课程设计报告网络教学系统（40页珍藏版）》请在装配图网上搜索。

1、课程设计报告课程名称 操作系统课程设计 设计题目 网络教学系统 专业班级 姓 名 学 号 指导教师 起止时间 2010年12月5日-24日 成 绩 评 定考核内容设计表现设 计报 告答辩综合评定成 绩电气与信息学院课程设计考核和成绩评定办法1 课程设计的考核由指导教师根据设计表现、设计报告、设计成果、答辩等几个方面，给出各项权重，综合评定。该设计考核教研室主任审核，主管院长审批备案。2 成绩评定采用五级分制，即优、良、中、及格、不及格。3 参加本次设计时间不足三分之二或旷课四天以上者，不得参加本次考核，按不及格处理。4 课程设计结束一周内，指导教师提交成绩和设计总结。5 设计过程考核和成绩在教

2、师手册中有记载。课程设计报告内容 课程设计报告内容、格式各专业根据专业不同统一规范，经教研室主任审核、主管院长审批备案。注： 1. 课程设计任务书和指导书在课程设计前发给学生，设计任务书放置在设计报告封面后和正文目录前。 2. 为了节省纸张，保护环境，便于保管实习报告，统一采用A4纸，实习报告建议双面打印（正文采用宋体五号字）或手写。09/10学年第2学期操作系统课程设计任务书指导教师：班级：一、课程设计的目的与要求本课程设计的目的是使课程设计的目的是使学生深刻理解操作系统的基本原理和方法。能够利用所学程序设计的知识和操作系统的原理，解决具体问题，提高学生程序设计的综合能力，为学生后续课程及毕

3、业设计打下良好的基础。要求学生从给定的十个题目中选择至少四个题目进行设计，并给出设计思想、设计规范、算法描述、源程序以及运行示例。二、课程设计的内容与安排1设计题目（范围） 设计一 进程调度 设计目的：进程管理是操作系统中的重要功能，用来创建进程、撤消进程、实现进程状态转换，它提供了在可运行的进程之间复用CPU的方法。在进程管理中，进程调度是核心，因为在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态，当就绪进程个数大于处理器数目时，就必须依照某种策略决定哪些进程优先占用处理器。本实验模拟在单处理器情况下的进程调度，目的是加深对进程调度工作的理解，掌握不同调度算法的优缺点。设计题目：

4、第一题：设计一个按先来先服务算法实现处理器调度的程序。第二题：设计一个按时间片轮转法实现处理器调度的程序。第三题：设计一个按优先数调度算法实现处理器调度的程序。第四题：设计一个按多级队列调度算法实现处理器调度的程序。 设计二进程同步 设计目的： 理解临界区和进程互斥的概念，掌握用信号量和PV操作实现进程互斥的方法。设计题目：在windows或者linux环境下编写一个控制台应用程序，该程序运行时能创建N个线程，其中既有读者线程又有写者线程，它们按照事先设计好的测试数据进行读写操作。用信号量和PV操作实现读者/写者问题。 设计三 死锁 设计目的： 死锁是进程并发执行过程中可能出现的现象，哲学家就

5、餐问题是描述死锁的经典例子。为了防止死锁，可以采用资源预分配法或者资源按序分配法。资源预分配法是指进程在运行前一次性地向系统申请它所需要的全部资源，如果系统当前不能够满足进程的全部资源请求，则不分配资源, 此进程暂不投入运行，如果系统当前能够满足进程的全部资源请求, 则一次性地将所申请的资源全部分配给申请进程。资源按序分配法是指事先将所有资源类全排序, 即赋予每一个资源类一个唯一的整数，规定进程必需按照资源编号由小到大的次序申请资源。设计题目：模拟有五个哲学家的哲学家进餐问题。 设计四 动态异长分区的存储分配与回收算法 设计目的： 存储器是计算机系统中的关键资源，存储管理一直是操作系统的最主要

6、功能之一。存储管理既包括内存资源管理，也包括用 于实现分级存储体系的外存资源的管理。通常，内存与外存可采用相同或相似的管理技术，如内存采用段式存储管理，则外存也采用段式存储管理。 通过本设计 理解存储管理的功能，掌握动态异长分区的存储分配与回收算法。设计题目：模拟动态异长分区的分配算法、回收算法和碎片整理算法。 设计五 虚拟设备 设计目的： 在网络环境下，连在网络服务器上的打印机要为多个终端服务，每个终端上的用户都可以通过客户端程序向服务器发送打印请求，服务器端的打印请求接收程序接收来自客户端的打印请求，并将该请求存放到磁盘上的打印请求队列中，由服务器端的假脱机打印程序在CPU空闲时从打印请求

7、队列中取出请求信息，并将文件输出到打印机中。这种工作方式不是将文件直接输出到打印机，而是先将待打印的文件缓存到磁盘上，然后立即返回用户程序，从而缩短了用户响应时间，为用户提供了虚拟的快速打印机.通过本设计理解虚拟设备的工作原理，理解守护程序的概念。设计题目：利用多线程技术编写假脱机打印程序，并设计测试数据以验证程序的正确性。 设计六 管道与进程通信 设计目的： 进程通信是指两个或者多个进程之间交换数据，管道允许进程之间按先进先出的方式传送数据。有两种类型的管道：有名管道和无名管道。有名管道可以使任意两个进程之间进行通信，无名管道只能用在父子进程之间。 通过本设计理解进程通信原理，掌握用管道实现

8、进程间通信的方法。设计题目： 在linux环境中利用有名管道实现两个进程之间的通信。 设计七 嵌入式操作系统下的并发程序设计 设计目的：了解嵌入式操作系统的特点，掌握在嵌入式操作系统下进行并发程序设计的方法。设计题目： 剖析源码公开的实时嵌入式操作系统内核uC/OS-II；在uC/OS-II上开发一个“并发程序设计动态演示系统”，此系统以可视化的方式演示多个任务在不同的优先级、不同的延时时间、不同的运行方式下的不同运行状况。教师可以根据实际情况确定学生独立完成任务个数，题目可参考本大纲中提供的，也可由学生自定，自定的题目须经指导教师批准。2主要技术指标和要求能按题目要求调试出正确的运行结果。3

9、方案选择及工作原理选择不同的设计题目，给出设计方案，正确运行。4设计成果的要求课程设计结束后，要求每个学生上交一份课程设计报告。报告要求包括课程设计任务，设计完成的界面图、源程序清单及课程设计总结等部分。三、进程安排时间，2010年3月1日-2010年3月5日。上机时间： 周四：7：50-12：00，2：00-16：30 周五：7：50-12：00 周六7：50-12：00序号完成内容时间1设计准备1天2按任务要求设计、调试程序，完成报告3天3总结和答辩1天4合计5天四、基本要求1明确课程设计任务，提高课程设计认识，严格服从教师安排，不迟到，不早退，不旷课，按时上机；上机时认真做设计，不得做聊

10、天、上网、玩游戏等与课程设计无关的事情，一经发现，经警告不改者，取消上机资格并把其课程设计成绩作零分计。2认真独立完成设计内容，上机前准备程序，做好资料搜集，能够上网查询所需资料；除了上机，其余时间为查找资料和编写程序，要充分利用好时间。3利用面向对象的方法以及VC+或者JAVA的编程思想来完成系统的设计，编写程序，调试各模块。4请各位同学携带U盘等存储设备，每次编写完程序作备份，以防源程序丢失。 五、课程设计的成果要求与成绩评定课程设计结束后，要求每个学生上交一份格式规范内容完整的课程设计报告。并能够上机演示程序运行结果。根据参加设计平时出勤表现情况、答辩验收情况、设计报告三方面评定给出最后

11、的总成绩。权重比例见下表：成绩评定项 目权重1、设计过程中出勤、能力、水平、态度等方面0.42、设计报告书写及图纸规范程度0.23、答辩0.4 一、进程调度1、设计目的： 进程管理是操作系统中的重要功能，用来创建进程、撤消进程、实现进程状态转换，它提供了在可运行的进程之间复用CPU的方法。在进程管理中，进程调度是核心，因为在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态，当就绪进程个数大于处理器数目时，就必须依照某种策略决定哪些进程优先占用处理器。本实验模拟在单处理器情况下的进程调度，目的是加深对进程调度工作的理解，掌握不同调度算法的优缺点。2、设计题目设计一个按多级队列调度算法实

12、现处理器调度的程序。3、 设计思想 设置多个就绪队列，分别赋予不同的优先级，如逐级降低，队列1的优先级最高。每个队列执行时间片的长度也不同，规定优先级越低则时间片越长，如逐级加倍。新进程进入内存后，先投入队列1的末尾，按FCFS算法调度；若按队列1一个时间片未能执行完，则降低投入到队列2的末尾，同样按FCFS算法调度；如此下去，降低到最后的队列，则按“时间片轮转”算法调度直到完成。仅当较高优先级的队列为空，才调度较低优先级的队列中的进程执行。如果进程执行时有新进程进入较高优先级的队列，则抢先执行新进程，并把被抢先的进程投入原队列的末尾。源代码 #include stdio.h#include

13、conio.h#include stdlib.h#include malloc.h#include time.h#include windows.h#define null 0#define N 4int MN=18;struct cpu /就绪队列 int time; /时间片数量 struct pss *head; struct pss *tail; ; struct pss /进程 char name5; int pro_time; /执行时间 int l_time; / 剩余时间 struct pss *next; ;void gotoxy(int x, int y) COORD c;

14、 c.X = x - 1; c.Y = y - 1; SetConsoleCursorPosition (GetStdHandle(STD_OUTPUT_HANDLE), c); void initial(struct cpu cpu_quene) /初始化就绪队列，时间片分别为2 4 8 16 int i,t=2; for(i=0;iname); gotoxy(25,8); printf(请输入处理进程需要的时间：); scanf(%d,&p-pro_time); p-l_time=p-pro_time; /剩余时间初始化，初始值为需要时间的值 p-next=null; if(cpu_que

15、ne0.head=null) cpu_quene0.head=p; cpu_quene0.tail=p; else q=cpu_quene0.tail; cpu_quene0.tail=p; q-next=p;void osdelay(int n)int a,i,m; m=500*n; a=clock(); for(i=0;i+) if(clock()-a=m) break; void print(struct cpu cpu_quene) struct pss *p; gotoxy(23,5); p=cpu_quene0.head; printf( ); gotoxy(23,5); whil

16、e(p!=null) printf(%s %d ,p-name,p-l_time); p=p-next; gotoxy(23,7); p=cpu_quene1.head; printf( ); gotoxy(23,7); while(p!=null) printf(%s %d ,p-name,p-l_time); p=p-next; gotoxy(23,9); p=cpu_quene2.head; printf( ); gotoxy(23,9); while(p!=null) printf(%s %d ,p-name,p-l_time); p=p-next; gotoxy(23,11); p=

17、cpu_quene3.head; printf( ); gotoxy(23,11); while(p!=null) printf(%s %d ,p-name,p-l_time); p=p-next;void nprint(struct pss *p)gotoxy(27,15); printf(%s %d ,p-name,p-l_time);void process(struct cpu cpu_queneN) /进程执行函数 struct pss *p,*q,*p1; int i=0,j,a,b; int flag1=1; while(il_time!=0) osdelay(1); p-l_t

18、ime=p-l_time-1; /剩余时间-1？ gotoxy(27,15); printf(进程%s处理完毕，离开队列!,p-name); cpu_quenei.head=p-next; print(cpu_quene); gotoxy(MN,18); printf(%s %d,p-name,p-pro_time); /输出执行结果 MN=MN+9; free(p); /释放内存 p=cpu_quenei.head; gotoxy(10,2); printf( ); gotoxy(10,2); printf(所有进程处理完毕!); else gotoxy(10,2); printf( );

19、gotoxy(10,2); printf(所有进程处理完毕!); flag1=0; break; case 2:p=cpu_quenei.head; for(;cpu_quenei.head!=null;) cpu_quenei.head=p-next; p-next=null; gotoxy(27,15); printf( ); nprint(p); b=cpu_quenei.time; while(p-l_time!=0&b!=0) osdelay(1); p-l_time=p-l_time-1; b-; /时间片减1 if(p-l_time=0) /剩余时间为零 gotoxy(27,15

20、); printf(进程%s处理完毕，离开队列!,p-name); gotoxy(MN,18); printf(%s %d,p-name,p-pro_time); /输出完成进程 MN=MN+9; free(p); else j=i+1; if(cpu_quenej.head!=null) /p=cpu_quenei.head q=cpu_quenej.tail; cpu_quenej.tail=p; q-next=p; else cpu_quenej.head=p; cpu_quenej.tail=p; p-next=null; print(cpu_quene); p=cpu_quenei.

21、head; cpu_quenei.tail=null; i+; if(i=3) a=1; else a=2; break; void main() int i, j,flag=1,t=2; char a; struct pss *p1; struct cpu cpu_quene4; initial(cpu_quene); /创建就绪队列 for(;flag=1;) gotoxy(20,4); printf(); for(j=5;jname,p1-pro_time); p1=p1-next; for(j=4;j13;j+) gotoxy(8,j); printf( ); gotoxy(8,4);

22、 printf(); gotoxy(10,5); printf(一级队列 2：); gotoxy(10,7); printf(二级队列 4：); gotoxy(10,9); printf(三级队列 8：); gotoxy(10,11); printf(四级队列 16：); gotoxy(8,13); printf(); print(cpu_quene); gotoxy(10,15); printf(正在处理的进程：); process(cpu_quene); gotoxy(10,20);printf(n*); 运行结果： 重点和难点及其解决方法 多级反馈队列算法的实现。刚开始对多级反馈队列算法

23、不太了解，是FCFS 、RR、HPF三者结合而形成的一种进程调度算法。 二、进程同步 1、设计目的： 理解临界区和进程互斥的概念，掌握用信号量和PV操作实现进程互斥的方法。2、设计题目： 在windows或者linux环境下编写一个控制台应用程序，该程序运行时能创建N个线程，其中既有读者线程又有写者线程，它们按照事先设计好的测试数据进行读写操作。用信号量和PV操作实现读者/写者问题。 3、 设计思路 将所有的读者和所有的写者分别放进两个等待队列中，当读允许时就让读者队列释放一个或多个读者，当写允许时，释放第一个写者操作。 读者优先： 如果没有写者正在操作，则读者不需要等待，用一个整型变量rea

24、dcount记录当前的读者数目，用于确定是否释放写者线程，（当readcout=0 时，说明所有的读者都已经读完，释放一个写者线程），每个读者开始读之前都要修改readcount,为了互斥的实现对readcount 的修改，需要一个互斥对象Mutex来实现互斥。 另外，为了实现写-写互斥，需要一个临界区对象 write,当写者发出写的请求时，必须先得到临界区对象的所有权。通过这种方法，可以实现读写互斥，当readcount=1 时，（即第一个读者的到来时，），读者线程也必须申请临界区对象的所有权. 当读者拥有临界区的所有权，写者都阻塞在临界区对象write上。当写者拥有临界区对象所有权时，第一

25、个判断完readcount=1 后，其余的读者由于等待对readcount的判断，阻塞在Mutex上！ 写者优先： 写者优先和读者优先有相同之处，不同的地方在：一旦有一个写者到来时，应该尽快让写者进行写，如果有一个写者在等待，则新到的读者操作不能读操作，为此添加一个整型变量writecount,记录写者的数目，当writecount=0时才可以释放读者进行读操作！ 为了实现对全局变量writecount的互斥访问，设置了一个互斥对象Mutex3。 为了实现写者优先，设置一个临界区对象read,当有写者在写或等待时，读者必须阻塞在临界区对象read上。 读者除了要一个全局变量readcount实

26、现操作上的互斥外，还需要一个互斥对象对阻塞在read这一个过程实现互斥，这两个互斥对象分别为mutex1和mutex2。 程序结构4、 源代码 #include #include #include fstream.h int readcount=0; /int writecount=0; /CRITICAL_SECTION RP_Write; /CRITICAL_SECTION cs_Write;CRITICAL_SECTION cs_Read;struct ThreadInfo /int Threadhao; /char ThreadClass; /double ThreadStartTim

27、e; /double ThreadRunTime; /;void ReaderFun(char* file);/void R_ReaderThread(void *p);/void R_WriterThread(void *p);/void WriterFun(char* file); /void W_ReaderThread(void *p);/void W_WriterThread(void *p);/int main()/char select;while (true)cout*-*nendl;cout 1:endl; cout 2:endl;cout 3:endl;coutn*endl

28、;cout:select;if(select!=1 & select!=2 & select!=3)coutendl;while (select!=1 & select!=2 & select!=3);system(cls);if (select=3)return 0;/else if (select=1)/ReaderFun(peizhi.txt); else if(select=2)/ WriterFun(peizhi.txt);coutn? 1. 2.select;if(select!=1 & select!=2 )coutendl;while (select!=1 & select!=

29、2);if(select=2)return 0;/system(cls);return 0;/void ReaderFun(char* file)DWORD n_thread=0; /0DWORD thread_ID; /IDDWORD wait_for_all; /HANDLE h_Mutex;/(h_Mutex)h_Mutex=CreateMutex(NULL,FALSE,mutex_for_readcount);HANDLE h_Thread64;/64ThreadInfo thread_info64;readcount=0; InitializeCriticalSection(&RP_

30、Write); /ifstream inFile;inFile.open(file); cout:nthread_infon_thread.Threadhaothread_infon_thread.ThreadClass thread_infon_thread.ThreadStartTimethread_infon_thread.ThreadRunTime;if (-1 = inFile.get()break;n_thread+;/for (int i=0;i(int)(n_thread);i+)if (thread_infoi.ThreadClass=r)/h_Threadi=CreateT

31、hread(NULL,0,(LPTHREAD_START_ROUTINE)(R_ReaderThread),&thread_infoi,0,&thread_ID);else/h_Threadi=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(R_WriterThread),&thread_infoi,0,&thread_ID);wait_for_all=WaitForMultipleObjects(n_thread,h_Thread,TRUE,-1);cout.Threadhao;m_delay=(DWORD)(ThreadInfo *)(p)-Thr

32、eadStartTime*100);m_ThreadRunTime=(DWORD)(ThreadInfo *)(p)-ThreadRunTime*100);Sleep(m_delay); /cout m_Threadhao .endl;/wait_for_mutex=WaitForSingleObject(h_Mutex,-1); /readcount /readcount+; /if (readcount=1)EnterCriticalSection(&RP_Write);/ ReleaseMutex(h_Mutex);/cout m_Threadhao .endl;Sleep(m_Thre

33、adRunTime);/cout m_Threadhao .Threadhao;m_delay=(DWORD)(ThreadInfo *)(p)-ThreadStartTime*100);m_ThreadRunTime=(DWORD)(ThreadInfo *)(p)-ThreadRunTime*100);Sleep(m_delay); /cout m_Threadhao .endl;EnterCriticalSection(&RP_Write);/cout m_Threadhao .endl;Sleep(m_ThreadRunTime);/cout m_Threadhao .endl;Lea

34、veCriticalSection(&RP_Write);/void WriterFun(char* file)DWORD n_thread=0; /DWORD thread_ID; /IDDWORD wait_for_all; /HANDLE h_Mutex1, h_Mutex2, h_Mutex3;h_Mutex1 = CreateMutex(NULL, FALSE, mutex_for_writecount);h_Mutex2 = CreateMutex(NULL, FALSE, mutex_for_readcount);h_Mutex3 = CreateMutex(NULL, FALS

35、E, mutex_for_read);/HANDLE h_Thread64;ThreadInfo thread_info64;readcount=0; /readcountInitializeCriticalSection(&cs_Write); /InitializeCriticalSection(&cs_Read);ifstream inFile;inFile.open(file); /cout:nthread_infon_thread.Threadhaothread_infon_thread.ThreadClassthread_infon_thread.ThreadStartTimeth

36、read_infon_thread.ThreadRunTime;if(-1 = inFile.get()break;n_thread+;/for (int i=0;i(int)(n_thread);i+)if (thread_infoi.ThreadClass=r)/h_Threadi=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(W_ReaderThread),&thread_infoi,0,&thread_ID);else/h_Threadi=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(W_Write

37、rThread),&thread_infoi,0,&thread_ID);/wait_for_all=WaitForMultipleObjects(n_thread,h_Thread,TRUE,-1);cout.Threadhao;m_delay=(DWORD)(ThreadInfo *)(p)-ThreadStartTime*100);/100m_ThreadRunTime=(DWORD)(ThreadInfo *)(p)-ThreadRunTime*100);Sleep(m_delay); cout m_Threadhao .endl;wait_for_mutex=WaitForSingl

38、eObject(h_Mutex1,-1); writecount+;if (writecount=1) EnterCriticalSection(&cs_Read); /ReleaseMutex(h_Mutex1); /mutex-1EnterCriticalSection(&cs_Write);cout m_Threadhao .endl;Sleep(m_ThreadRunTime);cout m_Threadhao .endl;LeaveCriticalSection(&cs_Write); /wait_for_mutex=WaitForSingleObject(h_Mutex1,-1); writecount-;if(writecount = 0)LeaveCriticalSection(&cs_Read); /ReleaseMutex(h_Mutex1);/-void W_ReaderThread(void *p)HANDLE h_Mutex2, h_Mutex3;h_Mutex2 = OpenMutex(MUTEX_ALL_ACCESS,FALSE,mutex_for_readcount);h_Mutex3 = OpenMutex(MUTEX_ALL_ACCESS,FALSE,mutex_for_read);DWORD wait_for