黑龙江大学“操作系统课程设计”总结报告
《操作系统》课程设计报告
《操作系统》课程设计报告一、读者/写者的问题模拟实现读者/写者问题，是指保证一个writer 进程必须与其他进程互斥地访问共享对象的同步问题。
读者写者问题可以这样的描述：有一群写者和一群读者，写者在写同一本书，读者也在读这本书，多个读者可以同时读这本书，但是只能有一个写者在写书，并且读者必优先，也就是说，读者和写者同时提出请求时，读者优先。
当读者提出请求时，需要有一个互斥操作，另外需要有一个信号量S 来确定当前是否可操作。
信号量机制是支持多道程序的并发操作系统设计中解决资源共享时进程间的同步与互斥的重要机制，而读者写者则是这一机制的一个经典范例。
与记录型信号量解决读者——写者问题不同，信号量机制它增加了一个限制，即最多允许RN 个读者同时读。
为此，又引入了一个信号量L,并赋予初值为RN，通过执行wait （L,1,1）操作来控制读者的数目，每当有一个读者进入时，就要执行wait （L,1,1）操作，使L 的值减1。
当有RN 个读者进入读后，L 便减为0，第RN+1 个读者要进入读时，必然会因wait（L,1,1）操作失败而堵塞。
程序实例：#include <windows.h>#include <ctype.h>#include <stdio.h>#include <string.h>#include <stdlib.h>#include <malloc.h>#define MAX_PERSON 100#define READER 0 //读者#define WRITER 1 //写者#define END -1#define R READER#define W WRITERtypedef struct _Person{HANDLE m_hThread;//定义处理线程的句柄int m_nType;//进程类型（读写）int m_nStartTime;//开始时间int m_nWorkTime;//运行时间int m_nID;//进程号}Person;Person g_Persons[MAX_PERSON];int g_NumPerson = 0;long g_CurrentTime= 0;//基本时间片数int g_PersonLists[] = {//进程队列1, W, 3, 5, 2, W, 16, 5, 3, R, 5, 2,4, W, 6, 5, 5, R, 4, 3, 6, R, 17,7,END,};int g_NumOfReading = 0;int g_NumOfWriteRequest = 0;//申请写进程的个数HANDLE g_hReadSemaphore;//读者信号HANDLE g_hWriteSemaphore;//写者信号bool finished = false; //所有的读完成//bool wfinished = false; //所有的写完成void CreatePersonList(int *pPersonList);bool CreateReader(int StartTime,int WorkTime,int ID);bool CreateWriter(int StartTime,int WorkTime,int ID);DWORD WINAPI ReaderProc(LPVOID lpParam);DWORD WINAPI WriterProc(LPVOID lpParam);int main(){g_hReadSemaphore = CreateSemaphore(NULL,1,100,NULL); //创建信号灯，当前可用的资源数为1，最大为100g_hWriteSemaphore = CreateSemaphore(NULL,1,100,NULL); //创建信号灯，当前可用的资源数为1，最大为100CreatePersonList(g_PersonLists); // Create All the reader and writersprintf("Created all the reader and writer\n 创建\n");g_CurrentTime = 0;while(true){g_CurrentTime++;Sleep(300); // 300 msprintf("CurrentTime = %d\n",g_CurrentTime);if(finished) return 0;} // return 0;}void CreatePersonList(int *pPersonLists){int i=0;int *pList = pPersonLists;bool Ret;while(pList[0] != END){switch(pList[1]){case R:Ret = CreateReader(pList[2],pList[3],pList[0]);//351,w452,523,654break; case W:Ret = CreateWriter(pList[2],pList[3],pList[0]);break;}if(!Ret)printf("Create Person %d is wrong\n",pList[0]);pList += 4; // move to next person list}}DWORD WINAPI ReaderProc(LPVOID lpParam)//读过程{Person *pPerson = (Person*)lpParam;// wait for the start timewhile(g_CurrentTime != pPerson->m_nStartTime){ }printf("Reader %d is Requesting 等待\n",pPerson->m_nID);printf("\n\n************************************************\n");// wait for the write requestWaitForSingleObject(g_hReadSemaphore,INFINITE); if(g_NumOfReading ==0) {WaitForSingleObject(g_hWriteSemaphore,INFINITE); }g_NumOfReading++;ReleaseSemaphore(g_hReadSemaphore,1,NULL);pPerson->m_nStartTime = g_CurrentTime;printf("Reader %d is Reading the Shared Buffer等待\n",pPerson->m_nID); printf("\n\n************************************************\n"); while(g_CurrentTime <= pPerson->m_nStartTime + pPerson->m_nWorkTime) {}printf("Reader %d is Exit退出\n",pPerson->m_nID);printf("\n\n************************************************\n"); WaitForSingleObject(g_hReadSemaphore,INFINITE);g_NumOfReading--;if(g_NumOfReading == 0){ReleaseSemaphore(g_hWriteSemaphore,1,NULL);//此时没有读者，可以写}ReleaseSemaphore(g_hReadSemaphore,1,NULL);if(pPerson->m_nID == 4) finished = true; //所有的读写完成ExitThread(0);return 0;}DWORD WINAPI WriterProc(LPVOID lpParam){Person *pPerson = (Person*)lpParam;// wait for the start timewhile(g_CurrentTime != pPerson->m_nStartTime){}printf("Writer %d is Requesting 请求进行写操作\n",pPerson->m_nID);printf("\n\n************************************************\n"); WaitForSingleObject(g_hWriteSemaphore,INFINITE);// modify the writer's real start timepPerson->m_nStartTime = g_CurrentTime;printf("Writer %d is Writting the Shared Buffer写内容\n",pPerson->m_nID);while(g_CurrentTime <= pPerson->m_nStartTime + pPerson->m_nWorkTime){}printf("Writer %d is Exit退出\n",pPerson->m_nID);printf("\n\n************************************************\n");//g_NumOfWriteRequest--;ReleaseSemaphore(g_hWriteSemaphore,1,NULL);if(pPerson->m_nID == 4) finished = true;//所有的读写完成ExitThread(0);return 0;}bool CreateReader(int StartTime,int WorkTime,int ID){DWORD dwThreadID;if(g_NumPerson >= MAX_PERSON)return false;Person *pPerson = &g_Persons[g_NumPerson];pPerson->m_nID = ID;pPerson->m_nStartTime = StartTime;pPerson->m_nWorkTime = WorkTime;pPerson->m_nType = READER;g_NumPerson++;// Create an New ThreadpPerson->m_hThread= CreateThread(NULL,0,ReaderProc,(LPVOID)pPerson,0,&dwThreadID); if(pPerson->m_hThread == NULL)return false;return true;}bool CreateWriter(int StartTime,int WorkTime,int ID){DWORD dwThreadID;if(g_NumPerson >= MAX_PERSON)return false;Person *pPerson = &g_Persons[g_NumPerson];pPerson->m_nID = ID;pPerson->m_nStartTime = StartTime;pPerson->m_nWorkTime = WorkTime;pPerson->m_nType = WRITER;g_NumPerson++;// Create an New ThreadpPerson->m_hThread= CreateThread(NULL,0,WriterProc,(LPVOID)pPerson,0,&dwThreadID); if(pPerson->m_hThread == NULL)return false;return true;}二、进程间通信与子进程使用管道进行父子进程间通信，程序首先判断参数是否合法，因为输入的字符将从父进程通过发送到子进程中。
操作系统课程设计实验报告
操作系统课程设计实验报告操作系统课程设计实验报告引言：操作系统是计算机科学中的重要课程，通过实验设计，可以帮助学生更好地理解操作系统的原理和实践。
本文将结合我们在操作系统课程设计实验中的经验，探讨实验设计的目的、实验过程和实验结果，以及对操作系统的理解和应用。
一、实验设计目的操作系统课程设计实验的目的是帮助学生深入理解操作系统的工作原理和实际应用。
通过设计和实现一个简单的操作系统，学生可以更好地掌握操作系统的各个组成部分，如进程管理、内存管理、文件系统等。
同时，实验设计还可以培养学生的动手能力和问题解决能力，提高他们对计算机系统的整体把握能力。
二、实验过程1. 实验准备在进行操作系统课程设计实验之前，我们需要对操作系统的基本概念和原理进行学习和理解。
同时，还需要掌握一些编程语言和工具，如C语言、汇编语言和调试工具等。
这些准备工作可以帮助我们更好地进行实验设计和实现。
2. 实验设计根据实验要求和目标，我们设计了一个简单的操作系统实验项目。
该项目包括进程管理、内存管理和文件系统三个主要模块。
在进程管理模块中，我们设计了进程创建、调度和终止等功能；在内存管理模块中，我们设计了内存分配和回收等功能；在文件系统模块中，我们设计了文件的创建、读写和删除等功能。
通过这些模块的设计和实现，我们可以全面了解操作系统的各个方面。
3. 实验实现在进行实验实现时，我们采用了分阶段的方法。
首先，我们实现了进程管理模块。
通过编写相应的代码和进行调试，我们成功地实现了进程的创建、调度和终止等功能。
接下来，我们实现了内存管理模块。
通过分配和回收内存空间，我们可以更好地管理系统的内存资源。
最后，我们实现了文件系统模块。
通过设计文件的读写和删除等功能，我们可以更好地管理系统中的文件资源。
三、实验结果通过实验设计和实现，我们获得了一些有意义的结果。
首先，我们成功地实现了一个简单的操作系统，具备了进程管理、内存管理和文件系统等基本功能。
操作系统课程设计报告
操作系统课程设计报告概述：本课程设计旨在使学生熟悉文件管理系统的设计方法，加深对所学各种文件操作的了解及其操作方法的特点。
通过模拟文件系统的实现，深入理解操作系统中文件系统的理论知识，加深对教材中的重要算法的理解。
同时通过编程实现这些算法，更好地掌握操作系统的原理及实现方法，提高综合运用各专业课知识的能力。
主要任务：本课程设计的主要任务是设计和实现一个简单的文件系统，包括建立文件存储介质的管理机制、建立目录（采用一级目录结构）、文件系统功能（显示目录、创建、删除、打开、关闭、读、写）和文件操作接口（显示目录、创建、删除、打开、关闭、读、写）。
系统设计：本系统模拟一个文件管理系统，要完成对文件的基本操作，包括文件、文件夹的打开、新建、删除和读取写入文件，创建更改目录，列出目录内容等信息。
系统建立了文件目录树，存储文件系统中的所有文件。
对于用户名下的文件，用文件目录树的分支来存储。
采用命令行操作界面很直观，也方便用户进行操作，用户只要按照操作界面所显示的命令来操作即可。
整体设计框架：系统初始化界面由创建用户存储空间、管理文件、退出系统三个模块组成。
用户创建由创建用户存储空间、进入目录、删除用户存储空间、显示所有用户存储空间等模块组成。
然后各个模块再由一些小模块组成。
其中创建文件、打开关闭文件、读写文件等文件操作模块包括在进入目录模块里面。
系统实现：以下是本课程设计的主要内容的实现程序代码：cincludeincludeincludetypedef struct file{ char name[10];struct file *next; File;typedef struct content{ char name[10];File *file;int f_num;struct content *next; Content;typedef struct user{ char name[10];char psw[10]; Content *con;struct user *next; User;char cur_user[20];XXX;int user_num=0;添加文件：在该函数中，我们首先需要获取文件名，然后检查是否已经存在该文件。
操作系统课程设计报告心得体会2019_心得体会范文_
操作系统课程设计报告心得体会2019课程设计终于结束了，我们的程序也通过了，这次的课程设计给我们很大的收获，使我们对操作系统的基本知识有了进一步的提高，并在实践中对各种概念有了进一步的深化，开始的时候总觉得很简单的课程设计，因为程序的编写确实不是很难的，所以在开始的时候都没有认真做，一直到要交需求分析的时候才发现老师的要求蛮高的，因为写了三遍的需求分析才通过，虽然只用了一个下午，但明白了一个道理，简单的应付是不容易完成的。
到开始编程序的时候，基本是peng一个人完成的，因为我们认为程序也不是很大，多人写的话光说明接口就要好多时间(后来的事情证明当初的想象是不正确的)，结果是我们的程序没有通过，老师说是程序的基本设计有问题，经过研究发现peng对需求分析的理解出了些问题，导致我们重新写的程序(大家都觉得很郁闷)，当时已经很晚了，后天就该交程序了，甚至都不想做了，重写程序简直让我们没法接受，最后终于我们还是打起精神，经过一个黑夜的努力，在第二天写完了程序。
由于大家的参与，设计书很快也就写出来了。
现将课程设计中的收获简单的写在下面。
1.程序的设计思想的精巧的重要性，是不管怎么说都不为过的，好的设计可以让大家很快的明白你的思想，而且很方便的来实现它。
2.在多人做项目的时候，队员的交流是非常重要的，接口的说明和思想的交流都是很关键的部分。
3.良好的编程习惯，它可以使你的程序很方便的被别人阅读，也很方便的被更改，所以可以的话，尽可能多的写出注释，没有人会闲你写的太多。
4.尽可能多的和客户去联系，因为你写的东西可能并不满足他的要求，而你可能并不知道，或者在你完成了后才发现自己根本没有符合要求，这样简直会让你疯掉。
5.基本的语言功底一定要扎实，不想看到一个cin或者getline会让我们查一个小时资料。
课程设计结束了，不只学到了设计简单磁盘管理的思想，重要的是有了多人合作项目的经验，这简直太重要了。
操作系统课程设计总结报告(白雪娇3823).
int data; struct LNode *next; }LNode; 1.4 算法设计及流程图: 算法： 创建进程：输入进程的名称，先判断进程名是否已存在，若已存在，
则创建进程失败，需重新操作，创建进程成功后，新进 程进入就绪队列。若执行态为空，将进程插入执行态。 阻塞进程：若当前有执行进程，则将其阻塞，并将进程加入阻塞态， 若就绪队列不为空，则就绪队列第一个进程插入执行 态；若当前无执行进程 ，则阻塞失败。 唤醒进程：若当前阻塞态不为空，则将阻塞队列第一个进程插入就 绪态；若当前阻塞态为空，则唤醒失败。 时间片到：若当前有执行态进程，则插入就绪队态，并将就绪态第 一个进程进入执行态；若当前无执行进程，则无执行进 程。 结束进程：若当前有执行进程，则结束进程，若当前就绪态不为空， 则就绪态第一个进程进入执行态；若当前无执行进程 ， 则结束进程失败。
产生缺页中断，分别用 FIFO 算法和 LRU 算法请求调页，并计算缺 页率。 流程图：
开始
输入页表长度 length 输入栈的大小 size
输入内存大小 memory
随机生成位示图
输入逻辑地址 logical
根据页块计算出物理地址
根据页表号入栈（内存）
Y
改变栈顶指针 置换
命中？
N
栈满？
N
块号入栈
要求在驱动程序之上设计一层设备无关软件，其主要功能可分 为：
（1）执行所有设备的公有操作，主要包括：(a)独占设备的分配与 回收；(b)将逻辑设备名映射为物理设备（LUT），进一步可以 找到相应物理设备的驱动程序。
（2）向用户层（或文件层）软件提供统一的接口。例如，对各种 设备的读操作，在应用程序中都用 read; 而对各种设备的写 操作，则都使用 write。
《操作系统》课程实验报告
《操作系统》课程实验报告一、实验目的本次《操作系统》课程实验的主要目的是通过实际操作和观察，深入理解操作系统的工作原理、进程管理、内存管理、文件系统等核心概念，并掌握相关的操作技能和分析方法。
二、实验环境1、操作系统：Windows 10 专业版2、开发工具：Visual Studio Code3、编程语言：C/C+＋三、实验内容（一）进程管理实验1、进程创建与终止通过编程实现创建新进程，并观察进程的创建过程和资源分配情况。
同时，实现进程的正常终止和异常终止，并分析其对系统的影响。
2、进程同步与互斥使用信号量、互斥锁等机制实现进程之间的同步与互斥。
通过模拟多个进程对共享资源的访问，观察并解决可能出现的竞争条件和死锁问题。
（二）内存管理实验1、内存分配与回收实现不同的内存分配算法，如首次适应算法、最佳适应算法和最坏适应算法。
观察在不同的内存请求序列下，内存的分配和回收情况，并分析算法的性能和优缺点。
2、虚拟内存管理研究虚拟内存的工作原理，通过设置页面大小、页表结构等参数，观察页面的换入换出过程，以及对系统性能的影响。
（三）文件系统实验1、文件操作实现文件的创建、打开、读取、写入、关闭等基本操作。
观察文件在磁盘上的存储方式和文件系统的目录结构。
2、文件系统性能优化研究文件系统的缓存机制、磁盘调度算法等，通过对大量文件的读写操作，评估不同优化策略对文件系统性能的提升效果。
四、实验步骤（一）进程管理实验步骤1、进程创建与终止（1）使用 C/C+＋语言编写程序，调用系统函数创建新进程。
（2）在子进程中执行特定的任务，父进程等待子进程结束，并获取子进程的返回值。
（3）通过设置异常情况，模拟子进程的异常终止，观察父进程的处理方式。
2、进程同步与互斥（1）定义共享资源和相关的信号量或互斥锁。
（2）创建多个进程，模拟对共享资源的并发访问。
（3）在访问共享资源的关键代码段使用同步机制，确保进程之间的正确协作。
（4）观察并分析在不同的并发情况下，系统的运行结果和资源竞争情况。
《操作系统课程设计》报告范本
ｖoｉdfirｓｔin（void）
{
if(reaｄy!=NULL)
｛
run=reａdｙ;
ｒｅady=reａdｙ-＞ｎｅxｔ;
ruｎ->staｔｅ='Ｒ';
ｒun-＞nｅｘt=NUＬL；
}
ｅlｓe
{
ruｎ＝ＮULL;
}
}
voidprt1（cｈarａ)
{
ﻩcout＜<＂nａme＂<<" ｃｐuｔiｍe＂<<＂ needｔimｅ＂＜＜" couｎt ＂<＜＂ rｏunｄ"<<＂ statｅ＂<<endl;
intcputｉme;／*进程消耗的ＣUＰ时间＊/
intneeｄtime;/*进程需要的CUP时间*/
inｔcｏunt;/＊进程运行时间*／
cｈaｒsｔaｔe;／*进程的状态:'R＇:运行,'Ｗ'：等待,'Ｆ':结束＊/
ｓtructnode *nｅxt;/*指向下一个进程的指针*/
｝ＰCB;
ＰＣB *ｆinish,*ready,*ｔａil,*ｒuｎ;/*指向三个队列的队首的指针,taiｌ为就绪队列的队尾指针*/
进程的个数，进程的内容(即进程的功能序列）来源于一个进程序列描述文件,另外调度运行结果输出到一个运行日志文件;
设计PCB适用于时间片轮转法;
建立进程队列；
实现时间片轮转调度算法，尽量可视化的展示调度的动态过程。
总结程序设计的开发过程：需求分析、系统设计、系统实现及文档的收集和整理。
三、实验方法与设计分析
ciｎ＞＞N；
操作系统课程实验报告
操作系统课程实验报告操作系统课程实验报告一、引言操作系统是计算机系统中最基础的软件之一，扮演着管理计算机硬件和软件资源的重要角色。
为了更好地理解操作系统的工作原理和实践操作系统的相关技术，我们在本学期的操作系统课程中进行了一系列的实验。
二、实验一：进程管理在本实验中，我们学习了进程管理的基本概念和实现方法。
通过编写代码，我们实现了一个简单的进程管理系统。
在这个系统中，我们可以创建、销毁和调度进程，并且实现了进程间的通信和同步机制。
通过这个实验，我们深入了解了进程的创建、调度和通信机制，以及进程的状态转换和资源管理。
三、实验二：内存管理内存管理是操作系统中非常重要的一部分。
在这个实验中，我们学习了内存管理的基本原理和实现方法。
通过编写代码，我们实现了一个简单的内存管理系统。
在这个系统中，我们可以分配和释放内存块，并且实现了虚拟内存和页面置换算法。
通过这个实验，我们深入了解了内存的分配和释放机制，以及虚拟内存的概念和实现。
四、实验三：文件系统文件系统是计算机系统中用于管理和组织文件的一种机制。
在这个实验中，我们学习了文件系统的基本概念和实现方法。
通过编写代码，我们实现了一个简单的文件系统。
在这个系统中，我们可以创建、读取和写入文件，并且实现了文件的目录结构和权限控制。
通过这个实验，我们深入了解了文件的组织和管理机制，以及文件的访问和保护机制。
五、实验四：设备管理设备管理是操作系统中负责管理计算机硬件设备的一部分。
在这个实验中，我们学习了设备管理的基本原理和实现方法。
通过编写代码，我们实现了一个简单的设备管理系统。
在这个系统中，我们可以管理设备的分配和释放，并且实现了设备的互斥和同步机制。
通过这个实验，我们深入了解了设备的管理和调度机制，以及设备的并发和互斥机制。
六、实验总结通过这一系列的实验，我们对操作系统的工作原理和实践操作系统的相关技术有了更深入的了解。
我们学习了进程管理、内存管理、文件系统和设备管理的基本概念和实现方法，并且通过编写代码实现了简单的操作系统功能。
操作系统实验报告总结
操作系统实验报告总结操作系统实验报告总结引言操作系统是计算机系统中非常重要的一个组成部分，它负责管理计算机硬件和软件资源，为用户提供一个良好的工作环境。
通过操作系统实验，我们深入了解了操作系统的原理和功能，并通过实践掌握了操作系统的基本操作和管理技巧。
本文将对我们在操作系统实验中的学习和收获进行总结。
实验一：操作系统的安装与配置在本次实验中，我们学习了如何安装和配置操作系统。
通过实践，我们了解了操作系统的安装过程和常见的配置选项。
在安装过程中，我们需要选择适合我们计算机硬件的操作系统版本，并进行相应的设置。
通过这个实验，我们对操作系统的安装和配置有了更深入的了解。
实验二：进程管理进程是操作系统中的一个重要概念，它代表了一个正在运行的程序。
在本次实验中，我们学习了进程的创建、调度和终止等操作。
通过实践，我们掌握了如何使用操作系统提供的命令和工具来管理进程，如查看进程列表、创建新进程、终止进程等。
这些操作对于提高系统的资源利用率和运行效率非常重要。
实验三：内存管理内存管理是操作系统中的另一个重要概念，它负责管理计算机的内存资源。
在本次实验中，我们学习了内存的分配和释放、虚拟内存的管理等操作。
通过实践，我们了解了操作系统如何通过页表、地址映射等技术来管理内存资源。
这些知识对于保证系统的稳定性和性能至关重要。
实验四：文件系统文件系统是操作系统中用于管理文件和目录的一种机制。
在本次实验中，我们学习了文件系统的创建、读写文件等操作。
通过实践，我们掌握了如何使用操作系统提供的命令和工具来管理文件和目录，如创建文件、复制文件、删除文件等。
这些操作对于有效地组织和管理文件非常重要。
实验五：设备管理设备管理是操作系统中的另一个重要模块，它负责管理计算机的硬件设备。
在本次实验中，我们学习了设备的初始化、打开、关闭等操作。
通过实践，我们了解了操作系统如何通过设备驱动程序来管理硬件设备。
这些知识对于保证系统的稳定性和性能至关重要。
操作系统实训报告总结
操作系统实训报告总结1. 引言操作系统实训是计算机科学与技术专业中非常重要的一门课程。
通过该实训，学生可以深入了解操作系统的原理和应用，并通过实践操作系统设计和开发的过程，提升自己的动手能力和解决问题的能力。
本文将对操作系统实训报告进行总结，讨论实训的目标、内容和收获，并分享个人对操作系统实训的观点和理解。
2. 操作系统实训的目标操作系统实训的目标是培养学生对操作系统原理和应用的理解，并通过实践项目来巩固和应用相关的知识。
通过实训，学生应当能够独立思考和解决实际问题，掌握常用操作系统的设计和开发方法，提升自身的编程能力和团队合作能力。
3. 实训内容和项目操作系统实训通常分为理论学习和实践项目两个部分。
在理论学习阶段，学生需要学习操作系统的概念、原理和各个模块之间的关系。
这包括进程管理、内存管理、文件系统、I/O 设备管理等内容。
在实践项目阶段，学生需要根据老师或指导书的要求，选择一个操作系统相关的项目进行设计和开发。
常见的项目包括模拟操作系统调度算法、实现虚拟内存管理、设计一个简单的文件系统等。
4. 操作系统实训的收获通过参加操作系统实训，学生可以获得以下收获：4.1 知识积累：通过理论学习和实践项目，学生可以深入了解操作系统的原理和应用，并掌握相关的编程技巧和工具使用方法。
4.2 动手能力提升：实训强调动手实践，学生需要亲自设计和实现操作系统相关的项目，提高了他们的动手能力和解决问题的能力。
4.3 团队合作能力：实训项目通常需要学生组成团队合作完成，通过与队友的合作和沟通，学生可以提升自己的团队合作能力和协作能力。
4.4 发现问题和解决问题的能力：实训过程中，学生可能会遇到各种问题，包括设计问题、编程问题等。
通过解决这些问题，他们可以培养自己的问题发现和解决问题的能力。
5. 个人观点和理解操作系统实训对我来说是一个很有挑战性和意义的项目。
通过实践项目，我不仅深入理解了操作系统的原理和应用，还提升了我的动手能力和解决问题的能力。
操作系统课程设计心得体会
操作系统课程设计心得体会导言操作系统是计算机科学和工程领域的重要基础课程之一，它涵盖了计算机系统中最核心的组件之一。
在完成操作系统课程设计的过程中，我深深体会到了操作系统的重要性和复杂性。
通过设计和实现一个简单的操作系统，我不仅加深了对操作系统原理的理解，还锻炼了编程能力和解决问题的能力。
项目背景及目标在操作系统课程设计中，我们的任务是设计一个简单的操作系统，实现一些基本的功能。
具体目标包括：处理器管理、内存管理、文件系统和进程管理。
通过这个项目，我们将深入了解操作系统的核心原理，并学会将理论知识与实际应用相结合。
设计思路与方法处理器管理在处理器管理方面，我们设计了一个调度器来分配系统资源。
我们采用了简单的轮转调度算法，即按照顺序为每个进程分配一个时间片。
通过设计和实现这一调度器，我们深入了解了调度算法的原理和实现方式。
内存管理在内存管理方面，我们使用了分页技术来管理内存空间。
我们将物理内存空间划分成若干固定大小的页，将用户程序划分为相同大小的页框，实现了虚拟内存到物理内存的映射。
通过这种方式，我们可以更灵活地管理内存，并支持多任务运行。
文件系统我们设计了一个简单的文件系统，用于管理磁盘上的文件。
文件系统采用了层次目录结构，支持对文件的增删改查等基本操作。
通过实现文件系统，我们了解了文件系统的组织结构和文件的存储方式。
进程管理在进程管理方面，我们设计了一个进程调度器和一个进程控制块。
进程调度器负责根据一定策略选择下一个要运行的进程，而进程控制块则保存了进程的相关信息，如进程状态、寄存器的值等。
通过实现这些功能，我们学会了如何管理和调度进程，以及如何处理进程间的通信和同步问题。
实施过程与结果在实施操作系统课程设计的过程中，我们遇到了许多挑战和困难。
首先，理解和掌握操作系统的核心原理需要花费很多时间和精力。
我们通过阅读教材、查阅相关资料，并结合实际操作来加深对操作系统原理的理解。
其次，在设计和实现操作系统的各个模块时，我们需要考虑彼此之间的协作和依赖关系。
操作系统课程实验报告
操作系统课程实验报告一、实验目的操作系统是计算机系统中最为关键的软件之一，它负责管理计算机的硬件资源和软件资源，为用户提供一个良好的工作环境。
通过操作系统课程实验，旨在深入理解操作系统的基本原理和功能，提高对操作系统的实际操作能力和问题解决能力。
二、实验环境本次实验使用的操作系统为Windows 10 和Linux（Ubuntu 1804），开发工具包括 Visual Studio Code、gcc 编译器等。
三、实验内容（一）进程管理1、进程创建与终止在 Windows 系统中，使用 C+＋语言创建多个进程，并通过进程句柄控制进程的终止。
在 Linux 系统中，使用 fork(）系统调用创建子进程，并通过 exit(）函数终止进程。
2、进程同步与互斥使用信号量实现进程之间的同步与互斥。
在 Windows 中，利用CreateSemaphore(）和 WaitForSingleObject(）等函数进行操作；在Linux 中，通过 sem_init(）、sem_wait(）和 sem_post(）等函数实现。
（二）内存管理1、内存分配与释放在 Windows 中，使用 HeapAlloc(）和 HeapFree(）函数进行动态内存的分配与释放。
在 Linux 中，使用 malloc(）和 free(）函数完成相同的操作。
2、内存页面置换算法实现了几种常见的内存页面置换算法，如先进先出（FIFO）算法、最近最少使用（LRU）算法等，并比较它们的性能。
（三）文件系统管理1、文件创建与读写在 Windows 和 Linux 系统中，分别使用相应的 API 和系统调用创建文件，并进行读写操作。
2、目录操作实现了目录的创建、删除、遍历等功能。
四、实验步骤（一）进程管理实验1、进程创建与终止（1）在 Windows 系统中，编写 C+＋程序，使用 CreateProcess(）函数创建新进程，并通过 TerminateProcess(）函数终止指定进程。
黑龙江大学“操作系统课程设计”读书工程报告
黑龙江大学“操作系统课程设计”读书工程报告学院软件学院年级2010级专业软件工程学号姓名报告日期2013/7/03成绩黑龙江大学计算机科学技术学院黑龙江大学软件学院一、基本理论阐述1.死锁的概念：系统中多个进程因素因竞争资源而产生的僵死状态，若无外力推动进程将无法继续执行。
2.死锁的根本原因；对资源的竞争；进程推进的顺序不当。
3．死锁产生的必要条件互斥条件在某一段时间里，某资源被一个进程所占有，不能为别的进程使用；请求并保持（不释放）进程每次申请它所需要的一部分资源。
在等待新资源的同时，进程继续占用已分配到的资源；非剥夺条件进程所获得的资源在为使用完之前，不能被其他进程强行夺走，即只能由获得该资源的进程自己来释放；环路条件存在一种进程资源的循环等待链，链中的每一个进程已获得资源的同时被链中下一个进程所请求。
4.死锁的预防①破坏“互斥条件”。
由于资源特性所限，一般情况下这个条件是无法摒弃的，但对于某些互斥共享的设备，如打印机，则可以通过Spooling技术来摒弃互斥条件。
②破坏“请求与保持条件”。
可以采用资源静态分配法，即对资源采用一次性分配策略，但会导致资源利用率的下降。
③破坏“非剥夺条件”。
可以采用剥夺策略，但涉及到对资源现场的恢复问题，需付出高昂代价。
因此，一般只适用于处理机和存储器资源，不适宜对其他资源使用该方法。
④破坏“环路等待条件”。
可以采用资源顺序分配法，但实际情况是：资源编号增加的顺序与实际使用资源的顺序不一致，从而可能导致提早分配资源而导致资源长期不用的现象，使资源利用律下降。
通过精心分配资源，可以动态回避死锁；即通过执行一种算法，在分配过程中预测出死锁发生的可能性并加以避免。
死锁避免算法的实质是防止系统进入不安全状态。
常用的是银行家算法。
但执行这种测试需要的开销较大。
5.进程：是操作系统中最基本、最重要的概念，但直到目前还没有一个统一的定义，下面通过能反映进程实质的几点描述来认识进程：①进程是程序的一次执行；②进程是可以和别的计算并发执行的计算；③进程是程序在一个数据集合上运行的过程，是系统进行资源分配和调度的一个独立单位；④进程是一个具有一定功能的程序关于某个数据集合的一次运行活动。
操作系统课程总结报告
操作系统课程总结报告1. 引言操作系统是计算机科学中的重要课程，它是计算机硬件和应用软件之间的关键桥梁。
通过学习操作系统，我对计算机系统的运作原理有了更深入的了解，并且掌握了操作系统的基本概念和工作原理。
在本篇报告中，我将对这门课程进行总结和回顾。
2. 操作系统的基本概念操作系统是计算机系统中最基本、最核心的部分，它负责管理和控制计算机的硬件资源，提供给用户和应用程序一个简单、一致和高效的接口。
在操作系统课程中，我们学习了以下几个基本概念：2.1 进程管理进程是计算机系统中的基本执行单位，它是指在系统中正在运行的一个程序。
操作系统通过进程管理来管理和调度系统中的各个进程，确保它们能够按照一定的顺序和优先级执行。
我们学习了进程的创建、调度、同步和通信等相关概念和算法。
2.2 内存管理内存管理是操作系统中的重要组成部分，它负责管理计算机系统的物理内存资源，为进程提供足够的内存空间进行执行。
我们学习了内存分配、地址转换和虚拟内存等相关概念和算法。
2.3 文件系统文件系统是操作系统中用于组织和管理文件和目录的一种机制。
它提供了对文件和目录的访问、读写和管理等功能。
我们学习了文件系统的基本组成结构、文件的组织方式和文件的访问方法等相关知识。
3. 课程收获通过学习操作系统课程，我获得了以下几方面的收获：3.1 理论知识操作系统课程使我对计算机系统的各个方面有了更全面的了解。
我对进程管理、内存管理和文件系统等核心概念和算法有了深入的理解。
这些理论知识为我深入研究和学习其他相关领域奠定了坚实的基础。
3.2 实践能力在课程中，我们进行了大量的编程实践和实验操作。
通过这些实践，我锻炼了自己的编程能力和问题解决能力。
我学会了使用各种工具和技术，如C语言编程、调试工具和性能分析器等，来开发和调试操作系统相关的程序和功能。
3.3 团队合作操作系统课程中，我们进行了一些小组项目和实验。
通过与同学们的合作，我学会了团队协作和沟通。
操作系统课程设计个人心得
我认为，在这次课程设计中，不仅培养了独立思考、动手操作的能力，在各种其它能力上也都有了提高。更重要的是，在实验课上，我们学会了很多学习的方法。而这是以后最实用的，真的是受益匪浅。要面对社会的挑战，只有不断的学习、实践，再学习、再实践。这对于我们的将来也有很大的帮助。回顾起此课程设计，至今我仍感慨颇多，从理论到实践，在这段日子里，可以说得是苦多于甜，但是可以学到很多很多的东西，同时不仅可以巩固了以前所学过的知识，而且学到了很多在书本上所没有学到过的知识。通过这次课程设计使我懂得了理论与实际相结合是很重要的，只有理论知识是远远不够的，只有把所学的理论知识与实践相结合起来，从理论中得出结论，才能真正为社会服务，从而提高自己的实际动手能力和独立思考的能力。在设计的过程中遇到问题，可以说得是困难重重，但可喜的是最终都得到了解决。
课程设计心得体会
课程设计题目
读者写着问题
姓名Leabharlann 学号班级组别第二组
专业
网络工程（无线传感方向）
我们这次课程设计的课题是读者写着问题，经过上学期期末的课程设计，我们都有了一定的经验，效率也提高了很多。当我们组拿到题目的时候我们先对题目进行分析，开始我们做了很多工作，比如，到图书馆借相关的资料，到网上搜索等等，最终经过我们组的努力以及老师和同学的帮助下顺利的实现了读者写着功能。
此次设计也让我明白了思路即出路，有什么不懂不明白的地方要及时请教或上网查询，只要认真钻研，动脑思考，动手实践，就没有弄不懂的知识，收获颇丰。
操作系统实训课程学习总结
操作系统实训课程学习总结在操作系统实训课程中，我通过实践学习了操作系统的基本概念、原理和应用。
在这门课程中，我掌握了操作系统的组成结构、进程管理、内存管理和文件系统的相关知识，并通过实际操作和编程练习加深了对这些知识的理解和掌握。
在实践中，我学习了操作系统的启动过程和系统调用的使用方法。
通过编写简单的引导程序和应用程序，我深入了解了操作系统是如何加载到内存并开始运行的，以及操作系统如何通过系统调用提供服务给用户程序。
通过这些实践项目，我对操作系统的启动过程和系统调用有了更加清晰的认识。
在进程管理方面，我学习了进程的概念、进程的状态转换以及进程调度算法。
我掌握了进程的创建、终止和切换的方法，了解了进程并发执行的原理。
通过编写多进程的程序，我深入了解了进程的创建和切换过程，以及进程之间的通信和同步机制。
在内存管理方面，我学习了内存的分配和回收方式、虚拟内存的概念和管理方法。
我了解了操作系统是如何管理和分配内存资源的，以及如何使用虚拟内存扩展实际可用内存。
通过实践项目，我熟悉了内存的分页和分段管理方式，并且能够编写简单的内存管理程序。
在文件系统方面，我学习了文件的组织和存储结构、文件的读写操作和目录管理方法。
我了解了文件系统是如何组织和管理文件的，以及如何使用文件接口进行文件的读写操作。
通过实践项目，我熟悉了文件的打开、关闭和读写操作，并且能够编写简单的文件管理程序。
通过这门实训课程的学习，我不仅掌握了操作系统的基本原理和应用，还提升了实际操作和编程能力。
在实践中，我深入了解了操作系统的各个组成部分的工作原理，并通过编写实际程序加深了对知识的理解。
这门课程为我今后在计算机领域的发展奠定了良好的基础，使我更加熟练和自信地应对各种操作系统相关的问题和挑战。
总结及展望通过操作系统实训课程的学习，我对操作系统的概念、原理和应用有了更深入的理解。
在实践中，我通过编写实际程序和操作系统相关的项目，提升了自己的动手能力和解决问题的能力。
操作系统课程设计总结
操作系统课程设计总结一、背景介绍操作系统是计算机科学中的重要课程之一，是计算机系统中最基本的软件之一。
操作系统课程设计是对操作系统原理和实践的实践性应用，旨在让学生通过设计和实现一个简单的操作系统来深入理解操作系统的原理和机制。
二、设计目标本次操作系统课程设计的目标是设计并实现一个简单的操作系统，包括内存管理、进程管理、文件管理等模块，并能够运行一些基本的应用程序。
具体目标如下：1. 实现内存管理模块，包括内存分配、释放等功能；2. 实现进程管理模块，包括进程创建、销毁等功能；3. 实现文件管理模块，包括文件读写、创建删除等功能；4. 能够运行基本的应用程序，如文本编辑器、计算器等。
三、设计思路1. 内存管理模块：采用分页式内存管理方式，将物理内存划分为大小相等且固定的页框，并将虚拟地址空间划分为大小相等且固定的页面。
通过页表将虚拟地址映射到物理地址上。
2. 进程管理模块：采用多级反馈队列调度算法，根据进程优先级和运行时间分配CPU时间片。
实现进程的创建、销毁和切换等功能。
3. 文件管理模块：采用文件控制块（FCB）的方式管理文件，实现文件的读写、创建删除等功能。
同时实现了目录管理功能，支持目录的创建、删除和查看等操作。
4. 应用程序：实现了文本编辑器和计算器两个基本应用程序，能够在操作系统上运行。
四、设计过程1. 内存管理模块：首先进行内存初始化，将物理内存划分为大小相等的页框，并建立页表。
接着实现内存分配和释放函数，通过修改页表来完成内存分配和释放操作。
2. 进程管理模块：首先定义进程控制块（PCB），包括进程ID、状态、优先级、时间片等信息。
然后实现进程的创建、销毁和切换函数，并根据多级反馈队列调度算法来完成进程调度。
3. 文件管理模块：定义文件控制块（FCB），包括文件名、大小、类型等信息。
然后实现文件读写函数和目录管理函数，通过修改FCB来完成文件读写和目录操作。
4. 应用程序：实现了文本编辑器和计算器两个基本应用程序，文本编辑器支持打开、保存和关闭文本文件；计算器支持加减乘除等基本计算功能。
黑龙江大学“操作系统课程设计”总结报告
“操作系统课程设计”总结报告学期2012-2013学年第2学期软件学院学院学号姓名2013 年7月3日本学期开设了操作系统课程，主要学习了计算机操作系统方面的知识（进程控制、进程调度、请求分页存储管理、设备管理、文件管理），了解了操作系统的相关应用，并通过“操作系统课程设计”实现了一套模拟的单用户多任务操作系统，掌握了操作系统包括进程管理、存储管理、设备管理和文件管理四部分。
更深刻地领会操作系统工作原理和操作系统实现方法，并提高程序设计能力。
以下是课程设计五个设计内容的总结。
一、进程控制1.1目的通过简单的结构和控制方法，完成模拟进程结构、进程状态和进程控制，掌握进程控制的实现。
1.2完成的内容1、用PCB表示整个进程实体，利用随机数方法或键盘控制方法模拟进程执行中产生的事件操作控制进程管理内容。
2、定义PCB：包括理论PCB中的基本内容，如内部ID、外部ID、进程状态、队列指针。
由于无法实现真正的进程创建功能，在实验中只需建立PCB，用它代表完整的进程。
3、定义进程状态转换方式：进程的状态转换是由进程内部操作或操作系统的控制引起，由于无法实现这些功能，采用随机数方法或键盘控制方法模拟，并实现对应的控制程序。
随机方法指产生1－6的随机数，分别代表创建进程(c)、结束进程(e)、进程阻塞(b)、激活进程(w)、调度进程(p)、时间片到(t)等事件；键盘模拟方法指定义6种按键代表以上6种事件。
4、根据事件处理就绪队列、阻塞队列和当前执行进程的状态。
每次事件处理后应形象地显示出当前系统中的执行进程是哪一个，就绪队列和阻塞队列分别包含哪些进程。
1.3主要数据结构void create(){ //新建struct PCB*temp;char name[10];printf("process name:");scanf("%s",name);temp=(struct PCB*)malloc(sizeof(struct PCB));strcpy(temp->name,name);//拷贝temp->next=NULL;add(ready,temp);if(running==NULL){running=removeFirst(ready);}}void interupt(){//中断if(running!=NULL){add(ready,running);running=removeFirst(ready);}}void block(){//阻塞if(running!=NULL){add(blocked,running);running=removeFirst(ready);}}void wakeup(){//唤醒if(blocked->next!=NULL){add(ready,removeFirst(blocked));}if(running==NULL){running=removeFirst(ready);}}void finished(){//终止if(running!=NULL){free(running);running=removeFirst(ready);}}1.4 算法设计及建立三个链表分别表示就绪队列、执行队列、阻塞队列；根据不同的命令对相应的队列进行增删改；1.5 小结（如何实现的？可以以关键部分流程图、主要数据结构、程序整体框架等 内容表示。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
“操作系统课程设计”总结报告学期 2012-2013学年第2学期学院软件学院学号姓名2013 年7月3日本学期开设了操作系统课程，主要学习了计算机操作系统方面的知识（进程控制、进程调度、请求分页存储管理、设备管理、文件管理），了解了操作系统的相关应用，并通过“操作系统课程设计”实现了一套模拟的单用户多任务操作系统，掌握了操作系统包括进程管理、存储管理、设备管理和文件管理四部分。
更深刻地领会操作系统工作原理和操作系统实现方法，并提高程序设计能力。
以下是课程设计五个设计内容的总结。
一、进程控制1.1目的通过简单的结构和控制方法，完成模拟进程结构、进程状态和进程控制，掌握进程控制的实现。
1.2完成的内容1、用PCB表示整个进程实体，利用随机数方法或键盘控制方法模拟进程执行中产生的事件操作控制进程管理内容。
2、定义PCB：包括理论PCB中的基本内容，如内部ID、外部ID、进程状态、队列指针。
由于无法实现真正的进程创建功能，在实验中只需建立PCB，用它代表完整的进程。
3、定义进程状态转换方式：进程的状态转换是由进程内部操作或操作系统的控制引起，由于无法实现这些功能，采用随机数方法或键盘控制方法模拟，并实现对应的控制程序。
随机方法指产生1－6的随机数，分别代表创建进程(c)、结束进程(e)、进程阻塞(b)、激活进程(w)、调度进程(p)、时间片到(t)等事件；键盘模拟方法指定义6种按键代表以上6种事件。
4、根据事件处理就绪队列、阻塞队列和当前执行进程的状态。
每次事件处理后应形象地显示出当前系统中的执行进程是哪一个，就绪队列和阻塞队列分别包含哪些进程。
1.3主要数据结构void create(){ //新建struct PCB *temp;char name[10];printf("process name:");scanf("%s",name);temp=(struct PCB *)malloc(sizeof(struct PCB));strcpy(temp->name,name); //拷贝temp->next=NULL;add(ready,temp);if(running==NULL){running=removeFirst(ready);}}void interupt(){//中断if(running!=NULL){add(ready,running);running=removeFirst(ready);}}void block(){//阻塞if(running!=NULL){add(blocked,running);running=removeFirst(ready);}}void wakeup(){//唤醒if(blocked->next!=NULL){add(ready,removeFirst(blocked));}if(running==NULL){running=removeFirst(ready);}}void finished(){//终止if(running!=NULL){free(running);running=removeFirst(ready);}}1.4建立三个链表分别表示就绪队列、执行队列、阻塞队列；根据不同的命令对相应的队列进行增删改；1.5小结（如何实现的？可以以关键部分流程图、主要数据结构、程序整体框架等内容表示。
）二、请求分页存储器管理2.1目的通过在第1部分实验基础上实现进程的分页式内存分配和地址转换过程，完成请求分页式存储分配和地址转换过程，掌握页面置换算法:先进先出（FIFO）、最近最久未使用（LRU）等算法。
2.2完成的内容1、建立一个位示图，用来模拟内存的分配情况，位示图的位数与设定的物理块个数相同。
程序启动时可利用一组随机0和1填充位示图，表示内存已被占用情况。
2、创建进程时输入进程大小，并根据程序中设定的物理块大小为进程分配物理块，同时建立页表。
3、输入当前执行进程所要访问的逻辑地址，并将其转换成相应的物理地址。
4、进程退出时，根据其页表内容向位示图反向回填“1”。
5、扩充页表，将其变成支持请求和置换功能的二维页表（增加存在位等）。
创建进程时可装入固定的前三页（或键盘输入初始装入页数，不同进程的装入个数可以不同），其余页装入到置换空间内。
6、分别采用FIFO和LRU置换算法对地址转换过程中遇到的缺页现象进行页面置换，可将多次地址转换过程中所涉及到的页号视为进程的页面访问序列，从而计算置换次数和缺页率.2.3主要数据结构struct page_table_item{int pagenum;int blocknum;int exist; //存在位int modify; //修改位int swap_add;};2.4算法设计及流程图void terminate(){int i,j,p,q;if(running==NULL){printf("已结束所有进程!!!");}if(running!=NULL){j=ceil(running->size,PAGE_SIZE);if(j>3){for(i=0;i<3;i++){//printf("aaaaa\n");p=(*(running->pagetable+i)).blocknum/8;q=(*(running->pagetable+i)).blocknum%8;//printf("%d",p);setbit(&bitmap[p],q,0);}for(i=3;i<j;i++){//printf("bbbb\n");p=(*(running->pagetable+i)).blocknum/8;q=(*(running->pagetable+i)).blocknum%8; // printf("%d %d\n",p,q);//printf("%d",p);setbit(&changemap[p],q,0);}}else{for(i=0;i<j;i++){p=(*(running->pagetable+i)).blocknum/8;q=(*(running->pagetable+i)).blocknum%8;setbit(&bitmap[p],q,0);}}free(running);}if(ready!=NULL){running=removeFirst(ready);}}void translate(){//逻辑地址转换成物理地址if(running==NULL){printf("没有执行进程");}else{int logical;int pagenum,offset;int blocknum;printf("请输入逻辑地址:\n");scanf("%d",&logical);pagenum=(int)(logical/PAGE_SIZE);offset=logical%PAGE_SIZE;blocknum=(running->pagetable+pagenum)->blocknum;//blocknum=*(running->pagetable+pagenum);printf("物理地址:%d",blocknum*PAGE_SIZE+offset);printf("\n");}//blockno=*(running->pagetable + pageno);}void dispagetable()//显示执行进程页表{int i;if(running==NULL){ printf("没有执行进程");return;}for(i=0;i<ceil(running->size,BLOCK_SIZE);i++)printf(" %d %d %d %d %d \n",(*(running->pagetable+i)).pagenum,(*(running->pagetable+i)).bloc knum,(*(running->pagetable+i)).exist,(*(running->pagetable+i)).modif y,(*(running->pagetable+i)).swap_add);}2.5小结三、设备管理3.1目的通过在前面的实验基础上,完成设备管理功能的模拟，掌握包括通道和控制器的添加和删除，设备的添加、删除，设备的分配和回收。
3.2完成的内容1、设备管理子系统涉及到系统设备表（SDT）、通道控制表（CHCT）、控制器控制表（COCT）和设备控制表（DCT）来体现输入输出系统的四级结构和三级控制。
2、实现上述设备、控制器以及通道的层次关系，同时能够添加或删除新的设备、控制器或通道。
3、通过键盘命令模拟进程执行过程中提出的设备分配或释放请求，并为此请求分配或释放设备。
分配设备成功后可将进程状态调整为阻塞，释放设备后变为就绪状态。
4、分配设备时应如果该设备已被其它进程占用，则设备分配失败，请求进程进入阻塞状态，同时等待该设备的释放。
如果设备空闲，进程占用设备的同时还应提出申请控制器请求，直到与设备相关的通道都已申请成功为止。
5、设备、控制器或通道的释放应引起对应节点的等待队列中的第一个阻塞进程被唤醒。
如果被唤醒的进程还未完成申请操作，应继续执行上级节点的申请操作。
3.3主要数据结构struct Node *DCTs,*COCTs,*CHCTs;//添加头结点，设备，控制器，通道struct Node *addNode(char *name,struct Node *parent,struct Node *head){//在以head为头结点队列中添加名为name的节点struct Node *tmp=head;//查找最末位节点while(tmp->next!=NULL)tmp=tmp->next;tmp->next=(struct Node *)malloc(sizeof(struct Node));strcpy(tmp->next->name,name);tmp->next->next=NULL;tmp->next->parent=parent;tmp->next->process=NULL;tmp->next->ready=(struct PCB *)malloc(sizeof(struct PCB));tmp->next->ready->next=NULL;return tmp->next;}3.4算法设计及流程图int get_child_count(struct Node *node,struct Node *childs_head){//获取一个节点的所有子节点int count=0;struct Node *tmp=childs_head->next;while(tmp!=NULL){if(tmp->parent==node)count++;tmp=tmp->next;}return count;}struct Node *findByName(char *name,struct Node *head){ struct Node *tmp=head->next;while(tmp!=NULL){if(strcmp(tmp->name,name)==0)//比较当前节点，相等就返回这个节点，否则查看下一个节点return tmp;tmp=tmp->next;}printf("%cError:can't find %s!\n",BEEP,name);//名为name的节点未找到return NULL;}void removeNode(char *name,struct Node *head){struct Node *tmp1=head;struct Node *tmp2=head->next;while(tmp2!=NULL){//节点实际存在if(strcmp(tmp2->name,name)==0){//比较if(tmp2->process==NULL && tmp2->ready->next==NULL){tmp1->next=tmp2->next;free(tmp2);}elseprintf("%cError:can't remove %s!\n",BEEP,name);return;}tmp1=tmp2;tmp2=tmp2->next;}printf("%cError:can't find %s!\n",BEEP,name);}//struct Node *addNode(char *name,struct Node *parent,struct Node *queue)/*void remove Node(char *name,struct Node*queue){}*/void add_devices(){//添加设备int i;char name[10],parent[10];while(1){printf("1:add device\n");//设备printf("2:add controller\n");//控制器printf("3:add channel\n");//通道printf("0:return\n");//返回主程序scanf("%d",&i);//i变量读菜单if(i!=0){printf("name:");scanf("%s",name);}if(i==1 || i==2){printf("parent name:");scanf("%s",parent);}switch(i){case 1:addNode(name,findByName(parent,COCTs),DCTs);//所添加的设备名在name里，通过parent名在COCT队列中找到父节点，之后以这个节点，这个名称为参数在DCT队列中添加一个新结点break;case 2:addNode(name,findByName(parent,CHCTs),COCTs);break;case 3:addNode(name,NULL,CHCTs);//通道没有父节点break;case 0:return ;}}}void remove_devices(){int i;char name[10];struct Node *tmp;while(1){printf("1:remove device\n");printf("2:remove controller\n");printf("3:remove channel\n");printf("0:return\n");scanf("%d",&i);if(i!=0){printf("name:");scanf("%s",name);}switch(i){case 1:removeNode(name,DCTs);break;case 2:tmp=findByName(name,COCTs);if(tmp==NULL)printf("%cError:can't find %s!\n",BEEP,name);else if(get_child_count(tmp,DCTs)>0) //子节点个数printf("%cError:can't remove %s!\n",BEEP,name);elseremoveNode(name,COCTs);break;case 3:tmp=findByName(name,CHCTs);if(tmp==NULL)printf("%cError:can't find %s!\n",BEEP,name);else if(get_child_count(tmp,COCTs)>0)printf("%cError:can't remove %s!\n",BEEP,name);elseremoveNode(name,CHCTs);break;case 0:return;}}}void allocate_channel(struct Node *node,struct PCB *p){if(p==NULL)return;if(node->process==NULL){node->process=p;block(blocked,p);}elseblock(node->ready,p);}void allocate_controller(struct Node *node,struct PCB *p){ if(p==NULL)return;if(node->process==NULL){node->process=p;allocate_channel(node->parent,p);}elseblock(node->ready,p);}void allocate_device(struct Node *node,struct PCB *p){if(p==NULL)return;if(node->process==NULL){node->process=p;allocate_controller(node->parent,p);}elseblock(node->ready,p);}void allocate(){char name[10];struct Node *node;if(running==NULL)return;printf("device name:");scanf("%s",name);node=findByName(name,DCTs);if(node==NULL){printf("Can't find %s!\n",name);return;}allocate_device(node,running);}void release_channel(struct Node *node,struct PCB *p){ if(node->process==p){node->process=NULL;allocate_channel(node,removeFirst(node->ready));add(ready,remove_process(blocked,p));if(running==NULL)running=removeFirst(ready);}else{add(ready,remove_process(node->ready,p));if(running==NULL)running=removeFirst(ready);}}void release_controller(struct Node *node,struct PCB *p){if(node->process==p){node->process=NULL;allocate_controller(node,removeFirst(node->ready));release_channel(node->parent,p);}else{add(ready,remove_process(node->ready,p));if(running==NULL)running=removeFirst(ready);}}void release(){char name[10];struct Node *node;struct PCB *p;printf("device name:");scanf("%s",name);node=findByName(name,DCTs);if(node==NULL || node->process==NULL)return;p=node->process;node->process=NULL;allocate_device(node,removeFirst(node->ready));release_controller(node->parent,p);}void display_process_status(struct Node *node){//显示节点的占用进程以及等待进程信息struct PCB *p=node->ready->next;if(node->process!=NULL)printf("<--%s",node->process->name);while(p!=NULL){printf("<--%s",p->name);p=p->next;}printf("\n");}void display_status(){//显示设备状态struct Node *chct=CHCTs->next,*coct,*dct;while(chct!=NULL){printf("%s",chct->name);display_process_status(chct);coct=COCTs->next;while(coct!=NULL){if(coct->parent==chct){printf("\t%s",coct->name);display_process_status(coct);dct=DCTs->next;while(dct!=NULL){if(dct->parent==coct){printf("\t\t%s",dct->name);display_process_status(dct);}dct=dct->next;}}coct=coct->next;}chct=chct->next;}}3.5小结四、文件管理4.1目的通过利用磁盘文件，完成操作系统的文件管理功能，掌握包括目录结构的管理、外存空间的分配与释放以及空闲空间管理三部分。