操作系统心得体会（精选多篇）

推荐第1篇：操作系统心得体会

转眼间，学习了一个学期的计算机操作系统课程即将结束。在这个学期中，通过老师的悉心教导，让我深切地体会到了计算机操作系统的一些原理和具体操作过程。在学习操作系统之前，我只是很肤浅地认为操作系统只是单纯地讲一些关于计算机方面的操作应用，并不了解其中的具体操作过程和实用性。通过这一学期的学习，我才知道操作系统(Operating System，简称OS)是管理计算机系统的全部硬件资源包括软件资源及数据资源；控制程序运行；改善人机界面；为其它应用软件提供支持等，使计算机系统所有资源最大限度地发挥作用，为用户提供方便的、有效的、友善的服务界面。

经过一个学期的学习，我也知道了计算机操作系统是铺设在计算机硬件上的多层系统软件，不仅增强了系统的功能，而且还隐藏了对硬件操作的细节，由它实现了对计算机硬件操作的多层次的抽象。操作系统的一些原理在生活中也有所应用，以下是我通过这一学期的学习，把操作系统的一些原理联系生活所得的心得体会：

操作系统是管理计算机系统的全部硬件资源包括软件资源及数据资源；控制程序运行；改善人机界面；为其它应用软件提供支持等，使计算机系统所有资源最大限度地发挥作用，为用户提供方便的、有效的、友善的服务界面。计算机操作系统是铺设在计算机硬件上的多层系统软件，不仅增强了系统的功能，而且还隐藏了对硬件操作的细节，由它实现了对计算机硬件操作的抽象。操作系统的一些原理在生活中的应用主要有以下几个，结合生活中的例子，可以化抽象为具体，我们会更加清楚地了解到其原理与操作过程：

1.生产—消费者问题

在实际的操作系统操作过程中，经常会碰到如下场景：某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。

单单抽象出生产者和消费者，还够不上是生产者—消费者问题。该问题还需要有一个缓冲区处于生产者和消费者之间，作为一个中介。生产者把数据放入缓冲区，而消费者从缓冲区取出数据。

为了理解这一问题，我们举一个寄信的例子。假设你要寄一封平信，大致过程如下：

1、你把信写好——相当于生产者制造数据

2、你把信放入邮筒——相当于生产者把数据放入缓冲区

3、邮递员把信从邮筒取出——相当于消费者把数据取出缓冲区

4、邮递员把信拿去邮局做相应的处理——相当于消费者处理数据

2、银行家算法——避免死锁 死锁的产生是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。由于资源占用是互斥的，当某个进程提出申请资源后，使得有关进程在无外力协助下，永远分配不到必需的资源而无法继续运行，这就产生了一种特殊现象死锁。我觉得操作系统所讲的死锁就好像两个人竟过独木桥，两辆车竟过单行桥等阻塞现象，原因是共享资源，即道路。

为提高系统资源的利用率，避免死锁并不严格限制死锁必要条件的存在，而是在资源的动态分配过程中，使用某种方法去防止系统进入不安全状态，从而避免死锁的最终出现。然而，最有代表性的避免死锁的算法，是Dijkstra的银行家算法。在该方法中把系统的状态分为安全状态和不安全状态，只要能使系统始终都处于安全状态，便可以避免发生死锁。银行家算法的基本思想是分配资源之前，判断系统是否是安全的；若是安全的，才分配。

我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。为保证资金的安全,银行家规定：

（1）当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客；

（2）顾客可以分期贷款,但贷款的总数不能超过最大需求量；

（3）当银行家现有的资金不能满足顾客尚需的贷款数额时，对顾客的贷款可推迟支付，但总能使顾客在有限的时间里得到贷款；

（4）当顾客得到所需的全部资金后，一定能在有限的时间里归还所有的资金。

另外，我们也可以把操作系统看作是建造房子，操作系统的资源看作是造房子的起吊机台数，进程向操作系统请求分配资源相当于建造房子时申请的起吊机台数。为保证工程的顺利进行，其操作过程如下：

当一栋房子对起吊机的最大需求量不超过建造房子现有的起吊机时可接纳该房子的建造；

所要建造的房子可以分开几次申请起吊机，但申请的起吊机的总数不能超过最大需求量；

当现有的起吊机台数不能满足某栋房子尚需的起吊机时，对该栋房子所需的起吊机数可推迟给予，但总能是房子在有限的时间里得到贷款； 当建造的房子得到所需的全部起吊机后，一定能在有限的时间里归还所有的起吊机数。

3.进程同步问题

一个进程到达了确定的点后，除非另一些进程已经完成了某些操作，否则不得不停下来等待另一进程为它提供的消息，早未获得消息前，该进程处于等待状态，获得消息后被唤醒处于就绪状态，这就是进程同步。我们在生活中也可以找到相应的例子：

例如汽车司机和售票员，汽车司机负责开车、进站、开车门、关车门与进站；

售票员负责售票、进出站后观察车门，给司机发开关门信息；正常状态下，各自活动，司机开车，售票员售票；在进出站时双方要进行进程同步。

为了理解这一问题，我们举一个寄信的例子。假设你要寄一封平信，大致过程如下：

1、你把信写好——相当于生产者制造数据

2、你把信放入邮筒——相当于生产者把数据放入缓冲区

3、邮递员把信从邮筒取出——相当于消费者把数据取出缓冲区

4、邮递员把信拿去邮局做相应的处理——相当于消费者处理数据

操作系统知识点看似繁杂,但究其原理,在对不同系统资源功能进行管理时,所采取的策略和方法有很多是相同的。从操作系统四种重要实现技术出发的横向技术线包括中断技术、共享技术、虚拟技术和缓冲技术。

(1)中断技术模块是实现程序并发执行与设备并行操作的基础,它包括中断类型、中断优先级、中断事件各知识单元。中断类型知识单

元包括外中断、内中断知识点;中断优先级知识点在不同的系统中有不同的规定;中断事件知识单元包括进程创建与撤消、进程阻塞与唤醒、分时时间片、缺页中断与缺段中断、I/O操作、文件操作各知识点。

(2)共享技术模块是提高资源利用率的必然途径,它包括处理机共享、存储共享、设备共享、文件共享各知识单元。处理机共享包含进程的并发执行;存储共享包含外存储器共享、内存储器共享知识点;设备共享包含SPOOLing系统;文件共享包含便于共享的文件目录。 (3)虚拟技术模块是把一个物理实体变为若干面向用户的逻辑单元,使资源的用户使用与系统管理相分离,从而提高资源利用率和安全性方,它包括虚拟处理机、虚拟存储器、虚拟存储器方法、虚拟设备、虚拟文件各知识单元。虚拟处理机包含多进程管理;虚拟存储器包含地址转换、中断处理过程、置换知识点;虚拟存储器方法包含页式管理、段式管理、段页式管理各知识点;虚拟设备包含设备共享;虚拟文件包含文件共享。

(4)缓冲技术模块是异步技术的实现前提,可大大提高相关资源的并行操作程度,它包括存储管理缓冲技术、设备管理缓冲技术、文件管理缓冲技术各知识单元。存储管理缓冲技术包含快表;设备管理缓冲技术包含硬缓冲、软缓冲、SPOOLing系统中的输入/输出井知识点;文件管理缓冲技术包含记录成组技术、文件表的打开。

操作系统这门课程并不是教你如何使用操作系统的，而是讲操作。总而言之，操作系统的一些原理在生活中都可以找到相应的例子。结合生活中的例子，可以化抽象为具体，我们会更加清楚地了解到其原理与操作过程。我觉得通过我们的不断学习，结合生活中的实际问题，我们就会把操作系统学得更好。总体来说，通过这次的对操作系统的总结，有收获也有遗憾、不足的地方，但我想，我已经迈入了操作系统的大门，只要我再认真努力的去学习，去提高，凭借我对网页设计的热情和执着，我将来设计出的网页会更加专业，更完善。

感谢老师在百忙中阅卷，也感恩老师这学期以来对我的照顾，在老师的深刻讲授下让操作系统这门十分枯燥和难理解的学科变得生动有趣。祝愿老师早日职称晋升，立项通过，身体健康，阖家欢乐。谢谢老师！

操作系统C

开放性考核

工学院

自动化系14级11班

14032316

李大鹏

指导教师

张博

推荐第2篇：操作系统心得体会

操作系统心得体会

电脑使用一段时间后机箱里会存积大量的灰尘，这些灰尘会影响硬件的散热，尤其会影响cpu的散热。具体的表现是主机工作时噪声变大，经常出现操作反映迟缓等现象（有时候病毒、木马和垃圾文件过多也是此现象，所以要具体情况具体对待）。那么多长时间清扫一次合适呢？这要看你的机器所处的环境的浮尘量了，一般在自己家里一个季度到半年清扫一次就可以了（新买的电脑建议在过了保修期以后再清扫，因为一旦打开机箱即保修自动终止），因为对于新手来说过于频繁的清扫反而会增大硬件意外损坏的风险。清扫时将机箱盖打开，用软毛刷子轻轻扫去附着在主板各硬件表面的灰尘，然后将cpu风扇拆下（散热片不要从主板上拆下来），仔细扫去风扇叶片和散热片缝隙里的灰尘。然后拔掉内存，将内存插槽和内存条上的触点用潮湿的软布轻轻的擦干净。最后将所有部件装回原位就可以了。 [操作系统维护] 关于操作系统的维护网上有很多这方面的内容，我这里就不过多的介绍了。不过我要说一下我自己的一些经验。

1、对于新手要尽量安装一键还原工具。一些品牌机都会带有一键还原工具，如果是组装的机器或是没有预装操作系统的品牌机，都是没有此类软件的，建议你在安装完操作系统后的第一时间安装这些软件并备份系统盘。

2、重装或更换操作系统前把一键还原工具卸载掉。因为这些软件很多都会保护引导区（mbr），所以在安装了这类软件后无法完成系统的重装。（所以我现在是不用一键还原的）

3、不要把我的文档放在系统盘。因为在我的文档中往往会保存一些比较大的文件，如果在系统盘，会占用本来就有限的系统盘空间，而且在一键还原或重装系统后系统盘的数据会被全部重写，原来的文件都将不复存在。

4、整理c盘的碎片时切忌不要让电脑做任何事情。这一点我深有体会，我曾经因为在整理碎片时浏览网页而导致系统崩溃。

5、尽量安装功能多的软件。这样可以减少系统中软件的数量，从而节省磁盘空间，但也不要过于求大求全，够用即可。

6、对于有经验的人来说可以关闭自动更新和系统还原，这样可以让系统运行更顺畅。

7、软件能用原版就用原版。很多软件都有破解版、汉化版、简化版、增强版等版本，这些版本很多都存在问题，有的还有病毒，所以软件还是原版好。

8、系统优化要慎重。我曾经因优化后系统不能正常工作而重装。

9、卸载软件后要及时删除其安装目录。很多软件在卸载后会在其安装目录里保留一些文件，虽然一般都不是很大，但系统用的时间长了难免会留下大量这类垃圾文件。所以在卸载完一个软件后要查看其安装目录是否依然存在，如果存在就将其删除，无法删除的可以在安全模式下删除。

10、尽量避免强行终止进程。这样可以减少垃圾文件的产生，有时候被强行终止后的程序还会工作不正常，甚至彻底不能用了。 操作系统心得体会（2）：

对于此次课程设计，我早在寒假就借了linux相关书籍参看，但上面讲的主要是有关linux操作方面的内容，编程方面讲得很少，而且在假期中也并不知道课设的题目是什么，因此此次课设基本上都是在开学后的这两周内完成的。

以前做过的软件方面的课设如c语言课设、数据结构课设都是在假期完成的，由于自己是一个十分追求完美的人，因此几乎每次都花了将近大半个假期的时间来做，如c语言就花了一个多月的时间来做，分数当然也较高，有90来分。对于课程设计，我历来都是相当认真的，此次操作系统的课程设计当然也不例外。可是linux以前没怎么接触过，学校也没怎么系统地讲过，在刚接到题目时除了知道如何用gcc编译等等，几乎可以算作处于一无所知的状态。时间紧任务重，要从对linux一无所知的状态到独立出色地完成课设，不下点苦功夫是不成的。那两周里我除了吃饭睡觉几乎就没离开电脑过，有时时间晚了食堂关门饭都没得吃了。终于，在这样近乎玩命地学习工作下，身体撑不住了，在第二周周三晚上我发烧了。但是眼看就要到检查的日期了，而我的课设也就快完工了。我不想因为看病而耽误下去弄得前功尽弃，因此只买了点药，继续在电脑前拼命&&最后，总算赶在周五检查前做出了较满意的作品。然而这几天一直高烧不退，周五回家（武汉）后就直接倒床昏睡过去，周六早上一量居然还有39°。于是赶紧去附近一家医院看病，连打了两天吊针才算好转过来。而看病用的几百块钱由于不是在校医院看的也无法报销，只好自掏腰包了。

在周五检查那天，老师看了我第4题后，又抽查了一下我的第3题，其实也只是要我把第3题运行一下而已罢了。若放在平时，这绝对是小菜一碟，但当时正在发烧，加上一点紧张，居然把模块加载命令insmod fdev.o错打成insmod fdev.c了，由于这个低级失误造成心中慌乱，于是后面的一条生成设备文件命令mknod干脆就照着参考资料打上去了。于是老师认为我不熟，在那题上打了个半钩。当时心里确实感到十分地遗憾和沮丧，心想所谓台上一分钟，台下十年功，一分钟若把握不好，也同样尽毁十年功啊！

但最后，我终于明白，分数不过是个数字，知识才是自己的。通过这次课程设计，我确实学到了很多东西，多年后我可能已经忘记这次课设最后打了多少分，但这些学到的东西却可以使我受益终生。除了知识技术上的东西，我更锻炼了自己的快速学习能力；我学会了如何快速有效地从图书馆、网络获取自己需要的信息；我尝到了在周围很多同学拷来拷去时孤军奋战的痛苦；我体会了夜以继日完成一个项目时中途过程的艰辛及最终完成后巨大的成就感&&我更加深了人生的信心，以后面对任何一个困难的项目，我想我都不会惧怕，并最终能够成功地将其完成。 感谢老师，感谢此次课程设计。虽然在其中吃了不少苦头，但我毫不后悔，因为我满载而归。

推荐第3篇：操作系统心得体会

操作系统心得体会

1925319 周浩

参考文献：Eric S.Raymond。《UNIX编程艺术》电子工业出版社 712102116

学习C语言是我第一次接触编程，也是如此近距离的接触计算机内部运行的原理，可能是在学习C的过程中没有遇到困难吧，我对编程产生了浓厚的兴趣，在这之后又学习了C++， 学习C++主要是使用C++之父（B S 单词忘了）写的那本《C++程序设计语言》，700多页的书中有一句话我记得特别清楚，他说语言就是一种思维方式，C是过程的思维，C++是面向对象的思维，读另一位高手（名字首字母是 S与 B 也忘了）写的《C++编程技术》一书时也有一句话让我印象深刻——去编程就是去理解，虽然我只学了C，C++（还有VC MFC 自我感觉他们不是，是一种C++的变体）但我感觉语言只需要记得地址，然后去骗骗编译器， 最重要的是对需要解决的问题的数学化，剩下的就是多实际操作，过程的积累是很重要的， 因为在操作的过程中可以加深对很多方面的理解，学编译器，那是大二下花了大概三个星期把清华出版的编译原理研究了下，是学习计算机以来觉得障碍最大的一门专业课，武功只算练了一半，编译的后期没怎么学（中间代码生成以后的东西），不过最近把PL/0放在机器上实际运行了后，我找到了一种感觉要理解语法分析词法分析要从计算机的角度去理解，顺序， 分支，循环，我还没有认真的去思考之间的关系，最近在忙着另外的事，这种感觉已经帮助解决了很多问题，剩下的就是多做些事去实际操作，加深理解，如果问题简化到只是时间问题了就不是问题了，我喜欢这样对自己说。

前面讲了很多与操作系统无关的体会好像有凑字的嫌疑，不要误会我在强调一种感觉，说不出来，但却很有用，这是一种理解，唯有理解才能分出高下，我用4，5个晚上我操作系统的书浏览到了系统安全，操作系统是一种程序，有着更高的特权级别，功能是提供服务与管理一些硬件的资源，存储器管理，处理机管理，文件管理，设备管理，我觉得这些问题大多数都可归结为数据结构，用数据结构的角度去解决应当不难，但是在用户程序与系统本身之间的切换方面总是感觉有些问题想不清楚，找不到我一直强调的那种会让问题变得简单的高深理解，我还需要时间去理解，我想听听老师对这方面的认识，说些高度概括的词让我思考 如何去理解这件事

UNIX操作系统的历史已经成为了一种传奇，但是我对它的历史不感兴趣，我对那些天才们的思维很感兴趣，是计算机领域宝贵财产，有时间我会去看，还有对无数人日日夜夜不辞辛苦的付出很是钦佩，我会向他们学习，对还有一件事印象深刻

UNIX在初期主要是用于DEC的机器，尽管没有正规的技术支持，但仗着灵活、快捷、容易修改和扩充以及资源丰富（包括支持的硬件设备更丰富，DEC的操作系统只支持自己的系列产品）的强大优势，很快就严重影响到DEC自身的软件推广。碰上这样的飞来横祸，DEC当然是非常恼火，他们对使用UNIX而带来的硬件问题拒不提供支持，但尽管如此也不能阻挡大家对UNX的热情。而VAX/VMS乃是DEC寄予厚望的战略级产品，技术那是相当的优秀，居然甫一推出，就又遭到UNIX的追杀，也难怪老板Olsen会口出恶言，讥讽UNIX是“蛇油”（意为“骗人的万用药”）了。DEC苦撑了几年之后，终于不支，改变态度，于1982年推出了自己的UNIX变种——DEC ULTRIX，但在推广策略上，仍是以自家的VMS为主导。DEC公司的保守作风终于酿成大祸，在别的公司推出专门针对UNIX设计的机器后，DEC的江湖地位每旷愈下，在PC问世后，更是一蹶不振，后来连年亏损，1992年把Olsen赶下台也没解决问题，终于在1998年，这个曾经的传奇——一度排名世界第二的计算机公司被后起之秀COMPAQ并购，不过96亿美元的天价也算是对它价值的承认。

DEC有他自己的想法不可否人，不过坚持有时会成为一种负担，如果用一种变通的方法

借UNIX的力量的话也许历史又会是另一种结果，这个问题我也得思考，发现自己就像是多线程处理器，有很多的事，但每件事都还没return

希望早日找到感觉，剩下的就是经验的积累，时间的付出，那就是我说的那句话了如果问题简化到只是时间问题了就不是问题了，简单

推荐第4篇：操作系统心得体会

电脑使用一段时间后机箱里会存积大量的灰尘，这些灰尘会影响硬件的散热，尤其会影响cpu的散热。具体的表现是主机工作时噪声变大，经常出现操作反映迟缓等现象（有时候病毒、木马和垃圾文件过多也是此现象，所以要具体情况具体对待）。那么多长时间清扫一次合适呢？这要看你的机器所处的环境的浮尘量了，一般在自己家里一个季度到半年清扫一次就可以了（新买的电脑建议在过了保修期以后再清扫，因为一旦打开机箱即保修自动终止），因为对于新手来说过于频繁的清扫反而会增大硬件意外损坏的风险。清扫时将机箱盖打开，用软毛刷子轻轻扫去附着在主板各硬件表面的灰尘，然后将cpu风扇拆下（散热片不要从主板上拆下来），仔细扫去风扇叶片和散热片缝隙里的灰尘。然后拔掉内存，将内存插槽和内存条上的触点用潮湿的软布轻轻的擦干净。最后将所有部件装回原位就可以了。

[操作系统维护]

关于操作系统的维护网上有很多这方面的内容，我这里就不过多的介绍了。不过我要说一下我自己的一些经验。

1、对于新手要尽量安装一键还原工具。一些品牌机都会带有一键还原工具，如果是组装的机器或是没有预装操作系统的品牌机，都是没有此类软件的，建议你在安装完操作系统后的第一时间安装这些软件并备份系统盘。

2、重装或更换操作系统前把一键还原工具卸载掉。因为这些软件很多都会保护引导区（mbr），所以在安装了这类软件后无法完成系统的重装。（所以我现在是不用一键还原的）

3、不要把“我的文档”放在系统盘。因为在“我的文档”中往往会保存一些比较大的文件，如果在系统盘，会占用本来就有限的系统盘空间，而且在一键还原或重装系统后系统盘的数据会被全部重写，原来的文件都将不复存在。

4、整理c盘的碎片时切忌不要让电脑做任何事情。这一点我深有体会，我曾经因为在整理碎片时浏览网页而导致系统崩溃。

5、尽量安装功能多的软件。这样可以减少系统中软件的数量，从而节省磁盘空间，但也不要过于求大求全，够用即可。

6、对于有经验的人来说可以关闭自动更新和系统还原，这样可以让系统运行更顺畅。

7、软件能用原版就用原版。很多软件都有破解版、汉化版、简化版、增强版等版本，这些版本很多都存在问题，有的还有病毒，所以软件还是原版好。

8、系统优化要慎重。我曾经因优化后系统不能正常工作而重装。

9、卸载软件后要及时删除其安装目录。很多软件在卸载后会在其安装目录里保留一些文件，虽然一般都不是很大，但系统用的时间长了难免会留下大量这类垃圾文件。所以在卸载完一个软件后要查看其安装目录是否依然存在，如果存在就将其删除，无法删除的可以在安全模式下删除。

10、尽量避免强行终止进程。这样可以减少垃圾文件的产生，有时候被强行终止后的程序还会工作不正常，甚至彻底不能用了。

操作系统心得体会（2）：

对于此次课程设计，我早在寒假就借了linux相关书籍参看，但上面讲的主要是有关linux操作方面的内容，编程方面讲得很少，而且在假期中也并不知道课设的题目是什么，因此此次课设基本上都是在开学后的这两周内完成的。

以前做过的软件方面的课设如c语言课设、数据结构课设都是在假期完成的，由于自己是一个十分追求完美的人，因此几乎每次都花了将近大半个假期的时间来做，如c语言就花了一个多月的时间来做，分数当然也较高，有90来分。对于课程设计，我历来都是相当认真的，此次操作系统的课程设计当然也不例外。可是linux以前没怎么接触过，学校也没怎么系统地讲过，在刚接到题目时除了知道如何用gcc编译等等，几乎可以算作处于一无所知的状态。时间紧任务重，要从对linux一无所知的状态到独立出色地完成课设，不下点苦功夫是不成的。那两周里我除了吃饭睡觉几乎就没离开电脑过，有时时间晚了食堂关门饭都没得吃了。终于，在这样近乎玩命地学习工作下，身体撑不住了，在第二周周三晚上我发烧了。但是眼看就要到检查的日期了，而我的课设也就快完工了。我不想因为看病而耽误下去弄得前功尽弃，因此只买了点药，继续在电脑前拼命……最后，总算赶在周五检查前做出了较满意的作品。然而这几天一直高烧不退，周五回家（武汉）后就直接倒床昏睡过去，周六早上一量居然还有39°。于是赶紧去附近一家医院看病，连打了两天吊针才算好转过来。而看病用的几百块钱由于不是在校医院看的也无法报销，只好自掏腰包了。

推荐第5篇：学习操作系统心得体会

学习操作系统心得体会

计算机操作系统是铺设在计算机硬件上的多层系统软件，不仅增强了系统的功能，而且还隐藏了对硬件操作的细节，由它实现了对计

算机硬件操作的抽象。

操作系统是管理计算机系统的全部硬件资源包括软件资源及数据资源；控制程序运行；改善人机界面；为其它应用软件提供支持等，使计算机系统所有资源最大限度地发挥作用，为用户提供方便的、有效的、友善的服务界面。

操作系统的一些原理在生活中的应用主要有以下几个，结合生活中的例子，可以化抽象为具体，我们会更加清楚地了解到其原理与操作过程：

1、银行家算法——避免死锁

死锁的产生是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。由于资源占用是互斥的，当某个进程提出申请资源后，使得有关进程在无外力协助下，永远分配不到必需的资源而无法继续运行，这就产生了一种特殊现象死锁。我觉得操作系统所讲的死锁就好像两个人竟过独木桥，两辆车竟过单行桥等阻塞现象，原因是共享资源，即道路。

为提高系统资源的利用率，避免死锁并不严格限制死锁必要条件的存在，而是在资源的动态分配过程中，使用某种方法去防止系统进入不安全状态，从而避免死锁的最终出现。然而，最有代表性的避免死锁的算法，是Dijkstra的银行家算法。在该方法中把系统的状态分为安全状态和不安全状态，只要能使系统始终都处于安全状态，便可以避免发生死锁。银行家算法的基本思想是分配资源之前，判断系统是否是安全的；若是安全的，才分配。

我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。为保证资金的安全,银行家规定：

（1）当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客；

（2）顾客可以分期贷款,但贷款的总数不能超过最大需求量；

（3）当银行家现有的资金不能满足顾客尚需的贷款数额时，对顾客的贷款可推迟支付，但总能使顾客在有限的时间里得到贷款； （4）当顾客得到所需的全部资金后，一定能在有限的时间里归还所有的资金。

另外，我们也可以把操作系统看作是建造房子，操作系统的资源看作是造房子的起吊机台数，进程向操作系统请求分配资源相当于建造房子时申请的起吊机台数。为保证工程的顺利进行，其操作过程如下：

 当一栋房子对起吊机的最大需求量不超过建造房子现有的起吊机时可接纳该房子的建造；

 所要建造的房子可以分开几次申请起吊机，但申请的起吊机的总数不能超过最大需求量；

 当现有的起吊机台数不能满足某栋房子尚需的起吊机时，对该栋房子所需的起吊机数可推迟给予，但总能是房子在有限的时间里得到贷款；

 当建造的房子得到所需的全部起吊机后，一定能在有限的时间里归还所有的起吊机数。

2、进程同步问题：进程管理模块包括进程概念、进程调度、进程互斥、进程同步、进程通信、进程死锁各知识单元。进程概念包含进程特征、进程状态与转换、进程控制各知识点;进程调度包含调度时机、调度算法、调度过程各知识点;进程互斥包含与时间有关的错误、临界资源与临界区、临界区使用原则、临界区互斥访问的解决途径、临界区互斥访问的解决途径各知识点;进程同步包含信号量同步机制、生产者与消费者问题、读者与写者问题、哲学家进餐问题各知识点;进程通信包含忙等待策略、睡眠和唤醒策略、消息传递策略各知识点;进程死锁包含产生原因、必要条件、解决途径各知识点。

一个进程到达了确定的点后，除非另一些进程已经完成了某些操作，否则不得不停下来等待另一进程为它提供的消息，早未获得消息前，该进程处于等待状态，获得消息后被唤醒处于就绪状态，这就是进程同步。我们在生活中也可以找到相应的例子：例如汽车司机和售票员，汽车司机负责开车、进站、开车门、关车门与进站；售票员负责售票、进出站后观察车门，给司机发开关门信息；正常状态下，各自活动，司机开车，售票员售票；在进出站时双方要进行进程同步。 3.生产—消费者问题

在实际的操作系统操作过程中，经常会碰到如下场景：某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。

单单抽象出生产者和消费者，还够不上是生产者—消费者问题。该问题还需要有一个缓冲区处于生产者和消费者之间，作为一个中介。生产者把数据放入缓冲区，而消费者从缓冲区取出数据。

为了理解这一问题，我们举一个寄信的例子。假设你要寄一封平信，大致过程如下：

1、你把信写好——相当于生产者制造数据

2、你把信放入邮筒——相当于生产者把数据放入缓冲区

3、邮递员把信从邮筒取出——相当于消费者把数据取出缓冲区

4、邮递员把信拿去邮局做相应的处理——相当于消费者处理数据

操作系统知识点看似繁杂,但究其原理,在对不同系统资源功能进行管理时,所采取的策略和方法有很多是相同的。从操作系统四种重要实现技术出发的横向技术线包括中断技术、共享技术、虚拟技术和缓冲技术。

(1)中断技术模块是实现程序并发执行与设备并行操作的基础,它包括中断类型、中断优先级、中断事件各知识单元。中断类型知识单元包括外中断、内中断知识点;中断优先级知识点在不同的系统中有不同的规定;中断事件知识单元包括进程创建与撤消、进程阻塞与唤醒、分时时间片、缺页中断与缺段中断、I/O操作、文件操作各知识点。

(2)共享技术模块是提高资源利用率的必然途径,它包括处理机共享、存储共享、设备共享、文件共享各知识单元。处理机共享包含进程的并发执行;存储共享包含外存储器共享、内存储器共享知识点;设备共享包含SPOOLing系统;文件共享包含便于共享的文件目录。

(3)虚拟技术模块是把一个物理实体变为若干面向用户的逻辑单元,使资源的用户使用与系统管理相分离,从而提高资源利用率和安全性方,它包括虚拟处理机、虚拟存储器、虚拟存储器方法、虚拟设备、虚拟文件各知识单元。虚拟处理机包含多进程管理;虚拟存储器包含地址转换、中断处理过程、置换知识点;虚拟存储器方法包含页式管理、段式管理、段页式管理各知识点;虚拟设备包含设备共享;虚拟文件包含文件共享。

(4)缓冲技术模块是异步技术的实现前提,可大大提高相关资源的并行操作程度,它包括存储管理缓冲技术、设备管理缓冲技术、文件管理缓冲技术各知识单元。存储管理缓冲技术包含快表;设备管理缓冲技术包含硬缓冲、软缓冲、SPOOLing系统中的输入/输出井知识点;文件管理缓冲技术包含记录成组技术、文件表的打开。

操作系统这门课程并不是教你如何使用操作系统的，而是讲操作系统内部机制的。操作系统的目标是为用户提供一个良好的界面，方便用户使用计算机，同时对内部各种软硬件资源能够进行有效地管理和分配，使整个系统能高效率得运行。操作系统的服务是越来越到位了。操作系统主要有五大功能：处理机管理、存储器管理、设备管理、文件管理、用户接口。我们现在使用的大多是PC机，都是只有一块CPU，而有时却要在计算机上运行多个程序，那么每道程序在什么时候使用CPU，这需要合理得分配协调才行，操作系统关于处理机的分配有相应的调度算法，这些工作都有操作系统帮你代劳。内存储器是存放程序与数据的，如何存放才能井井有条，互不干扰，而且能充分合理的利用有限空间，这都需要操心，这一切也是操作系统的事。当你要使用设备的时候，例如要使用打印机，只要单击打印机按钮即可将内容传到打印机进行后台打印，这一切也都是因为有了操作系统，才可以这么轻松的调用外部设备，还不影响当前处理的工作，所以对设备的管理也是非常重要的。文件的操作对于每个用户来说是家常便饭，每次存取文件只需知道地点和文件名即可，你可曾想过你要存取的文件是放在那个道那个扇区上么？有时你不想让自己的文件被外人看到，还可设置权限。这些幕后的工作都由操作系统完成，你只需要使用文件名对文件进行操作就可以了。操作系统还为用户使用提供了两种方式的接口：命令接口和系统调用接口。命令接口可使用户交互的使用计算机，敲入一条命令，系统响应返回结果，用户根据结果再敲入下一条命令，如此反复。Windows中开始菜单下里的运行，也可执行命令。系统调用是为编程人员提供的，每个系统调用都是一个能完成特定功能的子程序，这样编程人员就可站在操作系统的肩膀上编制程序，没必要所有的功能都从头编起，操作系统提供的功能只需申请调用即可。

每当我们打开计算机，启动成功后，首先映入眼帘的就是操作系统的界面。我们所做的一切的工作都是在操作系统之上来完成的。可是谁也不会去想：为什么鼠标的拖拖曳曳就能完成对文件、磁盘、各种软硬件资源的管理；谁也没意识到是因为有了操作系统的支撑，我么才那么方便的使用计算机。直到有一天，开机后发觉整个屏幕黑糊糊得一片，看不到蓝天白云急得象热锅上的蚂蚁时，才知道操作系统是多么得重要，明白了所有的程序的运行原来是离不开操作系统的。这就是“拥有了不知道珍惜，失去后才知道宝贵”的操作系统版的解释。如果有一天离开了操作系统，我们的计算机也就成了一堆废铁，什么事也干不了。

推荐第6篇：学习操作系统心得体会

学习操作系统心得体会

摘要：操作系统是控制其他程序运行，管理系统资源并为用户提供操作界面的系统软件的集合。操作系统身负诸如管理与配置内存、决定系统资源供需的优先次序、控制输入与输出设备、操作网络与管理文件系统等基本事务。

转眼间，学习了一个学期的计算机操作系统课程即将结束。在这个学期中，通过老师的悉心教导，让我深切地体会到了计算机操作系统的一些原理和具体操作过程。

在学习操作系统之前，我只是很肤浅地认为操作系统只是单纯地讲一些关于计算机方面的操作应用，并不了解其中的具体操作过程和实用性。通过这一学期的学习，我才知道操作系统(Operating System，简称OS)是管理计算机系统的全部硬件资源包括软件资源及数据资源；控制程序运行；改善人机界面；为其它应用软件提供支持等，使计算机系统所有资源最大限度地发挥作用，为用户提供方便的、有效的、友善的服务界面。

经过一个学期的学习，我也知道了计算机操作系统是铺设在计算机硬件上的多层系统软件，不仅增强了系统的功能，而且还隐藏了对硬件操作的细节，由它实现了对计算机硬件操作的多层次的抽象。操作系统的一些原理在生活中也有所应用，以下是我通过这一学期的学习，把操作系统的一些原理联系生活所得的心得体会：

1.生产—消费者问题

在实际的操作系统操作过程中，经常会碰到如下场景：某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。

单单抽象出生产者和消费者，还够不上是生产者—消费者问题。该问题还需要有一个缓冲区处于生产者和消费者之间，作为一个中介。生产者把数据放入缓冲区，而消费者从缓冲区取出数据。

为了理解这一问题，我们举一个寄信的例子。假设你要寄一封平信，大致过程如下：

1、你把信写好——相当于生产者制造数据

2、你把信放入邮筒——相当于生产者把数据放入缓冲区

3、邮递员把信从邮筒取出——相当于消费者把数据取出缓冲区

4、邮递员把信拿去邮局做相应的处理——相当于消费者处理数据

2、银行家算法——避免死锁

死锁的产生是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。由于资源占用是互斥的，当某个进程提出申请资源后，使得有关进程在无外力协助下，永远分配不到必需的资源而无法继续运行，这就产生了一种特殊现象死锁。我觉得操作系统所讲的死锁就好像两个人竟过独木桥，两辆车竟过单行桥等阻塞现象，原因是共享资源，即道路。

为提高系统资源的利用率，避免死锁并不严格限制死锁必要条件的存在，而是在资源的动态分配过程中，使用某种方法去防止系统进入不安全状态，从而避免死锁的最终出现。然而，最有代表性的避免死锁的算法，是Dijkstra的银行家算法。在该方法中把系统的状态分为安全状态和不安全状态，只要能使系统始终都处于安全状态，便可以避免发生死锁。银行家算法的基本思想是分配资源之前，判断系统是否是安全的；若是安全的，才分配。 我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。为保证资金的安全,银行家规定：

（1）当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客；

（2）顾客可以分期贷款,但贷款的总数不能超过最大需求量；

（3）当银行家现有的资金不能满足顾客尚需的贷款数额时，对顾客的贷款可推迟支付，但总能使顾客在有限的时间里得到贷款；

（4）当顾客得到所需的全部资金后，一定能在有限的时间里归还所有的资金。

另外，我们也可以把操作系统看作是建造房子，操作系统的资源看作是造房子的起吊机台数，进程向操作系统请求分配资源相当于建造房子时申请的起吊机台数。为保证工程的顺利进行，其操作过程如下：

 当一栋房子对起吊机的最大需求量不超过建造房子现有的起吊机时可接纳该房子的建造；

 所要建造的房子可以分开几次申请起吊机，但申请的起吊机的总数不能超过最大需求量；

 当现有的起吊机台数不能满足某栋房子尚需的起吊机时，对该栋房子所需的起吊机数可推迟给予，但总能是房子在有限的时间里得到贷款；  当建造的房子得到所需的全部起吊机后，一定能在有限的时间里归还所有的起吊机数。  进程同步问题

一个进程到达了确定的点后，除非另一些进程已经完成了某些操作，否则不得不停下来等待另一进程为它提供的消息，早未获得消息前，该进程处于等待状态，获得消息后被唤醒处于就绪状态，这就是进程同步。我们在生活中也可以找到相应的例子：

例如汽车司机和售票员，汽车司机负责开车、进站、开车门、关车门与进站； 售票员负责售票、进出站后观察车门，给司机发开关门信息；正常状态下，各自活动，司机开车，售票员售票；在进出站时双方要进行进程同步。

小结：

总而言之，操作系统的一些原理在生活中都可以找到相应的例子。结合生活中的例子，可以化抽象为具体，我们会更加清楚地了解到其原理与操作过程。我觉得通过我们的不断学习，结合生活中的实际问题，我们就会把操作系统学得更好。

推荐第7篇：学习操作系统心得体会

学院：软件学院 班级：1042 组号：7组 成员：

张晗

武川渊

张天峰

进程的创建与撤销

#include #include #include #include using namespace std; #define OK 1 //成功返回OK定义为1 #define EVERFLOW -1 //越界用-1 #define PCBSIZE 10 //空闲队列初始数组空间

#define NULL 0 //空定义为0 typedef struct PCB //定义进程结构体

{

char name[100]; int id; //进程的序号

int priority; //进程的优先级

int time; struct PCB *next; //进程指向下一个节点

}PCB,*PCBList; PCB pcb[PCBSIZE];//创建pcb块，初始空间大小为10 PCBList nullPcb;//空闲队列 PCBList readyPcb;//就绪队列

PCBList readyPcbtail;//就绪队列队尾指针 void InitPcb(PCBList &nullPcb);//--初始化空闲队列 PCBList Create(PCBList &nullPcb);//-- //创建一个pcb进程从PCB空间申请一个空PCB，填入进程参数，创建一个

pcb进程。

void InsertReadyPcb(PCBList &readyPcb,PCBList &pcb); int Delete(int id,PCBList &readyPcb,PCBList &nullPcb);//--用于销毁一个pcb进程，指定销毁队列的序列号，销毁该进程，并将它插入到空闲队列中 void PrintPCB(PCBList &readyPcb);//--就绪队列输出函数-输出就绪队列中的进程信息，以便观察创建或撤消活动

的结果 void main()

{ int on=0; PCBList p; int deleteId; InitPcb(nullPcb); //给就绪队列分配空间

readyPcbtail=(PCB*)malloc(sizeof(PCB)); readyPcb=readyPcbtail; readyPcbtail->id=0; readyPcbtail->priority=0; readyPcbtail->time=0; readyPcbtail->next=NULL;

do

{/*创建程序控制界面*/ cout>on;//设置开关按钮

switch(on)

{ case 1: p=Create(nullPcb); InsertReadyPcb(readyPcb,p);break; //执

行创建PCB进程

case 2: cout>deleteId;Delete(deleteId,readyPcb,null

Pcb);break; case 3: PrintPCB(readyPcb);break;

case 4: exit(0);

default:

cout

}

}while(on!=4);

} void InitPcb(PCBList &nullPcb)//初始化空闲队列

{

nullPcb=&pcb[0]; for(int i=0;i

pcb[i].id=i;

pcb[i].next=&pcb[i+1];

} pcb[PCBSIZE-1].next=NULL;

cout

} PCBList Create(PCBList &nullPcb)//用于创建一个pcb进

程

{ PCBList pcbP; if(nullPcb){//将空闲队列的第一个赋值给就绪队列，并

将它放置在就绪队列的队尾

pcbP=nullPcb; nullPcb=nullPcb->next; printf(\"请输入创建pcb的序号id\\n\"); scanf(\"%d\",&pcbP->id); printf(\"请输入创建它的名字\\n\"); scanf(\"%s\",&pcbP->name); printf(\"请输入它的优先级\\n\"); scanf(\"%d\",&pcbP->priority); printf(\"请输入它运行所需时间\\n\"); scanf(\"%d\",&pcbP->time);

pcbP->next=NULL;

} return pcbP;

} int Delete(int id,PCBList &readyPcb,PCBList &nullPcb)//用于销毁一个pcb进程

{ PCBList pcbT,pcbF;

if(pcbT) { while(pcbT) { if(pcbT->id==id) {

pcbF->next=pcbT->next;

pcbT->next=nullPcb;

nullPcb=pcbT;

printf(\"销毁成功\\n\");

return OK;

}

pcbT=pcbT->next;

pcbF=pcbF->next;

} if(!pcbT) {

printf(\"没有要删除的pcb进程\\n\");

} } else{

printf(\"没有要删除的pcb进程\\n\");

} return OK;

} void PrintPCB(PCBList &readyPcb)//打印pcb就绪序列

{ PCBList pcbP; printf(\"就绪队列中的进程，按照优先级排序的序列

为:\\n\"); printf(\"\\t\\t序号\\t名字\\t优先级\\t运行时间\\n\");

pcbP=readyPcb->next;

while(pcbP)

{

printf(\"\\t\\t%d\\t%s\\t%d\\t%d\\n\",pcbP->id,pcbP->name,pcbP->priority,pcbP->time); pcbP=pcbP->next;

} } void InsertReadyPcb(PCBList &readyPcb,PCBList &pcb)

{ PCBList pcbF=readyPcb; PCBList pcbT=readyPcb->next;

if(pcbT)

{

while(pcbT)

{ if(pcbT->prioritypriority)

{

pcb->next=pcbT;

pcbF->next=pcb;

printf(\"创建成功并将进程插入到了就绪队列

中了\\n\");

return;

}

pcbT=pcbT->next;

pcbF=pcbF->next;

} if(!pcbT)

{

pcbF->next=pcb;

} } else{

pcbF->next=pcb;

printf(\"创建成功并将进程插入到了就绪队列中了

\\n\"); } }

学习操作系统心得体会

摘要：操作系统是控制其他程序运行，管理系统资源并为用户提供操作界面的系统软件的集合。操作系统身负诸如管理与配置内存、决定系统资源供需的优先次序、控制输入与输出设备、操作网络与管理文件系统等基本事务。

转眼间，学习了一个学期的计算机操作系统课程即将结束。在这个学期中，通过老师的悉心教导，让我深切地体会到了计算机操作系统的一些原理和具体操作过程。

在学习操作系统之前，我只是很肤浅地认为操作系统只是单纯地讲一些关于计算机方面的操作应用，并不了解其中的具体操作过程和实用性。通过这一学期的学习，我才知道操作系统(Operating System，简称OS)是管理计算机系统的全部硬件资源包括软件资源及数据资源；控制程序运行；改善人机界面；为其它应用软件提供支持等，使计算机系统所有资源最大限度地发挥作用，为用户提供方便的、有效的、友善的服务界面。

经过一个学期的学习，我也知道了计算机操作系统是铺设在计算机硬件上的多层系统软件，不仅增强了系统的功能，而且还隐藏了对硬件操作的细节，由它实现了对计算机硬件操作的多层次的抽象。操作系统的一些原理在生活中也有所应用，以下是我通过这一学期的学习，把操作系统的一些原理联系生活所得的心得体会：

1.生产—消费者问题

在实际的操作系统操作过程中，经常会碰到如下场景：某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。

单单抽象出生产者和消费者，还够不上是生产者—消费者问题。该问题还需要有一个缓冲区处于生产者和消费者之间，作为一个中介。生产者把数据放入缓冲区，而消费者从缓冲区取出数据。

为了理解这一问题，我们举一个寄信的例子。假设你要寄一封平信，大致过程如下：

1、你把信写好——相当于生产者制造数据

2、你把信放入邮筒——相当于生产者把数据放入缓冲区

3、邮递员把信从邮筒取出——相当于消费者把数据取出缓冲区

4、邮递员把信拿去邮局做相应的处理——相当于消费者处理数据

2、银行家算法——避免死锁

死锁的产生是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。由于资源占用是互斥的，当某个进程提出申请资源后，使得有关进程在无外力协助下，永远分配不到必需的资源而无法继续运行，这就产生了一种特殊现象死锁。我觉得操作系统所讲的死锁就好像两个人竟过独木桥，两辆车竟过单行桥等阻塞现象，原因是共享资源，即道路。

为提高系统资源的利用率，避免死锁并不严格限制死锁必要条件的存在，而是在资源的动态分配过程中，使用某种方法去防止系统进入不安全状态，从而避免死锁的最终出现。然而，最有代表性的避免死锁的算法，是Dijkstra的银行家算法。在该方法中把系统的状态分为安全状态和不安全状态，只要能使系统始终都处于安全状态，便可以避免发生死锁。银行家算法的基本思想是分配资源之前，判断系统是否是安全的；若是安全的，才分配。 我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。为保证资金的安全,银行家规定：

（1）当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客；

（2）顾客可以分期贷款,但贷款的总数不能超过最大需求量；

（3）当银行家现有的资金不能满足顾客尚需的贷款数额时，对顾客的贷款可推迟支付，但总能使顾客在有限的时间里得到贷款；

（4）当顾客得到所需的全部资金后，一定能在有限的时间里归还所有的资金。

另外，我们也可以把操作系统看作是建造房子，操作系统的资源看作是造房子的起吊机台数，进程向操作系统请求分配资源相当于建造房子时申请的起吊机台数。为保证工程的顺利进行，其操作过程如下：

 当一栋房子对起吊机的最大需求量不超过建造房子现有的起吊机时可接纳该房子的建造；

 所要建造的房子可以分开几次申请起吊机，但申请的起吊机的总数不能超过最大需求量；

 当现有的起吊机台数不能满足某栋房子尚需的起吊机时，对该栋房子所需的起吊机数可推迟给予，但总能是房子在有限的时间里得到贷款；  当建造的房子得到所需的全部起吊机后，一定能在有限的时间里归还所有的起吊机数。  进程同步问题

一个进程到达了确定的点后，除非另一些进程已经完成了某些操作，否则不得不停下来等待另一进程为它提供的消息，早未获得消息前，该进程处于等待状态，获得消息后被唤醒处于就绪状态，这就是进程同步。我们在生活中也可以找到相应的例子：

例如汽车司机和售票员，汽车司机负责开车、进站、开车门、关车门与进站； 售票员负责售票、进出站后观察车门，给司机发开关门信息；正常状态下，各自活动，司机开车，售票员售票；在进出站时双方要进行进程同步。

小结：

总而言之，操作系统的一些原理在生活中都可以找到相应的例子。结合生活中的例子，可以化抽象为具体，我们会更加清楚地了解到其原理与操作过程。我觉得通过我们的不断学习，结合生活中的实际问题，我们就会把操作系统学得更好。

推荐第8篇：网络操作系统心得体会

网络操作系统心得体会

通过这一学期学习，才慢慢接触专业课。刚开始觉得挺难得我都有点不想学这个专业了，慢慢的我觉得有趣多了。虽然我学的不是很好，最起码我能给自己装系统了。我给自己的电脑装过window7.xp系统。从一开始连个CMOS设置都不会进去，到现在能装各种机型的系统。让我最高兴的事是我会建立网站了，以及能制作出复杂点的，漂亮的网页了。

从刚开始学装window server2003时，我真的懵懵懂懂的，那开始是真的不想学这个专业了，那段时间还学java编程，我真的快崩溃了，后悔自己干嘛学这个专业，我根本就是没有天赋，感觉大学这四年完蛋了，大一大二还没有感觉，现在真实的感受到了，但后来发现，我是越来越感觉有兴趣了，只要肯付出课后肯钻研，就一定会有一点收获的。通过这次网页课程设计激发学习兴趣，调动学习的自觉性，自己动脑、动手，动口，运用网络资源，结合教材及老师的指导，通过自身的实践，创作出积聚个人风格、个性的个人网页。总体来说，整个学期的学习过程，我学会了很多知识，在此次网页设计中，我充分利用了这次设计的机会，全心全意投入到网页世界，去不断的学习，去不断的探索；同时去不断的充实，去不断的完善自我，在网络的天空下逐渐的美化自己的人生！做好页面，并不是一件容易的事，它包括个人主页的选题、内容采集整理、图片的处理、页面的排版设置、背景及其整套网页的色调等很多东西。本次课程设计不是很好，页面过于简单，创新意识反面薄弱，这是我需要提高的地方。需要学的地方还有很多，需要有耐心、坚持，不断的学习，综合运用多种知识，才能设计出好的web页面。

总体来说，通过这次的对网页和网站课程设计，有收获也有遗憾、不足的地方，但我想，我已经迈入了网页设计的大门，只要我再认真努力的去学习，去提高，凭借我对网页设计的热情和执着，我将来设计出的网页会更加专业，更完善。

推荐第9篇：操作系统复习提纲

3．什么是操作系统？操作系统在计算机中的主要作用是什么？

操作系统：管理系统资源、控制程序执行、改善人机界面、提供各种服务，并合理组织计算机工作流程和为用户方便有效地使用计算机提供良好运行环境的一种系统软件。 a>服务用户观点——操作系统作为用户接口和公共服务程序 b>进程交互观点——操作系统作为进程执行的控制者和协调者 c>系统实现观点——操作系统作为扩展机和虚拟机 d>资源管理观点——操作系统作为资源的管理者和控制者 10．试述系统调用与函数（过程）调用之间的主要区别。

a>调用形式和实现方式不同。函数调用所转向的地址是固定不变的，但系统调用中不包括内核服务例程入口地址，仅提供功能号，按功能号调用；函数调用是在用户态执行，只能访问用户栈；系统调用要通过陷阱设置，从用户态转换到内核态，服务例程在内核态执行并访问核心栈。

b>被调用代码的位置不同。函数调用是静态调用，调用程序和被调用代码处于同一程序内，经链接后可作为目标代码的一部分，这是用户级程序当函数升级或者修改时，必须重新编译和链接；系统调用是动态调用，系统调用的服务例程位于操作系统中，这是系统级程序，这样当系统调用的服务例程升级或修改时与调用程序无关，而且调用程序的长度大为缩减，能减少其所占用的内存空间。

c>提供方式不同。函数调用通常有编程需要提供，不同语言所提供的函数功能、类型和数量可以不同；系统调用由操作系统提供，一旦操作系统设计好，系统调用的功能、类型和数量便固定不变。 15．什么是多道程序设计？多道程序设计技术有什么特点？

多道程序设计是指允许多个作业（程序）同时进入计算机系统的内存并启动交替计算的方法。 特点：多道性、宏观并行、微观串行。

19．在分时系统中，什么是响应时间？它与哪些因素有关？

响应时间：从交互式进程提交一个请求（命令）直到获得响应之间的时间间隔。

影响因素：cpu的处理速度、联机终端的数目、所用时间片的长短、系统调度开销和对换信息量的多少等。 23．操作系统具有哪些基本功能？请简单叙述之。

a>处理器管理。处理器是计算机系统中最为稀有和宝贵的资源，应该最大限度地提高其利用率。常常采用多道程序设计技术组织多个作业同时执行，解决处理器调度、分配和回收问题。

b>存储管理。存储管理的主要任务是管理内存资源，为多道程序设计提供有力支持，提高存储空间利用率，具体来说有内存分配和回收、地址转换与存储保护、内存共享与存储扩充等。

c>设备管理。设备管理的主要任务是管理各种外部设备，完成用户提出的I/O请求；加快数据传输速度，发挥设备的并行性，提高设备的利用率；提供设备驱动程序和中断处理程序，为用户隐蔽硬件操作细节，提供简单的设备使用方法。

d>文件管理。主要任务是对用户和系统文件进行有效管理，实现按名存取；实现文件共享、保护和保密；保证文件的安全性；向用户提供一整套能够方便地使用文件的操作和命令。 e>联网和通信管理。1网络资源管理；2数据通信管理；3应用服务；4网络管理 27．什么是操作系统内核？

内核是一组程序模块，作为可信软件来提供支持进程并发的基本功能和基本操作，通常驻留在内核空间，运行于内核态，具有直接访问硬件设备和所有内存空间的权限，是仅有的能够执行特权指令的程序。 35．简述操作系统资源管理的主要技术：资源复用、资源虚拟和资源抽象。

资源复用：系统中相应地有多个进程竞争使用物理资源，由于计算机系统的物理资源是宝贵和稀有的，操作系统让众多进程共享物理资源，这种共享称为资源复用。

资源虚拟：虚拟的本质是对资源进行转换、模拟和整合，把一个物理资源转变成多个逻辑上的对应物，也可以把多个物理资源变成单个逻辑上的对应物。即创建无须共享的多个独占资源的假象，或创建易用且多个实际物理资源数量的虚拟资源假象，以达到多用户共享一套计算机物理资源的目的。 第二章

9．什么是系统调用？试述API、库函数及系统调用间的关系。

系统调用是一种中介角色把用户和硬件隔离开来，应用程序只有通过系统调用才能请求系统服务并使用系统资源。

POSIX标准规定了符合此标准的操作系统必须提供API，但并未规定接口的实现是采用系统调用、库函数还是其他形式。系统调用只是一种API。

调用fprintf()→C函数库中的fprintf()封装函数→系统调用处理程序→sys_write()内核函数。 18．什么是进程？计算机操作系统为什么要引入进程？

进程：可并发执行的程序在某个数据集合上的一次计算活动，也是操作系统作为资源分配和保护的基本单位。

目的：

a>刻画程序的并发性。进程是并发程序设计的一种有力工具，操作系统中引入进程概念能较好地刻画系统内部程序的并发执行，从而提高资源利用率。 b>解决资源的共享性。

20．进程最基本的状态有哪些？哪些事件可能引起不同状态间的转换？ 运行态：进程占有处理器正在运行的状态。

就绪态：进程具备运行条件，等待系统分配处理器以便运行的状态。

等待态：又称阻塞态或睡眠态，指进程不具备运行条件，正在等待某个事件完成的状态。 26．何谓进程控制快（PCB)？它包含哪些基本信息？

每个进程有切仅有一个进程控制块，或称进程描述符，它是进程存在的唯一标识，是操作系统用来记录和刻画进程状态及环境信息的数据结构，是进程动态特征的集合，也是操作系统掌握进程的唯一资料结构和所处的状态的主要依据。

a>标识信息。标识信息用于唯一地标识一个进程，分为用户使用的外部标识符和系统使用的内部标识符。 b>现场信息。现场信息用于保留进程在运行时存放在处理器现场中的各种信息。 c>控制信息。控制信息用于管理和进程调度。

48．处理器调度分为哪几种类型？简述各类调度任务的主要任务。

高级调度：又称作业调度、长度调度，在多道批处理操作系统中，从输入系统的一批作业按照预定的调度策略挑选若干作业进去内存，为其分配所需资源并创建对应作业的用户进程后，便完成启动阶段的高级调度任务，已经为进程做好运行前的准备工作，等待进程被调度运行，在作业完成后还要做结束阶段的善后工作。

中级调度：又称平衡调度、中度调度，根据内存资源情况决定没错中所能容纳的进程数目，并完成外存和内存中的进程对换工作。

低级调度：又称进程调度或线程调度、短程调度，根据某种原则决定就绪队列中的哪个进程/线程获得处理器，并将处理器让出给它使用。 第三章

9．什么是临界区和临界资源？临界区管理的基本原则是什么？ 并发进程中与共享变量有关的程序段称为临界区。共享变量所代表的资源称为临界资源，即一次仅能供一个进程使用的资源。

原则一：一次至多只有一个进程进入临界区内执行。

原则二：如果已有进程在临界区中，试图进入此临界区的其他进程应等待。

原则三：进入临界区内的进程应在有限的时间内退出，以便让等待队列中的一个进程进入。 13．什么是信号量？如何对其进行分类？

在操作系统中用信号量表示物理资源的实体，它是一个与队列有关的整型变量。 具体实现时，信号量是一种产量类型，用一个记录型数据结构表示，有两个分量，一个是信号量的值，另一个是信号量队列指针。

信号量按其用途可分为两种：a>公用信号量，联系一组并发进程均可在此信号量上执行pv操作，初值置为一，用于实现进程互斥；b>私有信号量，联系一组并发进程，仅允许此信号量所拥有的进程执行P操作，而其相关进程可在其上施行V操作，初值往往为0或正整数，多用于并发进程同步。

信号量按其取值可分为两种：a>二值信号量，仅允许取值为0或1，主要作用用于解决进程互斥问题；b>一般信号量，又称计数信号量，允许取大于1的整型值，主要用于解决进程同步问题。 15．何谓管程？它有哪些属性？

管程是由局部于自己的若干公共变量及其申明和所有访问这些公共变量的过程所组成的软件模块，它是一种互斥机制，进程可互斥的调用管程中的过程。

a>共享性。管程中的移出过程可被所有要调用管程的过程的进程所共享。

b>安全性。管程的局部变量只能由此管程的过程访问，不允许进程或其他管程来直接访问，一个管程的过程也不应访问任何非局部于它的变量。

c>互斥性。在任一时刻，共享资源的进程可以访问管程中的管理此资源的过程，但最多只有一个调用者能够正真地进入管程，其他调用者必须等待直至管程可用。 20．什么是管道？如何通过管道机制实现进程间的通信？

管道：是连接读写进程的一个特殊文件，允许按照FIFO方式传送数据，也能是使进程同步执行。

写进程在管道的尾端写入数据，读进程在管道的首端读出数据。数据读出后将从管道中移走，其他进程都不能再读到这些数据。进程试图读管道时，再有数据写入管道前，进程将一直阻塞。同样，管道已经满时，进程再试图写入管道，在其他进程从管道中移走数据之前，写进程将一直阻塞。 25．试述产生死锁的必要条件。

1>互斥条件：临界资源是独占资源，进程应互斥且排他地使用这些资源。 2>占有和等待条件：进程在请求资源得不到满足而等待时，不释放已占有资源。

3>不剥夺条件：又称不可抢占，已获资源只能由进程自愿释放，不允许被其他进程剥夺。

4>循环等待条件：又称环路条件，存在循环等待链，其中每个进程都在等待链中等待下一进程所持有的资源，造成这组进程处于永远等待状态。 27．何谓银行家算法？试述其基本思想。

系统中的所有进程放入进程集合，在安全状态下系统收到进程的资源请求后，先把资源试探性的分给它；然后系统将剩下的可用资源和进程集合中其他进程还需要的资源数作比较，找出剩余资源能满足最大需求量的进程，从而保证进程运行完毕并归还全部资源；这时把这个进程从进程集合中删除，归还其所占有的所有资源，系统的剩余资源则越多；反复执行上述步骤，最后检查进程集合，若为空则表明本次申请可行，系统处于安全状态，可以真正实施本次分配，否则只要等待集合非空，系统便处于不安全状态，本次资源分配不实施，让申请资源的进程等待。 第四章

1．试述存储管理的基本功能。

ⅰ存储分配ⅱ地址映射ⅲ存储保护ⅳ存储共享 ⅴ存储扩充 4．何谓地址转换（重定位）？哪些方法可以实现地址转换。

可执行的程序逻辑地址转换（绑定）为物理地址的过程称为地址转换。 实现方法：静态地址重定位，动态地州重定位。

5．分区存储管理中采用那些分配策略？比较其优、缺点。 固定分区：

优点：固定分区能解决单道程序运行在并发环境下不能与cpu速度匹配的问题，同时也解决了单道程序运行是内存空间利用低的问题。

缺点：ⅰ.由于预先已经规定分区大小，是的大作业无法装入，用户不能采用覆盖能技术加以补救，这样不但加重用户负担，而且极其不方便；ⅱ.内存空间利用率不高，作业很少会恰好填满分区；ⅲ.如果一个作业要求在运行过程中动态扩充存储空间，采用固定分区是相当困难的；ⅳ.分区数目是在系统初启是确定的这就会限制多道运行程序的道数，特别不适应分时系统交互型用户及内存需求变化很大的情况。 可变分区：

优点：ⅰ.能克服固定分区内存资源的浪费问题；ⅱ.有利于多道程序设计；ⅲ.实现了多个程序作业对内存的共享。

缺点：ⅰ.回收算法复杂；ⅱ.它的各种分配算法有一定缺陷，难以避免内存碎片的产生；ⅲ.采用动态地址重定位需要硬件寄存器的支持。

9．什么是虚拟存储器？列举采用虚拟存储技术的必要性和可能性。

虚拟存储技术：在具有层次结构存储器的计算机系统中，自动实现部分装入和部分替换功能，能存逻辑上为用户提供一个比物理内存容量大得多的、可寻址的“内存储器”。

必要性：可用较小的内存空间执行较大的程序，能容纳更多的并发执行程序。 可能性：基于程序的局部性原理。 11．试述请求分段虚存管理的实现原理。 请求分段虚存管理是将进程信息副本存放在外存中，当它被调度投入运行时，程序和数据没有全部装入内存，仅装入当前使用段，进程执行过程中访问到不在内存的段时候，再有系统自动调入。 18．试述实现虚拟存储器的基本原理。 作业运行之前仅将当前要运行的那部分页面和段先装入内存便可开始运行，在程序的运行中，发现所要访问的段不在内存中时，再有操作系统将其调入内存，程序便可继续执行下去。 第五章

1．试述设备管理的基本功能。

设备中断处理、缓冲区处理、设备分配和去配、设备驱动调度、实现虚拟设备。 2．试述各种I/O控制方式及其主要优、缺点。

轮询方式：又称程序直接控制方式，使用查询指令测试设备控制器的忙闲状态位，确定内存和设备是否能交换数据。

优点：原理简单，成本低廉。

缺点：a>.一旦cup启动了I/O设备，便不断的查询I/O设备的准备情况，终止了原程序的执行；b>.cpu在反复查询过程中，浪费了宝贵的cpu时间，c>.I/O设备准备就绪后，cpu参与数据的传输工作，此时cpu也不能执行原程序。总之，轮询方式的主要缺点是运行效率不足。

中断控制方式：cpu启动I/O设备后不必查询I/O设备是否准备就绪，而是继续执行现行程序，对设备是否准备就绪不加过问。

优点：不必忙于查询I/O准备情况，cup和I/O设备可实现部分并行，大大提升了cup的利用率。 缺点：输入输出操作直接由中央处理器控制，每传送一个字符或一个字，都要发生一次中断，仍耗费大量中央处理器时间。

DMA方式：内存和设备之间有一条数据通路成块的传说数据，在主机和I/O设备之间成块的传送数据过程中，无需CPU干预，实际操作有DMA直接执行完成。 优点：实现线路简单，价格低廉。

缺点：增加主存地址寄存器，数据移位寄存器等硬件，不仅有中断结构，还增加了DMA传输控制结构，增加了成本，但功能较差，不能满足复杂的I/O操作要求。

通道方式：又称I/O处理器，能完成内存和设备之间的信息传送，与CPU并行的执行操作。

优点：a>.自成独立体系，大大减少了外围设备和中央处理器的逻辑关系，把中央处理器从琐碎的输入输出操作中解放出来；b>.外围和中央处理器能实现并行操作；c>.通道和通道之间能实现并行操作；d>.各通道上的外围设备也能实现并行操作。

缺点：a>.具有通道装置的计算机的主机、通道、控制器和设备之间用四级连接，实施三级控制；b>.价格较高，一般在大型机中使用。 4．大型机常常采用通道实现信息传输，试问为什么是通道？为什么引入通道？ 通道又称I/O处理器，能完成内存和设备之间的信息传送，与CPU并行的执行操作。采用通道技术主要解决I/O操作的独立性和硬件部分的并行性，由通道来管理和控制I/O操作，大大减少了设备和中央处理器的逻辑关系，把中央处理器从琐碎的输入输出操作中解放出来，实现设备和中央处理器能实现并行操作，通道之间实现并行操作，设备之间并行操作，达到提高整个系统效率的目的。 12．为什么要引入缓冲技术？其基本思想是什么？

①为了解决cpu与设备之间速度不匹配的矛盾；②协调逻辑记录大小与物理记录大小不一致的问题；③提高cpu和设备的并行性；④减少I/O操作对cpu的中断次数，放宽对cpu中断响应时间的要求。 基本思想：当进程执行写操作输出数据时，先向系统申请一个输出缓冲区，然后将输入送入缓冲区，若是顺序写请求，则不断的将数据填入缓冲区，直至装满为止，此后进程可以继续计算，同时系统将缓冲区的内容写到设备上；当进程执行读操作输入数据时，先向系统申请一个输入缓冲区，系统将设备上的一条物理记录读至缓冲区，根据要求把当前所需要的逻辑记录从缓冲区中选出并传送给进程。 21．什么事虚拟设备？实现虚拟设备的主要条件是什么？

虚拟技术是为了提高独立设备的利用率，采用spooling技术科共享设备模拟独占设备。是独立设备依赖的关键技术是spooling技术。

实现相应功能的守护进程（线程）都在用户空间上运行，但所完成的是操作系统任务，即把本该有内成为共享设备。

26．Spooling是如何把独立型设备改造成共享型设备的？ 核实现的功能外移。

28．为什么要引入设备独立性？如何实现设备独立性？

应用程序与具体的物理设备无关，系统要增减或变更设备时对源程序不必加如何修改，易于应对I/O用户通常不指定物理设备，而是指定逻辑设备，是的用户作业和物理设备分离开来，在通过其他途径设备故障，增加设备分配的灵活性，能更有效的理由设备资源，实现多道程序设计。 建立逻辑设备和物理设备的映射。

30．目前常用的磁盘驱动调度算法有哪几种？分别适用于何种数据应用场合？ 先来先服务、最短查找时间优先算法、扫描算法、分步扫描算法、电梯调度算法、循环扫描算法。 第六章

1．试述下列术语的的定义并说明它们之间的关系:卷、块、记录、文件。 卷：硬盘上的存储区域。一个硬盘包括好多卷，一卷也可以跨越许多磁盘。 块：存储介质上连续信息所组成的一个区域。

记录：是一组相关数据的集合，用于描述一个对象在某方面的属性。

文件：是由信息按一定结构组成，可持久性保存的抽象机制，由于它必定存储在某中存储设备上，故也可以认为文件是设备的一种抽象。

4．什么是文件的逻辑结构？它有哪几种组织方式？ 从用户的观点出发，研究用户概念中抽象的信息组织方式，这是用户所能观察到的、可加以处理的数据集合。由于数据可独立于物理环境构造，故称为逻辑结构，相关数据的集合构成逻辑文件。 组织方式：流式文件、记录文件。

5．什么是文件的物理结构？它有哪几种组织方式？ 文件的物理结构和组织是指逻辑文件在物理存储空间中的存放方法和组织关系。 组织方式：组织文件、连接文件、直接文件、索引文件

9．文件系统所提供的主要文件操作有哪些？试述各自的主要功能。

创建文件：当文件尚未存在时，需要对其创建，或者文件原来已经存在，有时需要重新创建。 删除文件：把指定文件从其所在目录文件中删除。

打开文件：指系统将指明文件的属性从外存拷贝到内存打开文件表的一个目录表中，并将该表的编号返回给用户。

关闭文件：文件使用完毕，执行关闭系统调用切断应用进程与文件之间的联系。 读文件：把文件的内容读入用户数据区中。 写文件：把数据用户区中的信息写入文件中。 15．什么事设备文件？如何实现设备文件？

设备文件：为设备起的一个名字，可以像使用文件一样方便的管理设备。

实现：设备文件依赖于inode实现，文件目录并不能区分文件名是代表一个磁盘文件还是设备文件，但inode的内容是不同的，磁盘文件的inode包含指向数据的指针，而设备文件的inode则包含指向内核设备驱动程序的指针，用来控制设备的I/O操作。 16．什么事文件的共享？ 文件的共享是指不同进程使用同一个文件，文件共享不仅为不同进程完成共同任务所必需，而且还节省大量的外存空间，减少因文件复制而增加的I/O操作次数。

推荐第10篇：操作系统课程设计

长春理工大学 软件学院 0813111班 27号

姓名：丁为胜 一． 概述

1、课程设计目的及任务课程设计地点及要求

每个学生一台微机，需要安装windows98或windows2000操作系统，配备VC、VB、java或C编程语言，每个学生上机时间不少于24个小时。

操作系统是计算机专业的核心专业课，“操作系统课程设计”是理解和巩固操作系统基本理论、原理和方法的重要的实践环节。

操作系统课程主要讲述的内容是多道操作系统的原理与技术，与其它计算机原理、编译原理、汇编语言、计算机网络、程序设计等专业课程关系十分密切。本课程设计的目的综合应用学生所学知识，建立系统和完整的计算机系统概念，理解和巩固操作系统基本理论、原理和方法，掌握操作系统基本理论与管理方式。在算法基础上，解决实际的管理功能的问题，提高学生实际应用、编程的能力。

主要任务是实现操作系统和相关系统软件的设计，其中涉及进程创建，同步，进程间的通信，存储管理，文件系统等操作系统概念。

2.课程设计地点及要求

每个学生一台微机，需要安装windows98或windows2000操作系统，配备VC、VB、java或C编程语言，每个学生上机时间不少于24个小时。

3.课程设计的内容

设计二： 设计任务：

掌握进程的管道通讯机制和信号量同步互斥机制。 1． 进程的管道通讯

编制一个程序，程序中创建一个子进程。然后父子进程各自独立运行，父进程不断地在标准输入设备上读入小写字母，写入管道。子进程不断地从管道中读取字符，转换为大写字母后输出到标准输出设备上。当读到x时，结束。

2． 信号量实现的同步互斥机制

编制一个程序，程序中创建5个子进程，代表五位哲学家，然后父进程结束。使用信号量机制解决哲学家进餐问题。当哲学家进餐时，屏幕输出：

[进程号] eating! 当哲学家思考时，屏幕输出： [进程号] thinging! 相关的系统调用和函数：pipe(); write(); read(); semget(); sepop(); semctl(); 要求：查找并阅读上述系统调用的相关资料，将上述相关的函数封装为P( )、V( )操作，使用你封装的P( )、V( )操作实现5位哲学家的同步和互斥。

二． 设计的基本概念和原理

1.进程的管道通讯

管道（Pipe）实际是用于进程间通信的一段共享内存，创建管道的进程称为管道服务器，连接到一个管道的进程为管道客户机。命名管道（Named Pipes）是在管道服务器和一台或多台管道客户机之间进行单向或双向通信的一种命名的管道。一个命名管道的所有实例共享同一个管道名，但是每一个实例均拥有独立的缓存与句柄，并且为客户——服务通信提供有一个分离的管道。实例的使用保证了多个管道客户能够在同一时间使用同一个命名管道。

2.信号量实现的同步互斥机制

规定奇数号的哲学家先拿起他左边的筷子,然后再去拿他右边的筷子;而偶数号 的哲学家则相反.按此规定,将是1,2号哲学家竞争1号筷子,3,4号哲学家竞争3号筷子.即 五个哲学家都竞争奇数号筷子,获得后,再去竞争偶数号筷子,最后总会有一个哲学家能获 得两支筷子而进餐。而申请不到的哲学家进入阻塞等待队列，根FIFO原则，则先申请的哲 学家会较先可以吃饭，因此不会出现饿死的哲学家。

三． 总体设计

1.实现的方法和主要技术路线

1.无名管道

无名管道用于具有亲缘关系的父子进程，子子进程之间的通讯。它的实现函数有 int pipe(int fd[2]);

//fd[2] 为描述符数组，包含一个读描述符与一个写描述符，在使用管道通信时，关闭某些不需要的读或写描述符，建立起单向的读或写管道，然后用read 和write 像操作文件一样去操作它即可。

如图便是进程1 到进程2 的一个读管道。

分别在父进程和父子进程里向管道写数据，然后在子进程和子子进程里读数据。 2.哲学家进餐伪码：

semaphore chopstick[5]={1，1，1，1，1}; void philosopher(int i) {

while(true) {

think();

if(i%2 == 0) //偶数哲学家，先右后左。

{

wait (chopstick[ i + 1 ] mod 5) ; wait (chopstick[ i]) ; eat();

signal (chopstick[ i + 1 ] mod 5) ; signal (chopstick[ i]) ; }

Else //奇数哲学家，先左后右。

{

wait (chopstick[ i]) ;

wait (chopstick[ i + 1 ] mod 5) ; eat();

signal (chopstick[ i]) ;

signal (chopstick[ i + 1 ] mod 5) ; } } 四． 详细设计

进程的管道通信代码： import java.io.IOException; import java.io.PipedReader;

public cla ReceiverThread1 extends Thread { PipedReader pipedReader;

public ReceiverThread1(SenderThread1 sender) throws IOException

{

pipedReader=new PipedReader(sender.getPipedWriter());

}

public void run()

{ char[] ch=new char[100]; StringBuffer sb=null; String str=null; int i=0; try {

while((i=pipedReader.read(ch))!=-1)

{

sb=new StringBuffer();

for(int j=0;j

{

sb.append(ch[j]);

}

str=sb.toString();

System.out.println(\"子进程读取的字符为：\"+str.toUpperCase());

if(!str.endsWith(\"x\"))

{

System.out.print(\"父进程读入字符为：\");

}else if(str.endsWith(\"x\"))

{

System.out.println(\"结束无法再次输入字符\");

}

} } catch (IOException e) {

e.printStackTrace(); }finally{

try {

pipedReader.close();

} catch (IOException e) {

e.printStackTrace();

} }

}

}

import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PipedWriter;

public cla SenderThread1 extends Thread { PipedWriter pipedWriter;

public SenderThread1() {

pipedWriter=new PipedWriter(); }

public PipedWriter getPipedWriter() {

return pipedWriter; }

public void run()

{ BufferedReader ir=new BufferedReader(new InputStreamReader(System.in)); char[] ch=new char[100]; StringBuffer sb=null; String str=null; int i=0; System.out.print(\"父进程读入字符为：\"); try {

while((i=ir.read(ch))!=-1)

{

sb=new StringBuffer();

for(int j=0;j

{

if(ch[j]>=\'a\' && ch[j]

{

sb.append(ch[j]);

if(ch[j]==\'x\')

{

break;

}

}

}

str=sb.toString();

pipedWriter.write(str);

if(str.startsWith(\"x\")||str.endsWith(\"x\"))

{

break;

// this.stop();

}

}

} catch (IOException e) {

e.printStackTrace(); }finally{

try {

ir.close();

pipedWriter.close();

} catch (IOException e) {

e.printStackTrace();

}

}

} }

public cla ThreadComm1 { public static void main(String[] args)throws Exception{ SenderThread1 sender=new SenderThread1(); ReceiverThread1 receiver=new ReceiverThread1(sender); sender.start(); receiver.start(); } } 哲学家进餐问题代码： #include \"stdafx.h\" using namespace std; bool chop[100];//定义筷子 cla ph { protected: bool * left,* right;//哲学家的左右手指向的筷子

int eattime;//哲学家的吃饭时间 public: bool check()//用于检查哲学家左右手的筷子是不是被占用

{

if(*left && *right)

return true;

else

return false; } void eat(int ineattime)//哲学家开始进餐

{

eattime=ineattime;

*left=false;

*right=false; } bool finish()//检查哲学家是否完成进餐

{

if(eattime>0)//没完成的话剩余时间减少

{

eattime--;

if(eattime==0)//完成的话归还筷子

{

*left=true;

*right=true;

return true;

}

else

return false;

}

else

return false; } void init(int num,int max)//初始化哲学家，指定他们使用的筷子

{

eattime=0;

left=&chop[num];

if(num

right=&chop[num+1];

else

right=&chop[0]; } }; void main() { system(\"title 哲学家进餐问题\"); int in,i,temp,time,j=1; queue Q; ph P[100];

for(int i=0;i

chop[i]=1;

} for(int i=0;i>in; if(in==0)

break; else

if(in>5)

{

cout

}

else

{

Q.push(in-1);

} } cout>time; system(\"CLS\"); system(\"color 0a\"); while(!Q.empty()) { temp=Q.front(); Q.pop(); if(P[temp].check()) {

P[temp].eat(time);

cout

if(temp+2>5)

cout

else

cout

Q.push(temp); } for(i=0;i

{

if(P[i].finish())

cout

}

//Q.push(-1);

for(i=0;i

{

temp=Q.front();

Q.pop();

//if(temp!=-1)

{

cout

Q.push(temp);

}

//else

{

// Q.pop();

break;

}

} } for(int j=0;j

if(P[i].finish())

{

cout

} getch(); }

第11篇：操作系统课程设计

湖北民族学院信息工程学院11级计算机专业操作系统课程设计

（操作系统课程设计）

连续动态分区内存

管理模拟实现

学生姓名： 韩 慧 学生学号： 031140312 班 级： 031140--3

031140

1、0

2、0

3、04班制

二〇一三年十二月

1 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

目录

《操作系统》课程设计.......................................................1 引言......................................................................3 课程设计目的和内容 ......................................................3 需求分析.........................................................................3 概要设计...................................................................3 开发环境........................................................................4 系统分析设计.....................................................................4 有关了解内存管理的相关理论..................................................4 内存管理概念........................................................................4 内存管理的必要性..............................................................4 内存的物理组织.............................................................4 什么是虚拟内存.................................................................5 连续动态分区内存管理方式...................................................5 单一连续分配（单个分区)...................................................5

固定分区存储管理...............................................................5 可变分区存储管理（动态分区）..............................................5 可重定位分区存储管理........................................................5 问题描述和分析....................................................................6 程序流程图........................................................................6 数据结构体分析..................................................................8 主要程序代码分析...............................................................9 分析并实现四种内存分配算法 .................................................11 最先适应算.....................................................................11 下次适应分配算法..........................................................13 最优适应算法...............................................................16 最坏适应算法...............................................................18 回收内存算法................................................................20 调试与操作说明.................................................................22

初始界面.......................................................................22 模拟内存分配...............................................................23

已分配分区说明表面............................................................24 空闲区说明表界面.............................................................24 回收内存界面.....................................................................25 重新申请内存界面..........................................................26.总结与体会......................................................................28

2 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

参考文献.........................................................................28

引言

操作系统是最重要的系统软件，同时也是最活跃的学科之一。我们通过操作系统可以理解计算机系统的资源如何组织，操作系统如何有效地管理这些系统资源，用户如何通过操作系统与计算机系统打交道。

存储器是计算机系统的重要组成部分，近年来，存储器容量虽然一直在不断扩大，但仍不能满足现代软件发展的需要，因此，存储器仍然是一种宝贵而又紧俏的资源。如何对它加以有效的管理，不仅直接影响到存储器的利用率，而且还对系统性能有重大影响。而动态分区分配属于连续分配的一种方式，它至今仍在内存分配方式中占有一席之地。

课程设计目的和内容：

理解内存管理的相关理论，掌握连续动态分区内存管理的理论；通过对实际问题的编程实现，获得实际应用和编程能力。

编写程序实现连续动态分区内存管理方式，该程序管理一块虚拟内存，实现内存分配和回收功能。 分析并实现四种内存分配算法，即最先适应算法，下次最先适应算法，最优适应算法，最坏适应算法。内存分配算法和回收算法的实现。

需求分析

动态分区分配是根据进程的实际需要，动态地为之分配内存空间。在实现动态分区分配时，将涉及到分区分配中所用的数据结构、分区分配算法和分区的分配和回收操作这样三个问题。常用的数据结构有动态分区表和动态分区链。在对数据结构有一定掌握程度的情况下设计合理的数据结构来描述存储空间，实现分区存储管理的内存分配功能，应该选择最合适的适应算法（首次适应算法，最佳适应算法，最后适应算法，最坏适应算法），在动态分区存储管理方式中主要实现内存分配和内存回收算法，在这些存储管理中间必然会有碎片的产生，当碎片产生时，进行碎片的拼接等相关的内容

概要设计

本程序采用机构化模块化的设计方法，共分为四大模块。 ⑴最先适应算法实现

从空闲分区表的第一个表目起查找该表，把最先能够满足要求的空闲区分配给作业，这种方法目的在于减少查找时间。为适应这种算法，空闲分区表（空闲区链）中的空闲分区要按地址由低到高进行排序。该算法优先使用低址部分空闲区，在低址空间造成许多小的空闲区，在高地址空间保留大的空闲区。 ⑵下次适应分配算法实现

3 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

该算法是最先适应算法的变种。在分配内存空间时，不再每次从表头（链首）开始查找，而是从上次找到空闲区的下一个空闲开始查找，直到找到第一个能满足要求的的空闲区为止，并从中划出一块与请求大小相等的内存空间分配给作业。该算法能使内存中的空闲区分布得较均匀。 ⑶最优适应算法实现

它从全部空闲区中找出能满足作业要求的、且大小最小的空闲分区，这种方法能使碎片尽量小。为适应此算法，空闲分区表（空闲区链）中的空闲分区要按从小到大进行排序，自表头开始查找到第一个满足要求的自由分区分配。 ⑷最坏算法实现

最坏适应分配算法要扫描整个空闲分区或链表，总是挑选一个最大的空闲分区分割给作业使用。该算法要求将所有的空闲分区按其容量从大到小的顺序形成一空闲分区链，查找时只要看第一个分区能否满足作业要求。

开发环境：

win7 下 VC++6.0 系统分析设计：

相关算法原理，算法流程图，涉及的数据结构内容都相应包含在各章节中

有关了解内存管理的相关理论

内存管理概念：

内存管理，是指软件运行时对计算机内存资源的分配和使用的技术。其最主要的目的是如何高效，快速的分配，并且在适当的时候释放和回收内存资源。内存不是预先划分好的，而是在系统运行的过程中建立分区.当作业装入主存时，根据作业所需要的主存容量查看是否有足够的主存空间，若有则按需要分割一个分区给该作业；否则令该作业等待.分区长度不固定分区个数不固定。这种存储管理的方法克服了固定分区严重浪费主存的问题，提高了主存资源的利用率。

内存管理的必要性：

内存管理对于编写出高效率的 Windows 程序是非常重要的，这是因为Windows 是多任务系统，它的内存管理和单任务的 DOS 相比有很大的差异。DOS是单任务操作系统，应用程序分配到内存后，如果它不主动释放，系统是不会对它作任何改变的；但 Windows 却不然，它在同一时刻可能有多个应用程序共享内存，有时为了使某个任务更好地执行，Windows 系统可能会对其它任务分配的内存进行移动，甚至删除。因此，我们在 Windows 应用程序中使用内存时，要遵循Windows 内存管理的一些约定，以尽量提高 Windows 内存的利用率。

4 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

1.3 内存的物理组织：

物理地址：

把内存分成若干个大小相等的存储单元，每个存储单元占 8 位，称作字节（byte）。每个单元给一个编号，这个编号称为物理地址（内存地址、绝对地址、实地址）。

二、物理地址空间： 物理地址的集合称为物理地址空间（主存地址空间），它是一个一维空间。

什么是虚拟内存：

虚拟内存是内存管理技术的一个极其实用的创新。它是一段程序（由操作系统调度），持续监控着所有物理内存中的代码段、数据段，并保证他们在运行中的效率以及可靠性，对于每个用户层（user-level）的进程分配一段虚拟内存空间。当进程建立时，不需要在物理内存件之间搬移数据，数据储存于磁盘内的虚拟内存空间，也不需要为该进程去配置主内存空间，只有当该进程被被调用的时候才会被加载到主内存。

连续动态分区内存管理方式的实现

在早期的操作系统中，主存分配广泛采用连续分配方式。 连续分配方式，是指为一个用户程序分配一个连续的内存空间，该连续内存空间指的的是物理内存。下面介绍连续分配的四种方式。

单一连续分配（单个分区）

最简单的存储管理方式，用于多道程序设计技术之前。 内存分为系统区和用户区，系统区由操作系统使用。用户区作为一个连续的分区分配给一个作业。 分区存储管理是满足多道程序设计的最简单的一种存储管理方法，它允许多 4个用户程序同时存在系统内存中，即共享内存空间。 按分区划分方式可分为固定分区和可变分区。

固定分区存储管理

把内存的用户区预先划分成多个分区，每个分区大小可以相同，也可以不同。（分区的划分由计算机的操作员或者由操作系统给出，并给出主存分配表） 分区个数固定，分区的大小固定。 一个分区中可装入一个作业，作业执行过程中不会改变存放区域。 早期的 IBM 的 OS/MFT（具有固定任务数的多道程序系统）采用了这种固定分区的方法。

可变分区存储管理（动态分区）

内存不是预先划分好的，而是在系统运行的过程中建立分区.当作业装入主存时，根据作业所需要的主存容量查看是否有足够的主存空间，若有则按需要分割一个分区给该作业；否则令该作业等待。 分区长度不固定分区个数不固定。 这种存储管理的方法克服了固定分区严重浪费主存的问题，提高了主存资源的利用率。 ＩＢＭ操作系统ＯＳ／ＭＶＴ采用可变分区存储管理。

5 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

可重定位分区存储管理

解决碎片问题的一种简单方法是采用可重定位分区分配.。 其中心思想是，把不同程序，且在内存中地址不连续的想法让他们连续。

例：内存中现有 3 个空闲区，现有一作业到达，要求获得 30k 内存空间，没有分区满足容量要求，若想把作业装入，可将内存中所有作业进行移动，这样把原来分散的空闲区汇集成一个大的空闲区。 将内存中的作业进行移动使它们连接在一起把原来分散的多个小分区拼接成一个大的空闲区.这个过程称为”紧凑”或”移动”。 需解决的问题:每次”紧凑”后程序或数据装入的物理地址变化采用动态重定位。

问题描述和分析

系统应利用某种分配算法，从空闲分区链表中找到所需大小的分区，如果空闲分区大小大于请求分区大小，则从该分区中按改请求的大小划分出一块内存空间大小划分出一块内存空间分配出去，余下的部分仍留在空闲链表中。然后，将分配区的首址返回给调用者。

当进程运行完毕师范内存时，系统根据回收区的首址，从空闲区中找到相应的插入点，此时可能出现以下四种情况之一：

⑴该空闲区的上下两相邻分区都是空闲区：将三个空闲区合并为一个空闲区。新空闲区的起始地址为上空闲区的起始地址，大小为三个空闲区之和。空闲区合并后，取消可用表或自由链中下空闲区的表目项或链指针，修改上空闲区的对应项。

⑵该空闲区的上相邻区是空闲区：将释放区与上空闲区合并为一个空闲区，其起始地址为上空闲区的起始地址，大小为上空闲区与释放区之和。合并后，修改上空闲区对应的可用表的表目项或自由链指针。

⑶该空闲区的下相邻区是空闲区：将释放区与下空闲区合并，并将释放区的起始地址作为合并区的起始地址。合并区的长度为释放区与下空闲区之和。同理，合并后修改可用表或自由链中相应的表目项或链指针。

⑷两相邻区都不是空闲区：释放区作为一个新空闲可用区插入可用表或自由链。

程序流程图

内存分配流程图，如图

6 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

从头开始查表检索完否？NY返回分区大小>所需大小N继续检索下一个表项Y分区大小-所需大小

内存回收流程图，如图

7 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

开始判断空闲区上下内存情况上为空下为空上下都为空上下都不为空将上面的空闲区合并，并回收将下面的空闲区合并，并回收将上下的空闲区合并，并回收直接将其回收结束 数据结构体分析

⑴进程属性结构体 typedef struct readyque { char name[10]; int size; }readyque,*readyqueue; ⑵空闲链表结构体 typedef struct idlyspace { int from; int size; idlyspace * next; }idlyspace,*idly; ⑶已分配链表结构体 typedef struct busyspace { int from; readyque r;

8 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

busyspace * next; }busyspace,*busy

主要程序代码分析

⑴主函数//代码请添加适当的注释。 int main() { Is=(idly)malloc(sizeof(idlyspace)); Is->from=0; Is->size=256; Is->next=NULL; Is2=Is; Bs=(busy)malloc(sizeof(busyspace)); Bs->next=NULL; int t,t1; printf(\"\\n.......................欢迎来到动态分区存储管理系统..................\\n\\n\"); printf(\"...........................请选择要执行的算法:...........................\\n\"); printf(\".........................1.最先适应算法

...............................\\n\"); printf(\".........................2.下次适应算法 ............................\\n\"); printf(\"..........................3.最优适应算法

...............................\\n\"); printf(\".........................4.最坏适应算法 ................................\\n\"); printf(\"........................................................................\\n\"); printf(\"请输入您的选择:\"); scanf(\"%d\",&t); int i; while(i!=5) {

printf(\"........................................................................\\n\");

printf(\".........................操作菜单如下：（请选择）.......................n\");

printf(\"..........................1.输入进程分配空间 ...........................n\");

printf(\".........................2.进程撤销回收空间 ...........................\\n\");

printf(\".........................3.输出所有空闲分区

..........................\\n\");

printf(\"..........................4.输出所有已分配分区..........................\\n\");

printf(\"..........................5.退

出 ..........................\\n\");

printf(\"........................................................................\\n\");

scanf(\"%d\",&i);

switch(i)

{

case 1:

switch(t)

{

case 1:

t1=FF();

9 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

break;

case 2:

t1=NF();

break;

case 3:

t1=BF();

break;

case 4:

t1=WF();

break;

default:

printf(\"选择算法错误\\n\");

return 1;

}

if(t1)

printf(\"分配空间成功\\n\");

else

printf(\"分配空间失败\\n\");

break;

case 2:

t1=recover();

if(t1)

printf(\"回收成功\\n\");

else

printf(\"回收失败\\n\");

break;

case 3:

Isprint();

break;

case 4:

Bsprint();

break;

} } return 0; }

第三章 ：分析并实现四种内存分配算法

最先适应算法

空闲区按地址从小到大的次序排列。

分配：当进程申请大小为 SIZE 的内存时，系统顺序查找空闲区表（链），直到找到容量满足要求（≥SIZE）的空闲区为止。从该空闲区中划出大小为 SIZE的分区分配给进程，余下的部分仍作为一个空闲区，但要修改其首址和大小。

10 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

优点：这种算法是尽可能地利用低地址部分的空闲区，而尽量地保证高地址 6部分的大空闲区，有利于大作业的装入。

缺点:主存低地址和高地址分区利用不均衡。在低地址部分集中了许多非常小的空闲区碎片降低了主存的利用率。 最先适应算法 int FF() { int t=0; readyque D; printf“\"请输入进程名:\\”\"); scanf“\"%”\",D.name);

printf“\"输入进程申请空间大小:\\”\"); scanf“\"%”\",&D.size);

idly l=Is; int mt=256; busy b=Bs; idly min=NULL; while(l)

//寻找空闲表中大小满足申请进程所需大小并且起址最小的空闲结点

{

if(D.sizesize)

{

if(l->from

{ mt=l->from; min=l; t=1;

}

}

l=l->next; } if(mt!=256)

{

busy j;

j=(busy)malloc(sizeof(busyspace));

//如果找到则为进程分配空间

11 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

j->from=min->from;

for(int i=0;i

{

j->r.name[i]=D.name[i];

}

j->r.size=D.size;

while(b->next)

{ if(b->next->fromfrom)

b=b->next; else

break;

}

j->next=b->next;

b->next=j;

min->from=min->from+D.size;

min->size=min->size-D.size; } return t; }

下次适应分配算法

最先适应算法的变种。

总是从空闲区上次扫描结束处顺序查找空闲区表（链），直到找到第一个满足容量要求的空闲区为止，分割一部分给作业，剩余部分仍作为空闲区。 下次适应分配算法 int NF() { int t=0; readyque D; printf“\"请输入进程名:\\”\"); scanf“\"%”\",D.name);

12 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

printf“\"输入进程申请空间大小:\\”\"); scanf“\"%”\",&D.size);

int mt=256; idly l=Is2; idly min=NULL; busy b=Bs; while(l) //寻找空闲表中大小满足申请进程所需大小并且起址最小的空闲结点

{

if(D.sizesize)

{

if(l->from

{ mt=l->from; min=l; t=1;

}

}

l=l->next; } if(mt!=256)

{

busy j;

j=(busy)malloc(sizeof(busyspace));

j->from=min->from;

for(int i=0;i

{

j->r.name[i]=D.name[i];

}

j->r.size=D.size;

while(b->next)

{ if(b->next->fromfrom)

b=b->next; else

break;

//如果找到则为进程分配空间

13 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

}

//将申请空间进程插入到已分配链表中

j->next=b->next;

b->next=j;

//修改相应空闲节点的起址和大小

min->from=min->from+D.size;

min->size=min->size-D.size;

Is2=min->next;

结点

t=1;

return t; }

l=Is;//l指向空闲表的头

while(l!=Is2)

{

if(D.sizesize)

{

if(l->from

{ mt=l->from; min=l; t=1;

}

}

l=l->next; } if(mt!=256) {

busy j;

j=(busy)malloc(sizeof(busyspace));

j->from=min->from;

for(int i=0;i

{

//ls2指向修改结点的下一个

//循环查找

14 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

j->r.name[i]=D.name[i];

}

j->r.size=D.size;

while(b->next)

{ if(b->next->fromfrom)

b=b->next; else

break;

}

j->next=b->next;

b->next=j;

min->from=min->from+D.size;

min->size=min->size-D.size;

Is2=min->next;

t=1;

return t; } return t; }

最优适应算法

空闲区按容量递增的次序排列。

分配：当进程申请存储空间，系统顺序查找空闲区表（链），直到找到第一个满足容量要求的空闲区为止。 采用最优适应算法选中的空闲区是满足容量要求的最小空闲区。 优点：选中的空闲区是满足容量要求的最小空闲区，而不致于毁掉较大的空闲区。

缺点：空闲区的大小一般与申请分区大小不相等，因此将其一分为二，留下来的空闲区一般情况下是很小的，以致无法使用。随着时间的推移，系统中的小空闲区会越来越多，从而造成存储空间的浪费。 最优适应算法 int BF() { int t=0;

15 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

readyque D; printf“\"请输入进程名:\\”\"); scanf“\"%”\",D.name);

printf“\"输入进程申请空间大小:\\”\"); scanf“\"%”\",&D.size);

idly l=Is; idly min=NULL; int mt=256; busy b=Bs; while(l) //在空闲链中寻找第一个大于所输入的进程大小的空闲块

{

if(D.sizesize)

{

if(l->size

{

mt=l->size; min=l; t=1;

}

}

l=l->next; } if(mt!=256)

{

busy j;

j=(busy)malloc(sizeof(busyspace)); 空间

j->from=min->from;

//申请分配用于存放进程的内存

//找到第一个满足要求的空闲块

//将第一个满足要求的空闲块（min）的首地址赋给j

for(int i=0;i

{

j->r.name[i]=D.name[i]; 16 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

}

j->r.size=D.size;

while(b->next)

//按从小到大的顺序查找新进程在已分配区中的位置

{ if(b->next->fromfrom)

b=b->next; else

break;

}

j->next=b->next;

b->next=j;

min->from=min->from+D.size;

min->size=min->size-D.size;

} return t; }

最坏适应算法

为了克服最佳适应算法把空闲区切割得太小的缺点，人们提出了一种最坏适应算法，即每次分配时，总是将最大的空闲区切去一部分分配给请求者，剩余的部分仍是一个较大的空闲区。避免了空闲区越分越小的问题。 要求空闲区按容量递减的顺序排列。

分配：进程申请存储区时，检查空闲区表（链）的第一个空闲区的大小是否满足要求，若不满足则令进程等待；若满足则从该空闲区中分配一部分存储区给用户，剩下的部分仍作为空闲区。 最坏适应算法 int WF() { int t=0; readyque D; printf“\"请输入进程名:\\”\"); scanf“\"%”\",D.name);

printf“\"输入进程申请空间大小:\\”\");

//将所输入的进程插入进程链

//改变该空闲块的起始地址 //改变该空闲块的剩余大小 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

scanf“\"%”\",&D.size);

//输入进程申请的空间大小

idly l=Is;//l指向空闲链表ls头

idly min=NULL; int mt=0; busy b=Bs;

//b指向已分配链表Bs头

//找到空闲分区中大小满足进程的请求且尺寸最大的结点

while(l) {

if(D.sizesize) //判断进程所申请的大小是否小于空闲区的各结点大小

{

if(l->size>mt)

{ mt=l->size; min=l;//min指向空闲区中尺寸最大的结点

t=1;

}

}

l=l->next; } if(mt!=0) 点

{

busy j;

j=(busy)malloc(sizeof(busyspace));

j->from=min->from;

for(int i=0;i

{

j->r.name[i]=D.name[i];

}

j->r.size=D.size;

//判断是否找到了空闲区的满足结

//l指向空闲链表下一个结点

18 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

while(b->next) 置

//寻找插入到已分配链表中的位

{ if(b->next->fromfrom)

b=b->next; else

break;

}

//把此进程结点j插入到已分配链表中

j->next=b->next;

b->next=j;

//修改空闲链表的相应结点的参数

min->from=min->from+D.size;

min->size=min->size-D.size; } return t; }

可变分区的回收

当某个进程释放某存储区时，系统首先检查释放区是否与系统中的空闲区相邻若相邻则把释放区合并到相邻的空闲区去，否则把释放区作为一个空闲区插入到空闲表的适当位置。

释放区与空闲区相邻的四种情况。

（1） 释放区与前空闲区相邻：把释放区与前空闲区合并到一个空闲区。其首址仍为前空闲区首址，大小为释放区大小与空闲区大小之和。

（2） 释放区与后空闲区相邻：则把释放区合并到后空闲区，其首地址为释放区首地址，大小为二者之和。

（3） 释放区与前后两空闲区相邻：这三个区合为一个空闲区，首地址为前空闲区首址，大小为这三个空闲区之和，并取消后空闲区表目。

（4） 释放区不与任何空闲区相邻：将释放区作为一个空闲区，将其大小和首址插入到空闲区表的适当位置。

19 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

回收内存算法

int recover() { readyque D; printf“\"请输入想要回收的进程名\\”\");

scanf“\"%”\",D.name);

busy b=Bs; idly l=Is; while(b->next) 链表中

{

bool yo=1;

for(int i=0;i

{

if(b->next->r.name[i]==D.name[i]) yo=yo*1;

else yo=0;

}

//如果在已分配链表中则释放该结点所占空间

if(yo)

{

int t=b->next->from;

int ts=b->next->r.size;

//查找输入的进程名是否在已分配湖北民族学院信息工程学院11级计算机专业操作系统课程设计

while(l)

{ if(l->from>t+ts) 不邻接

{ idly tl; tl=(idly)malloc(sizeof(idlyspace)); tl->from=t; tl->size=ts; tl->next=l; Is=tl; break; } if(l->from==t+ts)

l->from=t;

l->size=l->size+ts;

busy tb=b->next;

b->next=b->next->next;

free(tb);

return 1; }

if(l->from+l->size

idly tl;

tl=(idly)malloc(sizeof(idlyspace));

tl->from=t;

tl->size=ts;

tl->next=l->next;

l->next=tl;

break; }

else if(l->from+l->size==t)

//所回收进程与空闲结点上邻接 {

//所回收进程与空闲结点上下都不邻接

//所回收进程与空闲结点下邻接 {

//所回收进程与空闲结点上下都 21 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

l->size=l->size+ts;

if(l->from+l->size==l->next->from) 接

{

l->size=l->size+l->next->size;

idly tm=l->next;

l->next=l->next->next;

freI);

}

br

l=l->next;

}

//从已分配链表中释放所回收进程

busy tb=b->next;

b->next=b->next->next;

free(tb);

return 1;

}

b=b->next; } printf(\"没找到这”进程\\n\"); return 0; }

//所回收进程与空闲结点上下都邻调试与操作说明

初始界面

程序初始界面，有四个块选择，选择要执行的算法，调试以最坏算法为例，如图

22 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

选择最坏适应算法，如图

模拟内存分配

给进程a分配内存20，如图

23 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

已分配分区说明表界面

同理，给进程b分配内存30，给进程c分配内存40，给进程d分配50，给进程e分配60，如图

空闲分区说明表界面

24 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

查看空闲分区，如图

回收内存界面

回收进程b和d所占内存，如图

已分配分区说明表和空闲分区说明表 如图

25 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

重新申请内存界面

再为新进程i分配内存30，如图

26 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

根据最坏适应算法结合图所示可知，该算法将会从空闲分区表中选择一块最大的内存空间分配给进程i，从图也可看出该模拟算法实现了最坏适应算法

27 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

总结与体会

本次做的课题是动态分区分配算法实现，此次课程设计成功实现了内存分配和内存回收，内存分配中包含了四种算法，分别是首次适应算法，循环首次适应算法，最佳适应算法和最坏适应算法。经编码调试，表明该程序模块是有效可行的。

通过这门课程的学习让我充分了解了内存管理的机制实现，从而更深一步的的对计算机

有了很多了解，这对于以后我们的研究和学习计算机系统起到了很重要的作用。

对于本次论文制作，自己的编程能力有所提高，对操作系统内存分配，存储空间的回收都有全新的认识。

在这次操作系统课程设计中，我使用了c++编写系统软件，对os中可变分区存储管理有了深刻的理解，但是过程中遇到了很多困难，一边做一边学，对c++有了比较多的理解。

实验中遇到很多问题，浪费了很多时间，总而言之是自己学习还不够好，不扎实，希望在以后学习中加以改善，学到更多知识。

参考文献

【1】 汤子瀛，哲凤屏，汤小丹.计算机操作系统.西安：西安电子科技大学出版社，2001.。

28 湖北民族学院信息工程学院11级计算机专业操作系统课程设计

【2】 任爱华.操作系统实用教程.北京：清华大学出版社，2001。

29

第12篇：操作系统课程设计

《操作系统》/《操作系统课程设计》课设指导书

《操作系统》 《操作系统课程设计》

指导

信息技术学院课设书

《操作系统》/《操作系统课程设计》课设指导书

《操作系统》/《操作系统课程设计》

课设项目指导书

课设项目1 磁盘调度算法程序设计

一、目的

磁盘是经常使用的一种重要的外设，对磁盘数据的寻道时间的长短直接影响机器的整体运行速度，本设计要求用C语言（或高级语言）编写程序模拟实现磁盘调度的常用算法。以加深对磁盘调度常用算法的理解和实现技巧。

二、课设要求

1）、设计一个函数完成先来先服务的磁盘调度功能。 2）、设计一个函数完成最短寻道时间优先的磁盘调度功能。 3）、设计一个函数完成电梯算法的磁盘调度功能。

三、课设设备、环境

奔腾以上计算机，装有Turbo C 2.0软件

四、课设方法及步骤

1、设计方法：

根据设计任务书的要求，画出程序设计流程图，确定程序的功能，把整个程序根据功能要求分解为各个子程序，利用TC语言分编写程序代码，然后进行上机调试、修改、进行连接，测试，写出设计总结报告。

2、设计步骤：

1）、自定义磁盘调度相关的数据结构。

2）、依据先来先服务算法（FCFS）、最短寻道优先算法（SSTF）、扫描(SCAN，也称电梯)算法的原理，编写对应函数，模拟系统的磁盘调度服务。

3）、为了更好地模拟和评价算法的性能，随机产生需寻道的磁道序列，磁道序列的首磁道为磁头的当前位置；在SCAN算法中，允许用户指定当前寻道方向。

4）、统计各算法总寻道次数和平均寻道距离；分析各算法性能，并作出评价。 5）、设计要求一人单独进行，独立完成设计，上机进行运行调试。 6）、写出课程设计报告书。

课设项目2 进程调度程序设计

一、目的

进程调度是处理机管理的核心内容。本设计要求用C语言编写和调试一个简单的进程调度程序。通过设计本可以加深理解有关进程控制块、进程队列的概念，并体会和了解最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法的具体实施办法。

二、课设要求

1）进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。

2）每个进程有一个进程控制块（ PCB）表示。进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。

3）进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。进程的到达时间为进程输入的时间。 进程的运行时间以时间片为单位进行计算。

4）每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。

5）就绪进程获得 CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。

6）每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。

7）重复以上过程，直到所要进程都完成为止。

三、课设设备、环境

奔腾以上计算机，装有Turbo C 2.0软件

四、课设方法及步骤

1、设计方法：

根据设计任务书的要求，画出程序设计流程图，确定进程调度程序的功能，把整个程序根据功能要求分解为各个子程序，利用TC语言分编写程序代码，然后进行上机调试、修改、进行连接，测试，写出设计总结报告。

《操作系统》/《操作系统课程设计》课设指导书

进程调度算法参考流程图

2、设计步骤：

1）充分了解各项设计要求。深入理解有关进程控制块、进程队列的概念，并体会和了解最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法的具体实施办法。

2）、按要求对进程调度程序进行分解，根据功能将其分解成多个子模块。

3）、建立主控模块程序流程图及各功能子模块程序流程图，要求条理清楚、简单明了、功能完备。

4）、根据流程图编制主程序代码及子程序代码。要求程序设计结构清晰，简洁，便于修改和调试。

5）、上述设计要求一人单独进行，独立完成设计。 6）、设计完成后，上机进行运行调试。

7）、程序运行成功，然后进行某些功能测试，选择有实用性、特殊性的数据进行录入调试，使设计进一步得到改进并完善。

8）、打印出程序运行结果，并对结果进行分析，验证程序设计的正确性。 9）、写出课程设计报告书。

《操作系统》/《操作系统课程设计》课设指导书

课设项目3 银行家算法程序设计

一、目的

银行家算法是避免死锁的一种重要方法，本设计要求用C语言（或高级语言）编写和调试一个简单的银行家算法程序。加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。通过对这个算法的设计,让学生能够对书本知识有更深的理解,在操作和其它方面有更高的提升,同时对程序设计的水平也有所提高。

二、课设要求

设计一个n个并发进程共享m个系统资源的程序实现银行家算法。要求包含： 1）、简单的选择界面。

2）、前系统资源的占用和剩余情况。

3）、为进程分配资源，如果进程要求的资源大于系统剩余的资源，不与分配并且提示分配不成功。

4）、撤销作业，释放资源。

三、课设设备、环境

奔腾以上计算机，装有Turbo C 2.0软件

四、课设方法及步骤

1、设计方法：

根据设计任务书的要求，画出程序设计流程图，确定程序的功能，把整个程序根据功能 要求分解为各个子程序，利用TC语言分编写程序代码，然后进行上机调试、修改、进行连接，测试，写出设计总结报告。

2、设计步骤：

1）、充分了解各项设计要求。深入理解多道程序系统中，进程并发执行的资源分配问题，和系统安全状态的概念。了解资源在进程并发执行中的资源分配策略并体会和掌握银行家算法的具体实现。

2）、按要求对进程调度程序进行分解，根据功能将其分解成多个子模块。

3）、模块程序流程图及各功能子模块程序流程图，要求条理清楚、简单明了、功能完备。 4）、根据流程图编制主程序代码及子程序代码。要求程序设计结构清晰，简洁，便于修改和调试。

5）、上述设计要求一人单独进行，独立完成设计。 6）、设计完成后，上机进行运行调试。

7）、程序运行成功，然后进行某些功能测试，选择有实用性、特殊性的数据进行录入调

试，使设计进一步得到改进并完善。

8）、打印出程序运行结果，并对结果进行分析，验证程序设计的正确性。 9）、设计报告书。

3、算法描述

设Request[i] 是进程Pi的请求向量，如果Requesti[j]=K,表示进程Pi需要K个Rj类型的资源，当Pi发出资源请求后，系统按下面步骤进行检查：

1）、如果Requesti[j]

2）、如果Requesti[j]

3）、系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：

Available[j]:=Available[j]-Requesti[j]; Allocation[i,j]:=Allocation[i,j]+Requesti[j]; Need[i,j]:=Need[i,j]-Requesti[j];

4）、系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。若安全，才 正式将资源分配给进程Pi，以完成本次分配；否则，将本次的试探分配作废，恢复原来 的资源分配状态，让进程Pi等待。

4、数据结构

银行家算法中的数据结构：

1）、可利用资源向量Available。这是一个含有n个元素的数组，其中的每一个元素代表一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源的数目，其数值随该类资源的分配和回收而动态地改变。如果Available[j]=K,则表示系统中现有Rj类资源K个。

2）、最大需求矩阵Max。这是一个m*n的矩阵，它定义了系统中n个进程中每一个进程对m类资源的最大需求。如果Max[i,j]=K,则表示进程i需要Rj类资源的最大数目为K。 3）、分配矩阵Allocation。这也是一个m*n的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。如果Allocation[i,j]=K,则表示进程i当前已分得Rj类资源的数目为K。

4）、需求矩阵Need。这也是一个n*m的矩阵，用以表示每一个进程尚需的各类资源数。如果Need[i,j]=K,则表示进程i还需要Rj类资源K个，方能完成其任务。

5）、工作数组Work.。这是一个含有n个元素的数组，它代表可以提供分配的资源数，初始值是Available中的数值，随着资源的回收，它的值也会改变，公式是 6

《操作系统》/《操作系统课程设计》课设指导书

Work[i]=Work[i]+Allocation[i]。

课设项目4 存储管理程序设计

一、目的

存储管理的主要功能之一是合理地分配空间。请求页式管理是一种常用的虚拟存储管理技术。本次设计的目的是通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式管理的页面置换算法。

二、课设要求

设计一个请求页式存储管理方案。并编写模拟程序实现之。要求包含： 1．过随机数产生一个指令序列，共320条指令。其地址按下述原则生成： ①50%的指令是顺序执行的；

②25%的指令是均匀分布在前地址部分； ③25%的指令是均匀分布在后地址部分； #具体的实施方法是：

A.在[0，319]的指令地址之间随机选区一起点M; B.顺序执行一条指令，即执行地址为M+1的指令；

C.在前地址[0，M+1]中随机选取一条指令并执行，该指令的地址为M’; D.顺序执行一条指令，其地址为M’+1；

E.在后地址[M’+2，319]中随机选取一条指令并执行； F.重复A—E，直到执行320次指令。 2．指令序列变换成页地址流

设：（1）页面大小为1K；

（2） 用户内存容量为4页到32页； （3） 用户虚存容量为32K。

在用户虚存中，按每K存放10条指令排列虚存地址，即320条指令在虚存中的存放方式为：

第0条—第9条指令为第0页（对应虚存地址为[0，9]）；

第10条—第19条指令为第1页（对应虚存地址为[10，19]）；

。。。。。。。。。。。。。。。。。。。。。

第310条—第319条指令为第31页（对应虚存地址为[310，319]）； 按以上方式，用户指令可组成32页。

3.计算并输出下述各种算法在不同内存容量下的命中率。

《操作系统》/《操作系统课程设计》课设指导书

A.FIFO先进先出的算法 B.LRR最近最少使用算法

C.OPT最佳淘汰算法（先淘汰最不常用的页地址） D.LFR最少访问页面算法 E.NUR最近最不经常使用算法

三、课设设备、环境

奔腾以上计算机，装有Turbo C 2.0软件

四、课设方法及步骤

1、设计方法：

根据设计任务书的要求，画出程序设计流程图，确定程序的功能，把整个程序根据功能要求分解为各个子程序，利用TC语言分编写程序代码，然后进行上机调试、修改、进行连接，测试，写出设计总结报告。

2、设计步骤：

1）、充分了解各项设计要求。深入理解有关页表、页面置换的概念，并体会和了解先进先出页面置换算法、先来先服务算法的具体实施办法。

2）、按要求对存储管理程序进行分解，根据功能将其分解成多个子模块。

3）、建立主控模块程序流程图及各功能子模块程序流程图，要求条理清楚、简单明了、功能完备。

4）、根据流程图编制主程序代码及子程序代码。要求程序设计结构清晰，简洁，便于修改和调试。

5）、上述设计要求一人单独进行，独立完成设计。 6）、设计完成后，上机进行运行调试。

7）、程序运行成功，然后进行某些功能测试，选择有实用性、特殊性的数据进行录入调试，使设计进一步得到改进并完善。

8）、打印出程序运行结果，并对结果进行分析，验证程序设计的正确性。 9）、写出课程设计报告书。

课设项目5 文件系统程序设计

一、目的

本设计要求用C语言编写和调试一个简单的文件系统，模拟文件管理的工作过程。本次课程设计的目的是通过一个简单多用户文件系统的设计，加深理解文件系统的内部功能和内部实现。

二、课设要求

要求设计一个 n个用户的文件系统，每次用户可保存m个文件，用户在一次运行中只能打开一个文件，对文件必须设置保护措施，且至少有Create、delete、open、close、read、write等命令。要求包含：

1）设计一个10个用户的文件系统，每次用户可保存10个文件，一次运行用户可以打开5个文件。

2）程序采用二级文件目录（即设置主目录[MFD]）和用户文件目录（UED）。另外，为打开文件设置了运行文件目录（AFD）。

3）为了便于实现，对文件的读写作了简化，在执行读写命令时，只需改读写指针，并不进行实际的读写操作。

4）可以实现下列几条命令

LOGIN 用户登陆 DIR 列文件目录 CREATE 创建文件 DELETE 删除文件 OPEN 打开文件 CLOSE 关闭文件 READ 读文件 WRITE 写文件

5）因系统小，文件目录的检索可使用简单的线性搜索。

三、课设设备、环境

奔腾以上计算机，装有Turbo C 2.0软件

四、课设方法及步骤

1、设计方法：

《操作系统》/《操作系统课程设计》课设指导书

根据设计任务书的要求，画出程序设计流程图，确定程序的功能，把整个程序根据功能要求分解为各个子程序，利用TC语言分编写程序代码，然后进行上机调试、修改、进行连接，测试，写出设计总结报告。

2、设计步骤：

1）、充分了解各项设计要求。深入理解有关文件控制块、目录的概念，并体会和了解目录管理的具体实施办法。

2）、按要求对进程调度程序进行分解，根据功能将其分解成多个子模块。

3）、建立主控模块程序流程图及各功能子模块程序流程图，要求条理清楚、简单明了、功能完备。

4）、根据流程图编制主程序代码及子程序代码。要求程序设计结构清晰，简洁，便于修改和调试。

5）、上述设计要求一人单独进行，独立完成设计。 6）、设计完成后，上机进行运行调试。

7）、程序运行成功，然后进行某些功能测试，选择有实用性、特殊性的数据进行录入调试，使设计进一步得到改进并完善。

8）、打印出程序运行结果，并对结果进行分析，验证程序设计的正确性。 9）、写出课程设计报告书。

第13篇：操作系统课程设计

1 引言

操作系统是计算机科学与技术专业的主要专业基础课和主干课。操作系统对计算机系统资源实施管理，是所有其他软件与计算机硬件的唯一接口，所有用户在使用计算机时都要得到操作系统提供的服务。

通过模拟操作系统的全部或者部分功能的实现，加深对操作系统工作原理和操作系统实现方法的理解，达到练习编程的目的，提高学生运用理论知识分析问题、解决问题的能力，为学生从事科学研究和独立负担计算机及其应用方面的工作打好扎实的基础。

0 河北大学工商学院2011级操作系统课程设计论文（设计）

2 课程设计任务及要求

2.1 设计任务

模拟采用多道程序设计方法的单用户操作系统，该操作系统包括进程管理、存储管理、设备管理、文件管理和用户接口四部分。

本部分要求实现文件的逻辑结构、文件的物理结构、目录结构、磁盘分配和回收、文件的保护和用户接口。

2.2 实现方法和原理

2.2.1文件的逻辑结构：

文件的逻辑结构采用流式结构； 文件均采用文本文件；

系统中有两种文件，一种是存放任意字符的文件，一种是可执行文件。可执行文件的内容就是模拟系统内进程的程序体。

文件中要有一种特定命令的“可执行”文件，文件中的命令非常简单，包括： x=?;

给x赋值一位数 x++;

x加1 x--;

x减1 !??；

第一个？为A,B,C中某个设备，第二个？为一位数，表示使用设备的时间（由于没有实际设备，所以无法知道设备何时工作完成，所以假定一个数，这个数随着系统时间增加而递减，减到0时，认为是设备工作完成）；

end.

表示文件结束，同时将结果写入文件out，其中包括文件路径名和x的值。 2.2.2 磁盘模拟：

用一个文件disk模拟磁盘，磁盘的每个盘块64字节，模拟磁盘共有128块。第0、1块存放文件分配表，第2块存放根目录，其余存放子目录和文件。 2.2.3目录结构

目录结构采用树型目录结构，目录项内容共十六个字节。 ①目录项内容（8个字节）： 目录名、文件名：3个字节；

1 河北大学工商学院2011级操作系统课程设计论文（设计）

扩展名：1个字节（可执行文件扩展名为e，目录没有扩展名）； 目录、文件属性：1字节； 起始盘块号：1个字节；

文件长度：2字节（目录没有长度）。 ②根目录

根目录位置固定，为磁盘第2块，大小固定，共8项，占用模拟磁盘第2块； ③子目录

位置不固定，大小不固定。 2.2.4磁盘分配

磁盘的分配采用链接结构（显式链接）的分配方式。系统采用文件分配表方式记录磁盘空间的使用情况和链接结构的指针。

因为磁盘有占用磁盘由128块，所以文件分配表中一项需要1字节，而磁盘由128块，因而需要128项，所以模拟磁盘空间中的第0、1块被用来存放文件分配表。 2.2.5用户接口

用户接口提供用户命令接口，要求实现以下命令： 创建文件：create 拷贝文件：copy 删除文件：delete 移动文件：move 显示文件：type 编辑文件：edit 改变文件属性：change 磁盘格式化命令 format 建立目录：makdir 改变目录路径：chadir

删除空目录：rdir 删除目录：deldir（既可删除空目录又可删除非空目录）

2 河北大学工商学院2011级操作系统课程设计论文（设计）

磁盘分区命令：fdisk 运行可执行文件：可执行文件的文件名（可创建进程）。

上述命令在实际系统中都是需要建立进程才可以实现的，这里由于模拟系统的能力达不到，所以除运行可执行文件需要建立进程外，其他指令执行不必在模拟系统中建立进程，可直接执行。

注意打开文件表。 2.2.6屏幕显示

如图所示，屏幕显示要求包括：

用户命令接口，用于系统运行时用户输入命令； 磁盘目录显示，要求显示磁盘的树型目录结构；

磁盘使用情况，显示磁盘每一个磁盘块的空间是占用还是空闲。

3程序设计与实现

3.1目录结构的实现

3.1.1创建目录

#region CreateMenu(建立目录)

public void CreateMenu(string pathname,string harddisk) 3.1.2删除空目录

删除空目录首先要找到该目录，如果目录不存在，执行指令失败；如果存在，但是根

3 河北大学工商学院2011级操作系统课程设计论文（设计）

目录或非空目录显示不能删除，操作失败；若是非空子目录，则删除器目录项并回收对应空间。删除空目录的过程和删除文件的过程相似。

3.1.3删除目录

#region DeleteMenu(删除目录)

public void DeleteMenu(string pathname, string harddisk)

{

if (Search(pathname,harddisk) == 1)

{

MeageBox.Show(\"文件路径不正确！\", \"注意\", MeageBoxButtons.OK, MeageBoxIcon.Exclamation); 3.2文件 3.2.1创建文件

#region CreateFile(建立文件) public void CreateFile(string pathname, byte attribute, byte addre, char length, string harddisk) {

if (attribute == 3 || attribute == 5) {

MeageBox.Show(\"只读性质，建立失败！\", \"注意\", MeageBoxButtons.OK,

MeageBoxIcon.Exclamation);

return; } 3.2.2拷贝文件

#region CopyFile(复制文件,只复制FCB)

public void CopyFile(string pathname1, string pathname2, string harddisk)

{

string[] pnames = pathname1.Split(new char[] { \'\\\', \'.\' });

string halfpathname = pathname1.Remove(pathname1.Length1]);

UTF8Encoding utf = new UTF8Encoding(); 4 河北大学工商学院2011级操作系统课程设计论文（设计）

byte[] name = utf.GetBytes(pnames[pnames.Length1];

CreateFile(pathname2, buffer.Attribute, buffer.Addre, buffer.Length,harddisk);

}

#endregion 3.2.3删除文件 #region DeleteFile(删除文件)

public void DeleteFile(string pathname, string harddisk)

{

if(Search(pathname,harddisk)==1)

{

MeageBox.Show(\"文件路径不正确！\", \"注意\", MeageBoxButtons.OK, MeageBoxIcon.Exclamation);

return;

}

else if (Search(pathname,harddisk) == 2)

//文件存在

{

string[] pnames = pathname.Split(new char[] { \'\\\', \'.\' });

string halfpathname = pathname.Remove(pathname.Length2]);

int disknum;

if (pnames.Length == 3)

//c:\\aaa.t

{

disknum = 3;

}

else

{

disknum = Search(halfpathname,harddisk);

}

int item = FindItem(disknum, name, attribute,harddisk)[0];

int addre = FindItem(disknum, name, attribute,harddisk)[1];

byte addr = Convert.ToByte(addre);

DeleteFCB(disknum, item,harddisk);

//删除FCB

if(addr==0)

{

return; 3.2.4移动文件

#region CutFile(移动文件)

public void CutFile(string pathname1, string pathname2, string harddisk)

{

CopyFile(pathname1, pathname2,harddisk); //复制FCB到新目录下

string[] pnames = pathname1.Split(new char[] { \'\\\', \'.\' });

string halfpathname = pathname1.Remove(pathname1.Length1]);

UTF8Encoding utf = new UTF8Encoding(); 6 河北大学工商学院2011级操作系统课程设计论文（设计）

byte[] name = utf.GetBytes(pnames[pnames.Length1) + 8 * (Itemnumber - 1), SeekOrigin.Begin);

Disk.Write(buffer.Name, 0, buffer.Name.Length);

Disk.Seek(0, SeekOrigin.Current);

Disk.WriteByte(buffer.Type);

Disk.Seek(0, SeekOrigin.Current);

Disk.WriteByte(buffer.Attribute);

Disk.Seek(0, SeekOrigin.Current);

Disk.WriteByte(buffer.Addre); 7 河北大学工商学院2011级操作系统课程设计论文（设计）

Disk.Seek(0, SeekOrigin.Current);

Disk.WriteByte(Convert.ToByte(buffer.Length));

}

Disk.Close();

}

#endregion

3.2.7显示文件

#region ReadFile(读文件画节点)

public void ReadFile(TreeView treeView, ContextMenuStrip contextMenuStrip,ImageList imageList)

{

treeView.Nodes.Clear();

//删除集合中所有树节点

//重新添加树节点

treeView.ImageList = imageList;

TreeNode root = new TreeNode(\"计算机\", 0, 0);

TreeNode node_C = new TreeNode(\"本地磁盘C\", 4, 4);

TreeNode node_D = new TreeNode(\"本地磁盘D\", 4, 4);

node_C.ContextMenuStrip = contextMenuStrip;

node_D.ContextMenuStrip = contextMenuStrip;

treeView.Nodes.Add(root);

root.Nodes.Add(node_C);

root.Nodes.Add(node_D);

DrawTree(node_C, 3,\"disk1.txt\",contextMenuStrip);

DrawTree(node_D, 3, \"disk2.txt\",contextMenuStrip);

treeView.ExpandAll();

}

#endregion

4.程序运行部分截图

4.1主页面

8 河北大学工商学院2011级操作系统课程设计论文（设计）

4.2创建文件

4.3编辑文件

9 河北大学工商学院2011级操作系统课程设计论文（设计）

4.4创建目录

5 总结

在此系统我主要模拟的是文件部分。通过编写此系统，采用了c#语言。但是，在实现此系统中，一方面因为我对c#这门语言掌握的不是很熟练，另外一方面，对操作系统理解的不够深入以至于部分功能没有实现，让我发现了自己的不足，从而要在以后的学习中更加努力，不短提高自己个方面的能力。

10 河北大学工商学院2011级操作系统课程设计论文（设计）

装

订

第14篇：操作系统课程设计

课程实验报告

课程名称：

操作系统原理课程设计

专业班级： 学

号： 姓

名 指导教师： 报告日期：

计算机科学与技术学院

目录

1.实验目的 ............................................................................................................................4 2.实验环境 ..........................................................................................................................4 3.实验内容 ..........................................................................................................................4 3.1 实验一 ....................................................................................................................4 3.2 实验二 ....................................................................................................................4 3.3 实验三 ....................................................................................................................5 3.4 实验四 ....................................................................................................................5 4.实验设计 ..........................................................................................................................5 4.1 实验一 ....................................................................................................................5 4.1.1 文件拷贝 ......................................................................................................5 4.1.2 并发进程分窗口显示 ....................................................................................5 4.2 实验二 ....................................................................................................................6 .....................................................................................................................................6 4.3 实验三 ....................................................................................................................6 4.4 实验四 ....................................................................................................................7 5.实验步骤 ..........................................................................................................................8 5.1 实验一 .............................................................................................................8 5.1.1 文件拷贝 ......................................................................................................8 5.1.2 并发进程分窗口显示 ....................................................................................9 5.2 实验二 ..................................................................................................................14 5.3 实验三 ..................................................................................................................15 2 5.4 实验四 ..................................................................................................................17 6.调试记录 ........................................................................................................................19 7.心得体会 ........................................................................................................................21 8.程序清单 ........................................................................................................................22 8.1实验一 ...................................................................................................................22 8.1.1 文件拷贝 ....................................................................................................22 8.1.2并发进程窗口显示 ......................................................................................23 8.2实验二 ...................................................................................................................33 8.3实验三 ...................................................................................................................34 8.4实验四 ...................................................................................................................38

1.实验目的

（1）掌握Linux操作系统的使用方法； （2）了解Linux系统内核代码结构； （3）掌握实例操作系统的实现方法。

2.实验环境

本次课程设计采用的操作系统环境是Windows

7、Ubuntu双系统，Ubuntu系统版本为15.04，内核版本是Linux 3.19。

3.实验内容

3.1 实验一

1)编写一个C程序，用fread、fwrite等库函数实现文件拷贝功能。

2)编写一个C程序，使用基于文本的终端图形编程库(curses)或图形界面(QT/GTK），分窗口显示三个并发进程的运行(一个窗口实时显示当前时间，一个窗口实时监测CPU的利用率，一个窗口做1到100的累加求和，刷新周期分别为1秒，2秒和3秒)。

3.2 实验二

4 采用编译内核的方法，添加一个新的系统调用实现文件拷贝功能 编写一个应用程序，测试新加的系统调用

3.3 实验三

采用模块方法，添加一个新的字符设备的驱动程序，实现打开/关闭、读/写等基本操作,编写一个应用程序，测试添加的驱动程序。

3.4 实验四

1)了解/proc文件的特点和使用方法。 2)监控系统状态，显示系统部件的使用情况。

3)用图形界面监控系统状态，包括CPU和内存利用率、所有进程信息等(可自己补充、添加其他功能)。

4.实验设计

4.1 实验一

4.1.1 文件拷贝

实现文件拷贝功能需要使用的函数是fopen、fgetc、fputc,由命令行参数获取2个文件名，根据其文件名和路径分别打开该2个文件，设置循环，使用fgetc和fputc函数每次从源文件复制1个字节到目的文件，直到源文件指针到文件尾，实现文件拷贝操作。 4.1.2 并发进程分窗口显示

5 使用图形界面GTK实现窗口的显示，使用fork（）创建三个并发进程： pid=fork()：创建子进程。

返回值:0

从子进程返回 >0

从父进程返回

exit进程自我终止，进入僵死状态 wait( ) 等待进程终止(由父进程调用) exec( ) 执行一个可执行程序(文件)。

4.2 实验二

不同的Linux内核版本编译内核和添加系统调用的方法不尽相同，在网上查阅了资料之后找到适合3.19版本内核的编译方法。

所谓系统调用，即Linux内核中设置了一组用于实现各种系统功能的子程序，称为系统调用，用户可以通过系统调用命令在自己的应用程序中调用它们。其调用机制为：使用寄存器中适当的值跳转到内核中事先定义好的代码中执行：跳转到系统调用的总入口system_call，检查系统调用号，再查找系统调用表sys_call_table，调用内核函数，最后返回。

实验二目的是更改内核中系统调用模块，增加自定义函数实现文件拷贝功能。

4.3 实验三

Linux设备驱动程序是一组常驻内存的具有特权的共享库，是低级硬件处理例程，每个设备文件有两个设备号，主设备号标识驱动程序，从设备号表示使用 6 同一个设备驱动程序的不同硬件设备。

设备驱动程序的功能包括：对设备初始化和释放，把数据从内核传送到硬件和从硬件读取数据，读取应用程序传给设备文件的数据和回送应用程序请求的数据，检测和处理设备出现的错误 。

Linux支持的设备包括三种：字符设备、块设备和网络设备。 添加设备驱动程序大致需要以下几个步骤：

1.注册设备 2.定义功能函数 3.卸载设备

4.4 实验四

proc文件系统特点：

1.进程文件系统和内核文件系统组成的复合体

2.将内核数据对象化为文件形式进行存取的一种内存文件系统

3.监控内核的一种用户接口，拥有一些特殊的纯文本文件，从中可以获取系统状态信息

4.系统信息：与进程无关，随系统配置的不同而不同 5.进程信息：系统中正在运行的每一个用户级进程的信息 其中各个文件保存的信息如下： /proc/cmd/line: 内核启动的命令行 /proc/cpuinfo: CPU信息

/proc/stat: CPU的使用情况、磁盘、页面、交换、所有的中断、最后一次的启动 7 时间等

/proc/meminfo: 内存状态的有关信息

利用/proc文件获取系统状态信息，并通过GTK图形化编程将系统信息以及通过这些信息计算得出的如CPU利用率、内存使用等通过窗口显示出来。

5.实验步骤

5.1 实验一

5.1.1 文件拷贝

文件拷贝主要是利用文件指针操作，在源文件和目的文件之间进行字符的复制，拷贝之前要判断源文件是否存在以及能否打开，这需要设置一个判断语句，同时也要设置判断语句判断目的文件是否存在，若不存在需要能够创建一个目的文件，最后执行循环拷贝。

步骤如下：

1.在Linux终端使用编译命令：gcc mycopy.c -o mycopy产生可执行文件。 2.创建源文件wangzihao目的文件shaochongjun。 3.编辑源文件：

8

4.打开可执行程序：./mycopy wangzihao shaochongjun 5.查看目的文件发现已经实现拷贝：

6.若源文件不存在会报错：

5.1.2 并发进程分窗口显示

1.使用fork（）函数创建三个进程，使用exec函数族实现程序的调用：

2.调用创建窗口函数init_window()，将进程中的信息在窗口中显示：

3.分别创建三个程序实现显示系统时间、CPU利用率、累加求和功能：

4.运行结果如下：

12

5.2 实验二

原内核版本：3.19.0 编译新内核版本：3.19.8 1.下载内核并解压

2.系统调用函数实现：修改kernel/sys.c文件，在文件的最后添加新的系统调用函数：sys_mycall(char* sourceFile,char* destFile) 3.设置系统调用号：修改arch/x86/syscalls/syscall_32.tbl，在最后一行添加新的系统调用号

4.添加系统调用声明到头文件 ：~$ vi include/asm-generic/syscalls.h 在#endif前添

#ifndef sys_mycall asmlinkage long sys_mycall(long number); #endif

5.安装基本编译套件：apt-get install build -eential kernal-package libncurses5-dev fakeroot 6.配置内核：make menuconfig 7.编译内核：make -j4 8.安装内核：make modules_install make install 9.重启进入新的内核

10.编写测试程序测试新的系统调用：

测试结果如下：

5.3 实验三

1.编写Makefile文件：

2.编写设备功能函数：(见程序清单)

3.设备加载：make clean make

加载模块：insmod wzhdriver.ko

输入 cat /proc/devices得 设备驱动的主设备号为:

15

加载 设备，分配设备号：mknod /dev/wzhdriver c 248 0

更改操作权限：chmod 666 /dev/wzhdriver 4.运行测试程序，结果：

5.4 实验四

1系统信息页：

2进程信息页：

17

3内存资源页：

18

6.调试记录

1.在编译gtk程序时，需要添加` pkg-config －－cflags --libs gtk+-3.0`.参数。 2.实验一程序过于简单，健壮性不大。

3.由于一开始没有加入刷新函数，导致实验一显示窗口数据不变化，在同学帮助下改正。

4.编译内核占用大量时间后来发现在make后添加-j4可以大大提升速度。

19

20

7.心得体会

本次课程设计主要目的是熟悉Linux系统，掌握Linux操作系统的使用方法，了解Linux系统内核代码结构，掌握实例操作系统的实现方法。由于刚开始接触Linux，实验的开始遇到了不少困难，GTK的安装和使用花费了我不少时间，并行程序是操作系统课程学过的内容，主要难点是图形化界面的设计。

实验二是耗费时间最多的，由于每个版本的内核编译方式不同，耗费了大量时间查找编译内核的方法，同时编译一次内核需要一个小时以上，不过皇天不负有心人最后我成功添加了系统调用。

添加设备驱动比较简单，主要是了解了Linux设备驱动的原理，熟悉设备驱动的安装过程。

分析/proc文件主要是搭建图形化界面，在借鉴了网上资源设计的窗口之后，我设计了简单的监控系统图形界面，其中CPU利用率以及占用曲线等需要计算。 通过本次实验我学到了很多东西，熟悉了Linux系统的使用方法，对Linux系统内核代码结构有了大致的了解，掌握了图形化界面GTK的使用，总而言之本次试验我获益匪浅。

21

8.程序清单

8.1实验一

8.1.1 文件拷贝 #include int main(int argc,char *argv[]) {

if(argc!=3)

{ printf(\"Error in argc!\\n\"); return 0;

}

FILE * fsource=NULL;

FILE * ftarget=NULL;

if( (fsource=fopen(argv[1],\"rb\"))==NULL )

{ printf(\"Fail to open source file!\\n\"); return 0;

}

if( (ftarget=fopen(argv[2],\"wb\"))==NULL )

{ printf(\"Fail to open target file!\\n\"); 22 return 0;

}

int c;

while((c=fgetc(fsource))!=EOF)

{ fputc(c,ftarget);

}

fclose(fsource);

fclose(ftarget);

return 0; } 8.1.2并发进程窗口显示

主函数：

#include #include #include int main() { pid_t time; pid_t cpu; pid_t sum; 23

if((time=fork())==-1) {

}

if(time==0) { execlp(\"./time\",0); printf(\"fork error\\n\"); return -1; }else {

if((cpu=fork())==-1) //create cpu {

} if(cpu==0) { execlp(\"./cpu\",0); printf(\"fork error\\n\"); return -1; }else 24

{ if((sum=fork())==-1) //create sum

{

printf(\"fork error\\n\");

return -1;

}

if(sum==0)

{

execlp(\"./sum\",0);

}else //father proce

{

wait(&time);

wait(&cpu);

wait(&sum);

}

}

}

} 系统时间：

25 #include #include #include #includechar t[50]; GtkWidget *label; gettime(){

time_t timep;

time (&timep);

sprintf(t,\"%s\",ctime(&timep));} void *thread(void * argc){

while(1){

gettime();

gtk_label_set_text(GTK_LABEL(label),t);

sleep(1);}

}

int main( int argc, char *argv[]) {

pthread_t id;

int i,ret;

ret=pthread_create(&id,NULL,(void *) thread,NULL); 26

GtkWidget *vbox;

GtkWidget *window;

//定义一个组装盒;

/*初始化整个GTK+程序，是每一个GTK+程序必不可少的部分*/

gtk_init(&argc, &argv);

/*这里生成了一个窗口构件——GtkWindow，GTK_WINDOW_TOPLEVEL包含窗口的标题栏和边框，同意用窗口管理器来进行管理*/

window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

gtk_window_set_title(GTK_WINDOW(window), \"time\");

gtk_window_set_default_size(GTK_WINDOW(window), 300, 200);

gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);

label = gtk_label_new (t);

gtk_container_add (GTK_CONTAINER (window), label);

gtk_widget_show (label);

/*开始显示窗口*/

gtk_widget_show(window);

gtk_main();

return 0; } CPU利用率： #include #include 27 #include GtkWidget* label; //the use rate of cpu char c[5]; float cpu(); void* thread(void* arg) {

} float cpu() {

FILE* fp; char buf[128]; char cpu[5]; long int user,nice,sys,idle,iowait,irq,softirq; float usage; while(1) {

} sleep(2); usage=cpu(); sprintf(c,\"the usage of cpu is %f %%\",usage); gtk_label_set_text(GTK_LABEL(label), c); 28

fp=fopen(\"/proc/stat\",\"r\"); if(fp==NULL) printf(\"error\\n\"); long int all1,all2,idle1,idle2; float usage; fgets(buf,sizeof(buf),fp);

canf(buf,\"%s%ld%ld%ld%ld%ld%ld%ld\",cpu,&user,&nice,&sys,&idle,&iowait,&irq,&softirq);

canf(buf,\"%s%ld%ld%ld%ld%ld%ld%ld\",cpu,&user,&nice,&sys,&idle,&iall1=user+nice+sys+idle+iowait+irq+softirq; idle1=idle; rewind(fp); //second sleep(1); memset(buf,0,sizeof(buf)); cpu[0]=\'\\0\'; user=nice=sys=idle=iowait=irq=softirq=0; fgets(buf,sizeof(buf),fp); 29 owait,&irq,&softirq);

} int main( int argc, char *argv[]) {

pthread_t id;

int i,ret;

ret=pthread_create(&id,NULL,(void *) thread,NULL);

GtkWidget *window;

/*初始化整个GTK+程序，是每一个GTK+程序必不可少的部分*/

gtk_init(&argc, &argv);

/*这里生成了一个窗口构件——GtkWindow，GTK_WINDOW_TOPLEVEL包含窗口的标题栏和边框，同意用窗口管理器来进行管理*/

window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

gtk_window_set_title(GTK_WINDOW(window), \"cpu\");

gtk_window_set_default_size(GTK_WINDOW(window), 300, 200);

gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);

label = gtk_label_new (c); usage=(float)(all2-all1-(idle2-idle1))/(all2-all1)*100; return usage; all2=user+nice+sys+idle+iowait+irq+softirq; idle2=idle; 30

gtk_container_add (GTK_CONTAINER (window), label);

gtk_widget_show (label);

/*开始显示窗口*/

gtk_widget_show(window);

gtk_main();

return 0; } 求和：

#include #include #include #includechar s[1000]; GtkWidget *label;

void *thread(void * argc){

int i,j,sum;

for(i=1,sum=0,j=1;i

sleep(3);

sum=sum+j;

j+=1;

sprintf(s,\"%d\",sum); 31

gtk_label_set_text(GTK_LABEL(label),s);

}

}

int main( int argc, char *argv[]) {

pthread_t id;

int i,ret;

ret=pthread_create(&id,NULL,(void *) thread,NULL);

GtkWidget *vbox;

GtkWidget *window;

/*初始化整个GTK+程序，是每一个GTK+程序必不可少的部分*/

gtk_init(&argc, &argv);

/*这里生成了一个窗口构件——GtkWindow，GTK_WINDOW_TOPLEVEL包含窗口的标题栏和边框，同意用窗口管理器来进行管理*/

window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

gtk_window_set_title(GTK_WINDOW(window), \"sum\");

gtk_window_set_default_size(GTK_WINDOW(window), 300, 200);

gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);

label = gtk_label_new (s);

gtk_container_add (GTK_CONTAINER (window), label);

//定义一个组装盒; 32

gtk_widget_show (label);

/*开始显示窗口*/

gtk_widget_show(window);

gtk_main();

return 0; } 8.2实验二

系统调用函数：

asmlinkage int sys_mycall(char* sourceFile,char* destFile) {

int source=sys_open(sourceFile,O_RDONLY,0);

int dest=sys_open(destFile,O_WRONLY|O_CREAT|O_TRUNC,0600);

char buf[4096];

mm_segment_t fs;

fs = get_fs();

set_fs(get_ds());

int i;

if(source>0 && dest>0)

{

do{

i=sys_read(source,buf,4096);

sys_write(dest,buf,i);

}while(i); 33

}

else {

printk(\"Error!\");

}

sys_close(source);

sys_close(dest);

set_fs(fs);

return 10; } 测试程序： #include #include #include

int main(int argc,char **argv) { int i=syscall(359,argv[1],argv[2]); printf(\"the %d\",i); return 1; } 8.3实验三

设备驱动：

#include #include #include 34 #include MODULE_LICENSE(\"GEL\"); MODULE_AUTHOR(\"wangzihao\"); #define DEV_NAME \"wzhdriver\" static ize_t GlobalRead(struct file *,char *,size_t,loff_t*); static ize_t GlobalWrite(struct file *,const char *,size_t,loff_t*); static int char_major = 0; static int GlobalData = 123456; struct file_operations globalchar_fops = {

.read = GlobalRead,

.write = GlobalWrite };

static int __init GlobalChar_init(void) {

int ret;

ret = register_chrdev(char_major,DEV_NAME,&globalchar_fops);

if(ret

{

printk(KERN_ALERT \"GlobalChar Reg Fail!\\n\");

} 35

else

{

printk(KERN_ALERT \"GloblaChar Reg Succe!\\n\");

char_major = ret;

printk(KERN_ALERT \"Major = %d\\n\",char_major);

}

return 0; } static void __exit GlobalChar_exit(void) {

unregister_chrdev(char_major,DEV_NAME);

printk(KERN_ALERT \"GlobalCharDev is dead now!\\n\");

return; } static ize_t GlobalRead(struct file *filp,char *buf,size_t len,loff_t *off) {

//GlobalData -= 1;

if (copy_to_user(buf,&GlobalData,sizeof(int)))

{

return -EFAULT;

}

return sizeof(int); 36 } static ize_t GlobalWrite(struct file *filp,const char *buf,size_t len,loff_t *off) {

if (copy_from_user(&GlobalData,buf,sizeof(int)))

{

return -EFAULT;

}

return sizeof(int); } module_init(GlobalChar_init); module_exit(GlobalChar_exit) 测试程序：

#include #include #include #include #define DEV_NAME \"/dev/wzhdriver\" int main() { int fd,num = 9999;

fd = open(DEV_NAME,O_RDWR,S_IRUSR | S_IWUSR); 37 if (fd

{

printf(\"Open Device Failed!\\n\");

return -1; } read(fd,&num,sizeof(int)); printf(\"The wzhdriver is %d\\n\",num); printf(\"input a number written to wzhdriver: \"); scanf(\"%d\",&num); write(fd,&num,sizeof(int)); read(fd,&num,sizeof(int)); printf(\"The char you input is %d\\n\",num);

close(fd); return 0; } 8.4实验四

#include #include #include #include #include 38 #include #include #include #include #include #include

char *txt_pid=NULL; char *txt_pid2=NULL;

char* meminfo_read(); /*内存使用情况*/ char* stat_read(); /*cpu使用率*/ char* procsum_read(); /*进程数*/

gint mem_refresh(gpointer mem_label); /*内存使用情况刷新*/ gint cpu_refresh(gpointer cpu_label);

/*cpu使用率刷新*/ gint proce_refresh(gpointer proce_label); /*进程数刷新*/

gboolean cpu_record_callback

(GtkWidget

*widget,GdkEventExpose *event,gpointer data);

39 gboolean mem_record_callback (GtkWidget *widget,GdkEventExpose *event,gpointer data);

void cpu_record_draw(GtkWidget *widget); void mem_record_draw(GtkWidget *widget);

static char temp_proce[50]; /*进程数*/ static char temp_cpu[50]; /*cpu使用率*/ static char temp_mem[50]; /*内存使用*/ static long idle,total; static int flag=0;

/*计算cpu时的数据*/ /*计算cpu使用率时启动程序的标志*/

/*计算单个进程cpu使用率时使用的标志*/ static int flag1=0;

static long mem_total; static long mem_free;

/*内存总大小*/ /*空闲内存*/ static long long ustime[32768]; /*前一次记录的用户态和核心态的总时间*/ static long mtime[32768]; /*前一次记录的时刻*/ static float cpu_used_percent=0;

/*cpu使用率*/ static int cpu_start_position=15; /*绘制cpu移动的线条*/ static float cpu_data[66]; static int flag2=0;

/*cpu历史数据*/

/*初始化cpu_data数组中数据的标志*/ static int cpu_first_data=0; /*第一个数据，既最早的数据，下一个要淘汰的数据 40 */ static float mem_data[66]; /*cpu历史数据*/ static int flag3=0;

/*初始化cpu_data数组中数据的标志*/ static int mem_first_data=0; /*第一个数据，既最早的数据，下一个要淘汰的数据*/ static int mem_start_position=15; /*绘制内存移动的线条*/

static GtkWidget *cpu_record_drawing_area;

static GtkWidget *mem_record_drawing_area;

static GtkWidget *notebook; /////////////////////////////////////////////

void kill_proc(void) {

char buf[20]; sprintf(buf,\"kill -9 %s\",txt_pid);

/*笔记本*/

system(buf); }

41 gint delete_event( GtkWidget *widget,

GdkEvent *event,

gpointer

data ) {

gtk_main_quit ();

return FALSE; }

char *get_cpu_name(char *_buf1) {

FILE * fp; int i=0; char *buf1=_buf1;

fp=fopen(\"/proc/cpuinfo\",\"r\"); for(i=0;i

char *get_cpu_type(char *_buf2) {

FILE * fp; int i=0; char *buf2=_buf2;

fp=fopen(\"/proc/cpuinfo\",\"r\"); for(i=0;i

char *get_cpu_f(char *_buf3) {

FILE * fp; int i=0; char *buf3=_buf3;

fp=fopen(\"/proc/cpuinfo\",\"r\"); for(i=0;i

char *get_cache_size(char *_buf4) {

FILE * fp; int i=0; char *buf4=_buf4;

fp=fopen(\"/proc/cpuinfo\",\"r\"); for(i=0;i

} fclose(fp); return buf4; char *get_system_type(char *_buf1) { FILE * fp;

int i=0;

//fp=fopen(\"/proc/version\",\"r\");

fp=fopen(\"/etc/iue\",\"r\");

fgets(buf1,256,fp);

for(i=0;i

buf1[i]=\'\\0\';

fclose(fp);

return buf1; }

char *get_system_version(char *_buf2) 46 { FILE * fp;

int i=0;

int j=0;

fp=fopen(\"/proc/version\",\"r\");

fgets(buf2,256,fp);

for(i=0,j=0;i

buf2+=i;

for(i=0;i

buf2[i+1]=\'\\0\';

fclose(fp);

return buf2; }

char *get_gcc_version(char *_buf3) { 47 FILE * fp;

int i=0;

int j=0;

fp=fopen(\"/proc/version\",\"r\");

fgets(buf3,256,fp);

for(i=0,j=0;i

buf3+=i;

for(i=0;i

buf3[i+1]=\'\\0\';

fclose(fp);

return buf3; }

void get_proc_info(GtkWidget *clist,int *p,int *q,int *r,int *s) {

DIR *dir; 48

struct dirent *ptr;

int i,j;

FILE *fp;

char buf[1024];

char _buffer[1024];

char *buffer=_buffer;

char *buffer2;

char proc_pid[1024];

char proc_name[1024];

char proc_stat[1024];

char proc_pri[1024];

char proc_takeup[1024];

char text[5][1024];

gchar *txt[5];

gtk_clist_set_column_title(GTK_CLIST(clist),0,\"PID\");

gtk_clist_set_column_title(GTK_CLIST(clist),1,\"名称\");

gtk_clist_set_column_title(GTK_CLIST(clist),2,\"状态\"); gtk_clist_set_column_title(GTK_CLIST(clist),3,\"优先级\"); gtk_clist_set_column_title(GTK_CLIST(clist),4,\"占用内存\");

gtk_clist_set_column_width(GTK_CLIST(clist),0,50);

gtk_clist_set_column_width(GTK_CLIST(clist),1,100); 49

第15篇：04操作系统

实训四 操作系统及驱动程序安装

教学目标

1．了解微型计算机操作系统安装的步骤和基础知识。

2．掌握微型计算机操作系统安装的过程。

主要教学内容

1．微型计算机操作系统安装的步骤和基础知识。

2．微型计算机操作系统安装的过程。

Windows XP光盘启动安装过程

Windows XP是Microsoft 继Windows 2000之后推出的新一代Windows 操作系统。Windows XP将Windows 2000的众多优点（安全性、易管理性和可靠性）与Windows 98和Windows Me的最佳特性（易于使用的用户界面）集成在一起的操作系统。

Windows XP在现有Windows 2000代码基础之上进行了很多改进，并且针对企业用户和家庭用户的不同需要提供了相应的版本：Windows XP Profeional和Windows XP Home Edition。

准备工作

准备好Windows XP Profeional 简体中文版安装光盘,并检查光驱是否支持自启动。 如果你想在安装过程中格式化C盘或D盘(建议安装过程中格式化C盘)，请备份C盘或D盘有用的数据。

用光盘启动系统

启动系统并把光驱设为第一启动盘,保存设置并重启。将XP安装光盘放入光驱,重新启动电脑。

安装Windows XP Profeional

光盘自启动后,如无意外即可见到安装界面

全中文提示，“要现在安装Windows XP，请按ENTER”，按回车。

许可协议,这里没有选择的余地，按“F8”后显示现有磁盘分区和尚未划分的空间信息。 这里用“向下或向上”方向键选择安装系统所用的分区。

NTFS格式可节约磁盘空间提高安全性和减小磁盘碎片。

格式化C盘的警告。

开始复制文件,文件复制完后，安装程序开始初始化Windows配置。然后系统将会自动在15秒后重新启动。

区域和语言设置选用默认值就可以了。

输入你想好的姓名和单位，这里的姓名是你以后注册的用户名。

输入安装序列号。

安装程序自动为你创建又长又难看的计算机名称,自己可任意更改。 输入系统管理员密码。

设置好日期和时间。

开始安装,复制系统文件、安装网络系统。

让你选择网络安装所用的方式，选典型设置。

顺利安装完成。

第16篇：操作系统实验报告

实验二

进程调度

1．目的和要求

通过这次实验，理解进程调度的过程，进一步掌握进程状态的转变、进程调度的策略，进一步体会多道程序并发执行的特点，并分析具体的调度算法的特点，掌握对系统性能的评价方法。

2．实验内容

阅读教材《计算机操作系统》第二章和第三章，掌握进程管理及调度相关概念和原理。

编写程序模拟实现进程的轮转法调度过程，模拟程序只对PCB进行相应的调度模拟操作，不需要实际程序。假设初始状态为：有n个进程处于就绪状态，有m个进程处于阻塞状态。采用轮转法进程调度算法进行调度(调度过程中，假设处于执行状态的进程不会阻塞)，且每过t个时间片系统释放资源，唤醒处于阻塞队列队首的进程。

程序要求如下：

1）输出系统中进程的调度次序； 2）计算CPU利用率。

3．实验环境

Windows操作系统、VC++6.0 C语言

4设计思想：

（1）

程序中进程可用PCB表示，其类型描述如下：

struct PCB_type

{

int pid ;

//进程名 int

state ;

//进程状态

2——表示“执行”状态

1——表示“就绪”状态

0——表示“阻塞”状态

int cpu_time ; //运行需要的CPU时间（需运行的时间片个数）

} 用PCB来模拟进程；

（2）设置两个队列，将处于“就绪”状态的进程PCB挂在队列ready中；将处于“阻塞”状态的进程PCB挂在队列blocked中。 队列类型描述如下：

struct QueueNode{

struct PCB_type

PCB;

Struct QueueNode *next; } 并设全程量：

struct QueueNode *ready_head=NULL,//ready队列队首指针

*ready_tail=NULL , //ready队列队尾指针

*blocked_head=NULL,//blocked队列队首指针 *blocked_tail=NULL; //blocked队列队尾指针 （3）设计子程序：

start_state();

读入假设的数据，设置系统初始状态，即初始化就绪队列和阻塞队列。

dispath();

模拟调度，当就绪队列的队首进程运行一个时间片后，放到就绪队列末尾，每次都是队首进程进行调度，一个进程运行结束就从就绪队列中删除，当到t个时间片后，唤醒阻塞队列队首进程。

calculate();

就绪进程运行一次，usecpu加1，当就绪队列为空时unusecpu加1，CPU利用率为use_cpu/(use_cpu+unuse_cpu)。

5源代码：

#include #include

struct PCB_type {

int pid ;

//进程名

int

state ;

//进程状态

//2--表示\"执行\"状态

//1--表示\"就绪\"状态

//0--表示\"阻塞\"状态

int cpu_time ; //运行需要的CPU时间（需运行的时间片个数） }; struct QueueNode{

struct PCB_type

PCB;

struct QueueNode *next; }; struct QueueNode *ready_head=NULL,

//ready队列队首指针

*ready_tail=NULL,

//ready队列队尾指针

*block_head=NULL,

//blocked队列队首指针

*block_tail=NULL;

//blocked队列队尾指针

int use_cpu,unuse_cpu;

void start_state() //读入假设的数据，设置系统初始状态 {

int n,m;

int i;

struct QueueNode *p,*q;

printf(\"输入就绪节点个数n:\");

scanf(\"%d\",&n);

printf(\"输入阻塞节点个数m:\");

scanf(\"%d\",&m);

p=(struct QueueNode *)malloc(sizeof(struct QueueNode));

p->next =NULL;

ready_head=ready_tail=p;

for(i=0;i

{

p=(struct QueueNode *)malloc(sizeof(struct QueueNode));

p->next =NULL;

p->PCB.state=1;

printf(\"输入就绪进程%d的pid和cpu_time:\",i+1);

scanf(\"%d%d\",&p->PCB.pid,&p->PCB.cpu_time);

ready_tail->next=p;

ready_tail=p;

}

q=(struct QueueNode *)malloc(sizeof(struct QueueNode));

q->next =NULL;

block_head=block_tail=q;

for(i=0;i

{

q=(struct QueueNode *)malloc(sizeof(struct QueueNode));

q->next=NULL;

q->PCB.state=0;

printf(\"输入阻塞进程%d的pid和cpu_time:\",i+1);

scanf(\"%d%d\",&q->PCB.pid,&q->PCB.cpu_time);

block_tail->next=q;

block_tail=q;

}

printf(\"\\n处于就绪状态的进程有:\\n\");

p=ready_head->next;

i=1;

while(p)

{printf(“进程%d的pid和cpu_time:%5d%5d%5d\\n\",i,p->PCB.pid,p->PCB.state,p->PCB.cpu_time);

p=p->next;

i++;

} } void dispath()

//模拟调度 {

int x=0,t;

use_cpu=0;

unuse_cpu=0;

printf(\"输入t:\");

scanf(\"%d\",&t);

printf(\"开始调度\\n\");

while(ready_head!=ready_tail||block_head!=block_tail)

{

struct QueueNode *p,*q;

if(ready_head!=ready_tail)

{

p=ready_head->next;

ready_head->next=p->next;

p->next=NULL;

if(ready_head->next==NULL)

{

ready_tail=ready_head;

}

p->PCB.state=2;

printf(\"进程%d调度\\t\",p->PCB.pid);

state和

use_cpu++;

x++;

p->PCB.cpu_time--;

if(p->PCB.cpu_time)

{

ready_tail->next=p;

ready_tail=p;

}

else

{

printf(\"进程%d完成\\t\",p->PCB.pid);

free(p);

}

}

else

{

unuse_cpu++;

x++;

printf(\"空闲一个时间片\\t\");

}

if(x==t&&block_head!=block_tail)

{

q=block_head->next;

block_head->next=q->next;

q->next=NULL;

if(block_head->next==NULL)

{

block_tail=block_head;

}

ready_tail->next=q;

ready_tail=q;

x=0;

}

} } void calculate()

//计算CPU利用率 { printf(\"\\ncpu的利用率%.2f\\n\",(float)use_cpu/(use_cpu+unuse_cpu));

} void main() {start_state();

dispath();

calculate(); } 6运行结果：

7实验总结：

实验帮我复习了数据结构和C语言，且巩固课本知识，知道了如何定义结构体，如何在链接队列中增删节点。模拟进程调度帮我们巩固了进程三状态之间的变迁。懂得调式的重要性。总之，我们明白了理论联系实际。多看书，多上机。

实验三

可变分区存储管理

1．目的和要求

通过这次实验，加深对内存管理的认识，进一步掌握内存的分配、回收算法的思想。

2．实验内容

阅读教材《计算机操作系统》第四章，掌握存储器管理相关概念和原理。 编写程序模拟实现内存的动态分区法存储管理。内存空闲区使用自由链管理，采用最坏适应算法从自由链中寻找空闲区进行分配，内存回收时假定不做与相邻空闲区的合并。

假定系统的内存共640K，初始状态为操作系统本身占用64K。在t1时间之后，有作业A、B、C、D分别请求8K、16K、64K、124K的内存空间；在t2时间之后，作业C完成；在t3时间之后，作业E请求50K的内存空间；在t4时间之后，作业D完成。要求编程序分别输出t

1、t

2、t

3、t4时刻内存的空闲区的状态。

3．实验环境

Windows操作系统、VC++6.0 C语言

4.设计思想

模拟内存分配和回收，要设置两个链队列，一个空闲区链和一个占用区链，空闲区链节点有起始地址，大小和指向下一节点的指针等数据域，占用区链节点有起始地址，大小，作业名和指向下一节点的指针等数据域，本实验用最坏适应算法，每次作业申请内存都是从空闲链队头节点分配，如果相等，就删除空闲头结点，如果小于申请的，就不分配，否则就划分内存给作业，剩下的内存大小，重新插入空闲链队，按从大到小，接着把作业占用的内存放到占用区链节点的末尾。每次作业运行完，就要回收其占用的内存大小，把作业节点按从大到小插入到空闲链队中。 5.源代码：

#include #include struct freelinkNode{ int len; int addre;

struct freelinkNode *next; }; struct busylinkNode{ char name;

int len; int addre; struct busylinkNode *next; }; struct freelinkNode *free_head=NULL;

//自由链队列（带头结点）队首指针

struct busylinkNode *busy_head=NULL;

//占用区队列队（带头结点）首指针

struct busylinkNode *busy_tail=NULL;

//占用区队列队尾指针 void start(void) /* 设置系统初始状态*/ { struct freelinkNode *p;

struct busylinkNode *q;

free_head=(struct freelinkNode*)malloc(sizeof(struct freelinkNode));

free_head->next=NULL; // 创建自由链头结点

busy_head=busy_tail=(struct busylinkNode*)malloc(sizeof(struct busylinkNode));

busy_head->next=NULL; // 创建占用链头结点

p=(struct freelinkNode *)malloc(sizeof(struct freelinkNode));

p->addre=64;

p->len=640-64;//OS占用了64K

p->next=NULL;

free_head->next=p;

q=(struct busylinkNode *)malloc(sizeof(struct busylinkNode));

q->name=\'S\'; /* S表示操作系统占用

*/

q->len=64; q->addre=0; q->next=NULL;

busy_head->next=q; busy_tail=q; } void requireMemo(char name, int require) /*模拟内存分配*/ { freelinkNode *w,*u,*v; busylinkNode *p; if(free_head->next->len>=require) {

p=(struct busylinkNode*)malloc(sizeof(struct busylinkNode));

p->name=name;

p->addre=free_head->next->addre;

p->len=require;

p->next=NULL;

busy_tail->next=p;

busy_tail=p; } else

printf(\"Can\'t allocate\");

w=free_head->next;

free_head->next=w->next;

if(w->len==require)

{

free(w); } else {

w->addre=w->addre+require;

w->len=w->len-require; }

u=free_head;

v=free_head->next;

while((v!=NULL)&&(v->len>w->len)) {

u=v;

v=v->next; }

u->next=w;

w->next=v; } void freeMemo(char name) /* 模拟内存回收*/ { int len;

int addre; busylinkNode *q,*p; freelinkNode *w,*u,*v; q=busy_head;

p=busy_head->next;

while((p!=NULL)&&(p->name!=name))

{

q=p;

p=p->next; }

if (p==NULL) {

printf(\"%c is not exist\",name); } else

{

if(p==busy_tail)

{

busy_tail=q;

}

else

{

q->next=p->next;

len=p->len;

addre=p->addre;

free(p);

w=(struct freelinkNode*)malloc(sizeof(struct freelinkNode));

w->len=len;

w->addre=addre;

u=free_head;

v=free_head->next;

while((v!=NULL)&&(v->len>len))

{ u=v; v=v->next;

}

u->next=w;

w->next=v;

} } } void past(int time) /* 模拟系统过了time 时间*/ { printf(\"过了时间%d后:\\n\",time); } void printlink() /* 输出内存空闲情况（自由链的结点） */ {

freelinkNode *p;

printf(\"内存的空闲情况为:\\n\");

p=(struct freelinkNode *)malloc(sizeof(struct freelinkNode));

p=free_head->next;

while(p!=NULL)

{

printf(\"内存的起始地址和内存的大小%5d\\t%5d:\\n\",p->addre,p->len);

p=p->next;

} }

void main() {

int t1=1,t2=2,t3=3,t4=4;

start();

past(t1);

requireMemo(\'A\',8);

requireMemo(\'B\',16);

requireMemo(\'C\',64);

requireMemo(\'D\',124);

printlink();

past(t2);

freeMemo(\'C\');

printlink();

past(t3);

requireMemo(\'E\',50);

printlink();

past(t4);

freeMemo(\'D\' );

printlink(); } 6.运行结果：

7.实验总结：

巩固编程能力，和调式能力，复习课本知识，明白理论联系实际的重要性，动手能力非常重要，多看书，多独立思考，品味痛苦的过程，享受成功的喜悦。

操作系统实验报告

院系：数计学院

班级：大类6班 学号：100511624 姓名：明章辉

指导教师：徐军利

第17篇：操作系统教案

操作系统

教案

操作系统课程简介

（一）课程性质

本课程是计算机科学与技术专业的核心课程之一，属于必修课程。

“操作系统”是计算机系统不可缺少的软件组成部分，负责对系统中各种资源进行有效的管理和对各种活动进行正确的组织，使整个计算机系统协调一致且高效地工作，指挥计算机系统正常运行。操作系统基于硬件，并对硬件实施管理，并构成对所有软件运行的支持平台，给用户使用计算机提供方便灵活友好的接口。

本课程的先修课为计算机组成原理、微机原理、数据结构、高级语言程序设计；后续课程为数据库系统原理、计算机网络、分布式系统等。

（二）教学目的

通过本课程的学习，使学生在深刻理解计算机系统整体概念的基础之上，掌握操作系统的基本原理及实现方法，掌握操作系统对计算机系统中各种资源的管理和控制功能，从而使学生具备一定的系统软件开发技能，为以后从事的研究、开发工作提供必要的软件基础和基本技能。

（三）教学内容

本课程内容包括：绪论，是对操作系统的一般性描述，包括什么是操作系统，操作系统在整个计算机系统的地位及其发展历史，它的功能、分类等；作业管理和Unix用户接口，介绍作业和操作系统用户接口，包括作业的基本概念和作业的建立过程、Unix介绍和它所提供的用户接口等；进程管理，主要介绍进程和线程的概念、进程控制、进程同步/互斥、死锁、进程间通信、线程等；处理机调度，主要介绍作业调度、进程调度、各种调度算法及其评价等；存储管理，介绍常见存储管理的方法，虚拟存储管理的实现等；Unix进程和存储管理；文件系统，包括文件系统的概念、文件结构和文件存取、文件目录管理、Unix文件管理等；设备管理；面向对象的操作系统。

（四）教学时数 课时:72学时

（五）教材（统编）

张尧学、史美林编著《计算机操作系统教程》，清华大学出版社，2003.2

（六）课程参考书

1.刘振鹏、李亚平、张明编著《操作系统》21世纪高等院校计算机教材 中国铁道出版社 2003.9 2 2.陆松年主编《操作系统教程》原理.应用.系统.网络管理 电子工业出版社

2000.10 3.何炎祥，李飞，李宁《计算机操作系统》，清华大学出版社，2004。 4.Tanenbaum AS, Operating System Design and Implementation, Prentice-Hall, 1987。

5.郭玉东，《Unix操作系统结构分析》，西安电子科技大学出版社，2002。6.汤子赢，《计算机操作系统》，西安电子科技出版社，2000。

7.孟静编著《操作系统教程—原理和实例分析》面向21世纪课程教材，高等教育出版社，2001.5 8.蒋静、徐志伟著《操作系统原理.技术与编程》机械工业出版社，2004.7 9.孙钟秀主编《操作系统教程》21世纪课程教材，高等教育出版社，2003.8第三版

10.胡元义、余健明、徐睿琳编著《操作系统课程辅导与习题解析》，人民邮电出版社，2002.10 11.《全国第八届计算机操作系统课程教学研讨暨学术交流会论文集》，2005.10 3

第一讲 操作系统的概念、历史和基本类型

【教学章节】第1章 绪论 1.1 操作系统概念 1.2 操作系统的历史 1.3操作系统的基本类型。 【教学时数】2学时

【教学目的】掌握操作系统的概念及其在计算机系统中的作用,了解操作系统的发展历史, 理解批处理系统、分时操作系统、实时操作系统、个人计算机操作系统、网络和分布式操作系统的特点。 【教学重点】操作系统的概念，基本类型。

【教学难点】联机批处理，脱机批处理，多道程序系统的特点和引发出的问题。 【教学方法与手段】课堂讲授（多媒体形式） 【教学过程】

课堂考勤 导入新课

从Windows 2000引入操作系统的概念。

讲授新课

第1章 绪论 1.1 操作系统概念 1.1.1 什么是操作系统

任何一个计算机系统都是由两部分组成：计算机硬件和计算机软件。 计算机硬件通常是由中央处理机（运算器和控制器）、存储器、输入设备和输出设备等部件组成。

计算机软件包括系统软件和应用软件。系统软件如操作系统、多种语言处理程序( 汇编和编译程序等 )、连接装配程序、系统实用程序、多种工具软件等; 应用软件为多种应用目的而编制的程序。

没有任何软件支持的计算机称为裸机，它仅仅构成了计算机系统的物质基础，而实际呈现在用户面前的计算机系统是经过若干层软件改造的计算机。图1.1展示了这种情形。

图1.1 操作系统与硬件软件的关系

操作系统的定义

操作系统是计算机系统中的一个系统软件，它是这样一些程序模块的集合——它们管理和控制计算机系统中的硬件及软件资源，合理地组织计算机工作流程，以便有效地利用这些资源为用户提供一个功能强大、使用方便和可扩展的工作环境，从而在计算机与其用户之间起到接口的作用。

1.2 操作系统的历史

随着计算机的发展，操作系统经历了如下的发展过程：手工操作阶段(无操作系统)、批处理、执行系统、多道程序系统、分时系统、实时系统、通用操作系统、网络操作系统、分布式操作系统等。

1.2.1 手工操作阶段

在第一代计算机时期，上机完全是手工操作：先把程序纸带(或卡片)装上输入机，然后启动输入机把程序和数据送入计算机，接着通过控制台开关启动程序运行。计算完毕，打印机输出计算结果，用户取走并卸下纸带(或卡片)。

50年代后期，计算机的运行速度有了很大提高，手工操作的慢速度和计算机的高速度之间形成矛盾。实现作业的自动过渡,出现了批处理。

1.2.2 早期批处理(batch proceing) 早期的批处理的两种方式 1.联机批处理

慢速的输入输出(I/O)设备是和主机直接相连。 作业的执行过程为: (1) 用户提交作业：作业程序、数据，用作业控制语言编写的作业说明书; (2) 作业被作成穿孔纸带或卡片; (3) 操作员有选择地把若干作业合成一批，通过输入设备(纸带输入机或读卡机) 把它们存入磁带; 5 这种联机批处理方式解决了作业自动转接，从而减少作业建立和人工操作时间。但是在作业的输入和执行结果的输出过程中，主机CPU仍处在停止等待状态，这样慢速的输入输出设备和快速主机之间仍处于串行工作，CPU的时间仍有很大的浪费。

2.脱机批处理

增加一台不与主机直接相连而专门用于与输入输出设备打交道的卫星机。如图1.2所示。

图1.2 早期脱机批处理模型

卫星机的功能是：

(1) 输入设备通过它把作业输入到输入磁带；

(2) 输出磁带将作业执行结果输出到输出设备。

这样，主机不是直接与慢速的输入输出设备打交道，而是与速度相对较快的磁带机发生关系。主机与卫星机可以并行工作，二者分工明确，以充分发挥主机的高速度计算能力。因此脱机批处理和早期联机批处理相比大大提高了系统的处理能力。

6 图1.3 监督程序管理下的解题过程

1.2.3 多道程序系统

批处理系统，每次只调用一个用户作业程序进入内存并运行，称为单道运行。图1.4(a)给出了单道程序工作示例。

而图1.4(b)给出了多道程序工作示例。在单处理机系统中，多道程序运行的特点是: (1) 多道:计算机内存中同时存放几道相互独立的程序。

(2) 宏观上并行：同时进入系统的几道程序都处于运行过程中，即它们先后开始了各自的运行，但都未运行完毕。

(3) 微观上串行：实际上，各道程序轮流使用CPU，交替执行。

(a) 单道程序工作示例 (b) 多道程序工作示例

图 1.4

(2) 随着多道程序的增加，出现了内存不够用的问题，提高内存的使用效率也 7 成为关键。因此出现了诸如覆盖技术、对换技术和虚拟存储技术等内存管理技术。

(3) 由于多道程序存在于内存，为了保证系统程序存储区和各用户程序存储区的安全可靠，提出了内存保护的要求。

多道程序系统的出现标志着在操作系统渐趋成熟的阶段先后出现了作业调度管理、处理机管理、存储器管理、外部设备管理、文件系统管理等功能。

1.2.4 分时操作系统 1.2.5 实时操作系统

20世纪60年代中期计算机进入第三代,计算机由于用于工业过程控制、军事实时控制等形成了各种实时处理系统。针对实时处理的实时操作系统是以在允许时间范围之内做出响应为特征的。它要求计算机对于外来信息能以足够快的速度进行处理，并在被控对象允许时间范围内作出快速响应，其响应时间要求在秒级、毫秒级甚至微秒级或更小。近年来，实时操作系统正得到越来越广泛的应用。特别是非PC机和PDA（个人数字助理）等新设备的出现，更加强了这一趋势。

1.2.6 通用操作系统

多道批处理系统和分时系统的不断改进、实时系统的出现及其应用日益广泛，致使操作系统日益完善。在此基础上，出现了通用操作系统。它可以同时兼有多道批处理、分时、实时处理的功能，或其中两种以上的功能。例如，将实时处理和批处理相结合构成实时批处理系统。在这样的系统中，它首先保证优先处理任务，插空进行批作业处理。通常把实时任务称为前台作业，批作业称为后台作业。将批处理和分时处理相结合可构成分时批处理系统。在保证分时用户的前提下，没有分时用户时可进行批量作业的处理。同样，分时用户和批处理作业可按前后台方式处理。

1.2.7 操作系统的进一步发展

进入20世纪80年代，一方面迎来了个人计算机的时代，同时又向计算机网络、分布式处理、巨型计算机和智能化方向发展。操作系统有了进一步的发展：

· 个人计算机上的操作系统，例如DOS系统。 · 嵌入式操作系统。 · 网络操作系统。 · 分布式操作系统。 · 智能化操作系统。

20世纪90年代后期，由于个人计算机硬件功能的急剧增加和用户对安全性、网络功能的要求增强，个人计算机操作系统也从DOS转向了通用操作系统Windows系列和linux系列。

8 1.3 操作系统的基本类型

根据其使用环境和对作业处理方式，操作系统的基本类型有： (1) 批处理操作系统(batch proceing operating system) (2) 分时操作系统(time sharing operating system) (3) 实时操作系统(real time operating system) (4) 个人计算机操作系统(personal computer operating system) (5) 网络操作系统(network operating system) (6) 分布式操作系统(distributed operating system)

1.3.1 批处理操作系统

现代操作系统大都具有批处理功能。图1.5给出了批处理系统中作业处理步骤及状态。

批处理系统的主要特征是：

(1) 用户脱机使用计算机。用户提交作业之后直到获得结果之前就不再和计算机打交道。作业提交的方式可以是直接交给计算中心的管理操作员，也可以是通过远程通讯线路提交。提交的作业由系统外存收容成为后备作业。

(2) 成批处理。操作员把用户提交的作业分批进行处理。每批中的作业将由操作系统或监督程序负责作业间自动调度执行。

(3) 多道程序运行。按多道程序设计的调度原则，从一批后备作业中选取多道作业调入内存并组织它们运行，成为多道批处理。

多道批处理系统的优点是由于系统资源为多个作业所共享，其工作方式是作业之间自动调度执行。并在运行过程中用户不干预自己的作业，从而大大提高了系统资源的利用率和作业吞吐量。其缺点是无交互性，用户一旦提交作业就失去了对其运行的控制能力；而且是批处理的，作业周转时间长，用户使用不方便。

多重处理系统配制多个CPU，因而能真正同时执行多道程序。

多道程序设计原则不一定要求有多重处理系统的支持。多重处理系统比起单处理系统来说，虽增加了硬件设施，却换来了提高系统吞吐量、可靠性、计算能力和并行处理能力等好处。

1.3.2 分时系统

分时系统一般采用时间片轮转的方式，使一台计算机为多个终端用户服务。对每个用户能保证足够快的响应时间，并提供交互会话能力。具有下述特点。

(1) 交互性：首先， 用户可以在程序动态运行情况下对其加以控制。其次，用户上机提交作业方便。第三，分时系统还为用户之间进行合作提供方便。

9 (2) 多用户同时性：多个用户同时在自己的终端上上机，共享CPU和其他资源，充分发挥系统的效率。

(3) 独立性：客观效果上用户彼此间感觉不到有别人也在使用该台计算机，如同自己独占计算机一样。

分时操作系统是一个联机的多用户交互式的操作系统。UNIX是最流行的一种多用户分时操作系统。

1.3.3 实时系统

实时系统主要随着计算机应用于实时控制和实时信息处理领域中而发展起来。 实时系统的主要特点是提供即时响应和高可靠性。系统必须保证对实时信息的分析和处理的速度比其进入系统的速度要快，而且系统本身要安全可靠。实时系统往往具有一定的专用性。与批处理系统、分时系统相比，实时系统的资源利用率可能较低。

设计实时操作系统要考虑这样一些因素： (1) 实时时钟管理(定时处理和延时处理)。

(2) 连续的人-机对话，这对实时控制往往是必须的。

(3) 要求采取过载保护措施。例如对于短期过载，把输入任务按一定的策略在缓冲区排队，等待调度; 对于持续性过载，可能要拒绝某些任务的输入; 在实时控制系统中，则及时处理某些任务，放弃某些任务或降低对某些任务的服务频率。

(4) 高度可靠性和安全性需采取冗余措施。双机系统前后台工作，包括必要的保密措施等。 1.3.4 通用操作系统

批处理系统、分时系统和实时系统是操作系统的三种基本类型，在此基础上又发展了具有多种类型操作特征的操作系统，称为通用操作系统。它可以同时兼有批处理、分时、实时处理和多重处理的功能，或其中两种以上的功能。

1.3.5 个人计算机上的操作系统

个人计算机上的操作系统是一联机的交互式的单用户操作系统，它提供的联机交互功能与通用分时系统所提供的很相似。由于是个人专用，因此在多用户和分时所要求的对处理机调度、存储保护方面将会简单得多。

多媒体技术已迅速进入微型计算机系统，它要求计算机具有高速信号处理、大容量的内存和外存、大数据量宽频带传输等能力，能同时处理多个实时事件。要求有一个具有高速数据处理能力的实时多任务操作系统。

10 1.3.6 网络操作系统

计算机网络是通过通信设施将物理上分散的具有自治功能的多个计算机系统互连起来的，实现信息交换、资源共享、可互操作和协作处理的系统。它具有这样的特征：

(1) 计算机网络是一个互连的计算机系统的群体。

(2) 这些计算机是自治的，每台计算机有自己的操作系统，各自独立工作，它们在网络协议控制下协同工作。

(3) 系统互连要通过通信设施(硬件、软件)来实现。

(4) 系统通过通信设施执行信息交换、资源共享、互操作和协作处理， 实现多种应用要求。

网络操作系统的研制开发是在原来各自计算机操作系统的基础上进行的。按照网络体系结构的各个协议标准进行开发，包括网络管理、通信、资源共享、系统安全和多种网络应用服务等达到上述诸方面的要求。

由于网络计算的出现和发展，现代操作系统的主要特征之一就是具有上网功能，因此，除了在20世纪90年代初期时，Novell公司的Netware等系统被称为网络操作系统之外，人们一般不再特指某个操作系统为网络操作系统。

1.3.7 分布式操作系统

分布系统也可以定义为通过通信网络将物理上分布的具有自治功能的数据处理系统或计算机系统互连起来，实现信息交换和资源共享，协作完成任务。但是有这样一些明显的区别应予考虑：

(1) 计算机网络的开发都遵循协议，而对于各种分布式系统并没有制定标准的协议。当然，计算机网络也可认为是一种分布式系统。

(2) 分布式系统要求一个统一的操作系统，实现系统操作的统一性。 (3) 分布式操作系统对用户是透明的。但对计算机网络，若一个计算机上的用户希望使用另一台计算机上的资源，则必须明确指明是哪台计算机。

(4) 分布式系统的基础是网络。分布式系统已不仅是一个物理上的松散耦合系统，同时还是一个逻辑上紧密耦合的系统。

(5) 分布式系统还处在研究阶段。而计算机网络已经在各个领域得到广泛的应用。

20世纪90年代出现的网络计算的趋势和高速网络的出现已使分布式系统变得越来越现实。

【答疑】 【本节小结】

11 本节主要介绍了操作系统的深层概念，操作系统的发展历史、分类，要求深刻理解操作系统的定义，熟悉批处理系统、分时系统、实时系统、网络操作系统、分布式操作系统的基本特征。

【作业】

1.1 什么是操作系统的基本功能? 1.2 什么是批处理、分时和实时系统?各有什么特征? 1.3 多道程序设计(multiprogramming)和多重处理(multi-proceing)有何区别? 【下课】

12 第二讲 操作系统的功能、相关硬件和研究观点

【教学章节】第1章 绪论 1.4 操作系统的功能 1.5计算机硬件简介 1.6算法的描述 1.7研究操作系统的几种观点 【教学时数】2学时

【教学目的】初步掌握操作系统的处理机管理、存储管理、文件管理、设备管理、用接通接口；掌握计算机的处理器、存储器、输入输出设备、输入输出控制器、总线、各种相关的寄存器等；了解操作系统是计算机资源的管理者观点，用户界面观点，进程管理观点。

【教学重点】操作系统的五大功能。

【教学难点】操作系统的处理机管理、存储管理、文件管理、设备管理、用接通接口，进程管理观点。

【教学方法与手段】课堂教授（多媒体形式） 【教学过程】

课堂考勤 导入新课

复习操作系统的定义和基本分类(引入新课)。

讲授新课

1.4 操作系统功能 1.4.1 处理机管理

在多道程序或多用户的情况下，要组织多个作业同时运行，就要解决对处理机分配调度策略、分配实施和资源回收等问题。这就是处理机管理功能。正是由于操作系统对处理机管理策略的不同，其提供的作业处理方式也就不同，例如成批处理方式、分时处理方式和实时处理方式。从而呈现在用户面前，成为具有不同性质功能的操作系统。

1.4.2 存储管理

(1) 内存分配。如何分配内存，以保证系统及各用户程序的存储区互不冲突。 (2) 存储保护。保证一道程序在执行过程中不会有意或无意地破坏另一道程序，保证用户程序不会破坏系统程序。

(3) 内存扩充。当用户作业所需要的内存量超过计算机系统所提供的内存容量时，把内部存储器和外部存储器结合起来管理，为用户提供一个容量比实际内存大得多的虚拟存储器。

13 1.4.3 设备管理

(1) 通道、控制器、输入输出设备的分配和管理。设备管理的任务就是根据一定的分配策略，把通道、控制器和输入输出设备分配给请求输入输出操作的程序，并启动设备完成实际的输入输出操作。

(2) 设备独立性。输入输出设备种类很多，使用方法各不相同。设备管理应为用户提供一个良好的界面，而不必去涉及具体的设备特性，以使用户能方便、灵活地使用这些设备。

1.4.4 信息管理(文件系统管理) 信息管理(文件系统管理) 是对系统的软件资源的管理。文件如不能很好管理，就会引起混乱，甚至遭受破坏。这就是管理信息文件需要解决的问题。

信息的共享、保密和保护，也是文件系统所要解决的。如果系统允许多个 用户协同工作，那么就应该允许用户共享信息文件。但这种共享应该是受控制的，应该有授权和保密机制。还要有一定的保护机制以免文件被非授权用户调用和修改，即使在意外情况下，如系统失效、用户对文件使用不当，也能尽量保护信息免遭破坏。也就是说，系统是安全可靠的。

1.4.5 用户接口

操作系统还为用户提供一个友好的用户接口。一般来说，操作系统提供两种方式的接口来为用户服务。

一种用户接口是程序一级的接口，即提供一组广义指令(或称系统调用、程序请求)供用户程序和其他系统程序调用。

另一种接口是作业一级的接口，提供一组控制操作命令(或称作业控制语言，或像UNIX中的Shell命令语言)供用户去组织和控制自己作业的运行。作业控制方式分两大类：脱机控制和联机控制。

1.5 计算机硬件简介 1.5.1 计算机的基本硬件元素 1.5 计算机硬件简介

操作系统管理和控制计算机系统中所有软硬件资源。同时，因操作系统是一个运行于硬件之上的系统软件，我们还必须对操作系统运行的硬件环境有所了解。

1.5.1 计算机的基本硬件元素

构成计算机的基本硬件元素有以下4种：处理器、存储器、输入输出控制与总线、外部设备等。

计算机的基本硬件元素

处理器控制和执行计算机的指令操作。

14 单处理器也称CPU。存储器用来储存数据和程序。存储器可分为内存与外存，以及用于数据和程序暂时存储用的缓冲器与高速缓存（cache）等。

输入输出控制器与缓冲主要用来控制和暂时存储外部设备与计算机内存之间交换的数据和程序。

外部设备是获取和输出数据与程序的基本单位，包括数字式设备和模拟式设备。 计算机系统的各种设备通过总线互相连接。总线是连接计算机各部件的通信线路。计算机系统的总线有单总线和多总线之分。

单总线是指处理机、外部设备、存储器等都连接在一起的总线结构，而多总线则指把系统的CPU和内存分开连接，外部设备和外存等也用其他总线分开连接进行管理和数据传送的总线结构。

不同的总线结构对操作系统的设计和性能有不同的影响。 1.5.2 与操作系统相关的几种主要寄存器

寄存器是在处理机中交换数据的速度比内存更快、体积也更小，而价格又更贵的暂存器件。

处理机中寄存的功能分为二类，即用户可编程的寄存器以及控制与状态寄存器。机器语言或汇编语言的程序员可对用户可编程寄存器进行操作，以获得更高的执行效率等。而控制与状态寄存器则被用来对处理机的优先级、保护模式或用户程序执行时的调用关系等进行控制和操作。

典型的用户可编程寄存器包括以下几种： 1.数据寄存器

对数据进行操作的任何机器指令都被允许访问数据寄存器。

根据硬件设置的规定，这些寄存器也可能只被允许进行浮点运算或被其他某些规定所限制。

2.地址寄存器

地址寄存器一般用来存放内存中某个数据或指令的地址，或者存放某段数据与指令的入口地址以及被用来进行更复杂的地址计算。

下面几种寄存器都可被认为是地址寄存器： (1） 地址标识位寄存器；

(2） 内存管理用各种始地址寄存器； (3） 堆栈指针； (4） 设备地址寄存器等。 3.条件码寄存器

条件码寄存器也称标志寄存器。条件码寄存器的比特位由处理机硬件设置。

15 典型的控制与状态寄存器包括以下几种： 4.程序计数器PC 程序计数器内装有下一周期被执行指令的地址。 5.指令寄存器IR 指令寄存器内装有待执行指令。 6.程序状态字PSW 程序状态字寄存器的各个比特位代表系统中当前的各种不同状态与信息。如执行模式是否允许中断等。

7.中断现场保护寄存器

如果系统允许不同类型的中断存在，则会设置一组中断现场保护寄存器以便保存被中断程序的现场和链接中断恢复处。

8.过程调用堆栈

堆栈被用来存放过程调用时的调用名、调用参数、以及返回地址等。 1.5.3 存储器的访问速度

硬件厂商提供有不同种类的存储器件，这些存储器件包括：可移动存储介质，例如光盘、磁盘和磁带等；硬盘，磁盘缓存内存，高速缓存以及寄存器等。

容量越大的存储介质，访问速度会越慢，但单位存储的成本越低;如果存储介质的访问速度越高，则它的成本也会越高。

除了上述的寄存器与存储介质之外，与操作系统设计相关的硬件器件还有中断机构、输入输出设备控制部分。

存储介质的访问速度

1.5.4 指令的执行与中断

计算机提供的最基本功能是执行指令。任何应用程序都只有通过指令的执行才能得以完成。执行指令的基本过程分为两步，即处理机从内存把指令读入的过程和执行的过程。其中，读指令是根据程序计数器PC所指的地址读入，而执行的指令则是指令寄存器IR中的指令。

16 指令的执行涉及到处理机与内存之间的数据传输，或者是处理机与外部设备之间的数据传输等。指令的执行也涉及到数据处理，指令的执行还可以是对其他指令的控制过程。

一条指令的执行可以是上述几种情况的组合。

另外，在指令的执行过程中或一条指令执行结束时，尽管指令地址计数器中已指明了下一条被访问指令的地址，但是，外部设备或计算机内部可能会发来亟须处理的数据或其他紧急事件处理信号。这就需要处理机暂停正在执行的程序，转去处理相应的紧急事件，待处理完毕后再返回原处继续执行，这一过程称为中断，如图1.9所示。

图1.9 中断执行过程

中断给操作系统设计带来许多好处，首先使得实时处理许多紧急事件成为可能；再者，中断可以增加处理机的执行效率；另外，中断还可以简化操作系统的程序设计。

系统发生中断时，处理机收到中断信号，从而不能继续执行程序计数器中所指的原程序。这时处理机将保存当前的执行现场（也就是各寄存器中的值）并调用新的程序到处理机上执行。

1.6 算法的描述

操作系统设计和原理描述中涉及到许多算法。为了描述简单起见，本书定义下述关键词描述算法中有关过程。

begin end Repeat 操作 „ 分别表示算法的开头和结束。

Until 条件 While 条件 表示当“条件”未被满足时重复所描述的“操作”。

do

od

操作 „

表示当“条件”满足时，进行相应的“操作”。关键词“ do” 和“od”分别表示“操作”的开始和结束。

If 条件

Then Else fi 操作 操作

表示满足“if”所指的“条件”时，进行“then”后的相关“操作”，否则完成“else”后的相关操作。关键词“fi”表示条件判断的结束。

例如，图1.8所示指令执行周期可被描述为：

Repeat

IR←M［PC］; PC←PC + 1; Execute［IR］; CPU halt; Until 其中，M［PC］表示地址为PC所示内存单元中的指令内容。 另一个例子是：

令p［1：n］为1到n(n>1)的整数置换， 设i=1，2，3，4，5，6，7； p［i］=4，7，3，2，1，5，6；

描述p［i］的巡回置换算法。（巡回置换指k∈［1：n］时，k=p［...p［k］...］的置换。）

解：

begin

local x, k; k←1; while k

end

od repeat

until x=k; k←k+1;

print(x); x→p［x］; 1.7 研究操作系统的几种观点

操作系统是计算机资源有效使用的管理者和为用户提供友好的接口。 1.7.2 用户界面的观点

对于用户来说，对操作系统的内部结构并没有多大的兴趣，他们最关心的是如何利用操作系统提供的服务来有效地使用计算机。因此操作系统提供了什么样的用户界面成为关键问题，即上节中所提出的程序一级和作业一级的两种接口。

1.7.3 进程管理观点

操作系统调用当前程序运行是一个动态过程，特别是现代操作系统的一个重要特征是并发性。

并发性是指操作系统控制很多能并发执行的程序段。并发执行的程序在多处理机系统中可能是真正并行执行的，但在单处理机情况下则是宏观并行微观顺序执行的。它们可以完全独立地运行，也可能以间接或直接方式互相依赖和制约。并发的程序段不仅会受到其他程序段活动的制约，也会受到系统资源分配情况的制约。

进程是指并发程序的执行。

用进程观点来研究操作系统就是围绕进程运行过程，即并发程序执行过程来讨论操作系统，那么我们就能讨论清楚“这些资源管理程序在系统中进行活动的过程”，对操作系统功能就能获得更多的认识。

【答疑】

【本节小结】本节主要介绍了操作系统功能，研究操作系统的观点。本节是对操作系统的一般性描述。目的是对操作系统的功能有一个全面的了解。建立资源管理的初步概念。初步了解操作系统的用户管理、设备管理、处理机管理、存储管理、文件管理等五大管理。

【作业】

1.4 讨论操作系统可以从哪些角度出发，如何把它们统一起来? 1.5 写出1.6节中巡回置换算法的执行结果。 1.6 设计计算机操作系统时与哪些硬件器件有关？ 【下课】

第18篇：操作系统比较

常见操作系统比较

一、三种操作系统简介

（一）Windows操作系统简介

Windows是Microsoft公司在1985年11月发布的第一代窗口式多任务系统，它使PC机开始进入了所谓的图形用户界面时代。在图形用户界面中，每一种应用软件（即由Windows支持的软件）都用一个图标（Icon）表示，用户只需把鼠标移到某图标上，连续两次按下鼠标器的拾取键即可进入该软件，这种界面方式为用户提供了很大的方便，把计算机的使用提高到了一个新的阶段。

Windows1.X版是一个具有多窗口及多任务功能的版本，但由于当时的硬件平台为PC/XT，速度很慢，所以Windows1.X版本并未十分流行。1987年底Microsoft公司又推出了MS-Windows2.X 版，它具有窗口重叠功能，窗口大小也可以调整，并可把扩展内存和扩充内存作为磁盘高速缓存，从而提高了整台计算机的性能，此外它还提供了众多的应用程序：文本编辑Write、记事本Notepad、计算器Calculator、日历Calendar……等。随后在88年、89年又先后推出了MS-Windows/286-V2.1和MS-Windows/386 V2.1这两个版本。1990年，Microsoft公司推出了Windows3.0，它的功能进一步加强，具有强大的内存管理，且提供了数量相当多的Windows应用软件，因此成为38

6、486微机新的操作系统标准。随后，Windows发表3.1版，而且推出了相应的中文版。3.1版较之3.0版增加了一些新的功能，受到了用户欢迎，是当时最流行的Windows版本。

1995年，Microsoft公司推出了Windows95。在此之前的Windows都是由DOS引导的，也就是说它们还不是一个完全独立的系统，而Windows95是一个完全独立的系统，并在很多方面作了进一步的改进，还集成了网络功能和即插即用（Plug and Play）功能，是一个全新的32位操作系统。

1998年，Microsoft公司推出了Windows95的改进版Windows98，Windows98的一个最大特点就是把微软的Internet浏览器技术整合到了Windows里面，使得访问Internet资源就像访问本地硬盘一样方便，从而更好地满足了人们越来越多的访问Internet资源的需要。Windows98是目前实际使用的主流操作系统。

在90年代初期Microsoft推出了Windows NT（NT是New Technology即新技术的缩写）来争夺Novell Netware的网络操作系统市场。相继有Windows NT 3.0，3.5，4.0等版本上市，逐渐蚕食了中小网络操作系统的大半江山。WindowsNT是真正的32位操作系统，与普通的Windows系统不同，它主要面向商业用户，有服务器版和工作站版之分。2000年，Microsoft公司推出了Windows 2000，它包括四个版本：Data center Server是功能最强大的服务器版本，只随服务器捆绑销售，不零售；Advanced Server和Server版是一般服务器使用；Profeional版是工作站版本的NT和Windows98共同的升级版本。目前还有一个主要面向家庭和个人娱乐，侧重于多媒体和网络的Windows Me存在。

2001年10月25日，Microsoft发布了功能及其强大的Windows XP，该系统采用Windows 2000/NT内核，运行非常可靠、稳定，用户界面焕然一新，使用起来得心应手，这次微软终于可以和苹果的Macintosh软件一争高下了，优化了与多媒体应用有关的功能，内建了极其严格的安全机制，每个用户都可以拥有高度保密的个人特别区域，尤其是增加了具有防盗版作用的激活功能。

（二）Unix操作系统简介

Unix系统是1969年在贝尔实验室诞生，最初是在中小型计算机上运用。最早移植到80286微机上的Unix系统，称为Xenix。 Xenix系统的特点是短小精干，系统开销小，运行速度快。

UNIX为用户提供了一个分时的系统以控制计算机的活动和资源，并且提供一个交互，灵活的操作界。UNIX被设计成为能够同时运行多进程，支持用户之间共享数据。同时，UNIX支持模块化结构，当你安装UNIX操作系统时，你只需要安装你工作需要的部分，例如：UNIX支持许多编程开发工具，但是如果你并不从事开发工作，你只需要安装最少的编译器。用户界面同样支持模块化原则，互不相关的命令能够通过管道相连接用于执行非常复杂的操作。UNIX 有很多种，许多公司都有自己的版本，如 AT&T、Sun、HP等。最初的Unix是用汇编语言编写的，一些应用是由叫做B语言的解释型语言和汇编语言混合编写的。B语言在进行系统编程时不够强大，所以汤普逊和里奇对其进行了改造，并与1971年共同发明了C语言。

1973年汤普逊和里奇用C语言重写了Unix。在当时，为了实现最高效率，系统程序都是由汇编语言编写，所以汤普逊和里奇此举是极具大胆创新和革命意义的。用C语言编写的Unix代码简洁紧凑、易移植、易读、易修改，为此后Unix的发展奠定了坚实基础。

（三）linux操作系统简介

简单地说， Linux是一套免费使用和自由传播的类 Unix操作系统，它主要用于基于 Intel x86系列 CPU的计算机上。这个系统是由世界各地的成千上万的程序员 设计和实现的。其目的是建立不受任何商品化软件的版权制约的、全世界都能自由使用的 Unix兼容产品。 Linux的出现，最早开始于一位名叫 Linus Torvalds 的计算机业余爱好者，当时他是芬兰赫尔辛基大学的学生。他的目的是想设计一个代替 Minix（是由一位名叫 Andrew Tannebaum的计算机教授编写的一个操作系统示教程序）的操作系统，这个操作系统可用于 38

6、486或奔腾处理器的个人计算机上，并且具有 Unix操作系统的全部功能，因而开始了 Linux雏形的设计。 Linux以它的高效性和灵活性著称。它能够在 PC计算机上实现全部的 Unix特性，具有多任务、多用户的能力。 Linux是在 GNU公共许可权限下免费获得的，是一个符合 POSIX标准的操作系统。 Linux操作系统软件包不仅包括完整的 Linux操作系统，而且还包括了文本编辑器、高级语言编译器等应用软件。它还包括带有多个窗口管理器的 X-Windows图形用户界面，如同我们使用 Windows NT一样，允许我们使用窗口、图标和菜单对系统进行操作。Linux是当今电脑界一个耀眼的名字，它是目前全球最大的一个自由免费软件，其本身是一个功能可与Unix和Windows相媲美的操作系统，具有完备的网络功能，它的用法与UNIX非常相似，因此许多用户不再购买昂贵的UNIX，转而投入Linux等免费系统的怀抱。

二、各操作系统特点

（一）Windows操作系统特点

从某种意义上说，Windows用户界面和开发环境都是面向对象的。用户采用“选择对象-操作对象”这种方式进行工作。比如要打开一个文档，我们首先用鼠标或键盘选择该文档，然后从右键菜单中选择“打开”操作，打开该文档。这种操作方式模拟了现实世界的行为，易于理解、学习和使用。

1.用户界面统

一、友好、漂亮：

Windows应用程序大多符合IBM公司提出的CUA (Common User Ace)标准，所有的程序拥有相同的或相似的基本外观，包括窗口、菜单、工具条等。用户只要掌握其中一个，就不难学会其他软件，从而降低了用户培训学习的费用。

2.丰富的设备无关的图形操作：

Windows的图形设备接口(GDI)提供了丰富的图形操作函数，可以绘制出诸如线、圆、框等的几何图形，并支持各种输出设备。设备无关意味着在针式打印机上和高分辨率的显示器上都能显示出相同效果的图形。

3.多任务：

Windows是一个多任务的操作环境，它允许用户同时运行多个应用程序，或在一个程序中同时做几件事情。每个程序在屏幕上占据一块矩形区域，这个区域称为窗口，窗口是可以重叠的。用户可以移动这些窗口，或在不同的应用程序之间进行切换，并可以在程序之间进行手工和自动的数据交换和通信。

（二）Unix操作系统特点

早期UNIX的主要特色是结构简炼、便于移植和功能相对强大，经过30来年的发展和进化，形成了一些极为重要并稳定的特色，其中主要包括：

1.技术成熟，可靠性高

经过30来年开放式道路的发展，UNIX的一些基本技术已变得十分成熟，有的已成为各类操作系统的常用技术。实践表明，UNIX是能达到大型主机（mainframe）可靠性要求的少数操作系统之一。目前许多UNIX大型主机和服务器在国外的大型企业中每天24小时，每年365天不间断地运行。例如，不少大企业或政府部门，即所谓肩负关键使命的场合/部门将其整个企业/部门信息系统建立并运行在以UNIX为主服务器的Client/Server结构上。但到目前为止，世界上还没有一家大型企业将其重要的信息系统完全建立在NT上。

2.极强的可伸缩性

UNIX系统是世界上唯一能在笔记本电脑、PC、工作站，直至巨型机上运行的操作系统，而且能在所有主要CPU芯片搭建的体系结构上运行（包括Intel/AMD及HP-PA、MIPS、PowerPC、UltraSPARC、ALPHA等RISC芯片）。至今为止，世界上没有第二个操作系统能达到这一点。此外，由于UNIX系统能很好地支持SMP、MPP和Cluster等技术，使其可伸缩性又有了很大的增强。目前，商品化UNIX系统能支持的SMP，CPU数已达到几百甚至更多个，MPP系统中的节点甚至已超过1024个UNIX支持的异种平台Cluster技术也已投入使用。UNIX的伸缩性远远超过了NT操作系统目前所能达到的水平

3.网络功能强

网络功能是UNIX系统的一又一重要特色，作为Internet网技术和异种机连接重要手段的TCP/IP协议就是在UNIX上开发和发展起来的。TCP/IP是所有UNIX系统不可分割的组成部分。因此，UNIX服务器在Internet服务器中占80％以上，占绝对优势。此外，UNIX还支持所有常用的网络通信协议，包括NFS、DCE、IPX/SPX、SLIP、PPP等，使得UNIX系统能方便地与已有的主机系统，以及各种广域网和局域网相连接，这也是UNIX具有出色的互操

作性（Interoperability）的根本原因。

4.强大的数据库支持能力

由于UNIX具有强大的支持数据库的能力和良好的开发环境，因此多年来，所有主要数据库厂商，包括Oracle、Informix、Sybase、Progre等，都把UNIX作为主要的数据库开发和运行平台，并创造出一个又一个性价比的新记录。UNIX服务器正在成为大型企业数据中心替代大型主机的主要平台。

5.开发功能强

UNIX系统从一开始就为软件开发人员提供了丰富的开发工具。成为工程工作站的首选和主要的操作系统和开发环境。可以说，工程工作站的出现和成长与UNIX是分不开的。至今为止，UNIX工作站仍是软件开发厂商和工程研究设计部门的主要工作平台。有重大意义的软件新技术的出现几乎都在UNIX上，如TCP/IP、WWW、OODBMS等。

6.开放性好

开放性是UNIX最重要的本质特性。开放系统概念的形成与UNIX是密不可分的。UNIX是开放系统的先驱和代表。由于开放系统深入人心，几乎所厂商都宣称自己的产品是开放系统，确实每一种系统都能满足某种开放的特性，如可移植性、可兼容性、可伸缩性、互操作性等。但所有这些系统与开放系统的本质特征—不受某些厂商的垄断和控制相去甚远，只有UNIX完全符合这一条件。

7.标准化

过去，Unix界被分析家和用户批判，因为没有为所有Unix操作系统提供统一的标准。其实，到目前为止，国际标准化组织（ISO）、工业团体恰恰是以UNIX基础制订了一系列标准化，如ISO/IEC的POSIX标准、IEEE POSIX标准、X/Open组织的XPG3/4工业标准以及后来的Spec 1170(因为它包含了1170个应用编程接口，后来改名为UNIX’95)标准。不少人对标准及标准化组织的作用及职权产生了误解。事实上，当标准化组织企图驾驭互相竞争的力量，和企图为用户规定他们的要求时是注定要失败的。比方说，标准只能用于给出道路的规则，而不应用于制造汽车。如果厂家被强迫完全遵从单一的标准，而不允许他们产品有特色，则用户将受害，Unix将变成象任何单一厂家的产品一样，没有任何特色。

（三）Linux操作系统特点

Linux作为自由软件有两个特点：一是它免费提供源码，二是爱好者可以按照自己的需要自由修改、复制和发布程序的源码，并公布在Internet上。这就吸引了世界各地的操作系统高手为Linux编写各种各样的驱动程序和应用软件，使得Linux成为一种不仅只是一个内核，而且包括系统管理工具、完整的开发环境和开发工具、应用软件在内，用户很容易获得的操作系统。

Linux是一个UNIX系统变种，因此也就具有了Unix系统的一系列优良特性，Unix上的应用可以很方便地移植到Linux平台上，这使得Unix用户很容易掌握Linux。

三、三种操作系统比较

（一）Linux操作系统和Windows操作系统比较

1.可完全免费得到

Linux操作系统可以从互联网上免费下载使用，只要您有快速的网络连接就行；而且，Linux上跑的绝大多数应用程序也是免费可得的。用了Linux就再也不用背”使用盗版软件”的黑锅了。

2.可以运行在386以上及各种RISC体系结构机器上

Linux最早诞生于微机环境，一系列版本都充分利用了X86CPU的任务切换能力，使X86CPU的效能发挥得淋淋尽致，而这一点连Windows都没有做到。此外，它可以很好地运行在由各种主流RISC芯片（ALPHA、MIPS、PowerPC、UltraSPARC、HP-PA等）搭建的机器上。

3.Linux是UNIX的完整实现

从发展的背景看，Linux与其他操作系统的区别是，Linux是从一个比较成熟的操作系统发展而来的，而其他操作系统，如WindowsNT等，都是自成体系，无对应的相依托的操作系统。这一区别使得Linux的用户能大大地从Unix团体贡献中获利。无论是Unix的作者还是Unix的用户，都认为只有Unix才是一个真正的操作系统，许多计算机系统（从个人计算机到超级计算机）都存在Unix版本，Unix的用户可以从很多方面得到支持和帮助。因此，Linux作为Unix的一个克隆，同样会得到相应的支持和帮助，直接拥有Unix在用户中建立的牢固的地位。UNIX上的绝大多数命令都可以在Linux里找到并有所加强。UNIX的可靠性、稳定性以及强大的网络功能也在Linux身上一一体现。

4.真正的多任务多用户

只有很少的操作系统能提供真正的多任务能力，尽管许多操作系统声明支持多任务，但并不完全准确，如Windows。而Linux则充分利用了X86CPU的任务切换机制，实现了真正多任务、多用户环境，允许多个用户同时执行不同的程序，并且可以给紧急任务以较高的优先级。

5.完全符合POSIX标准

POSIX是基于UNIX的第一个操作系统簇国际标准，Linux遵循这一标准这使UNIX下许多应用程序可以很容易地移植到Linux下，相反也是这样。

6.具有图形用户界面

Linux的图形用户界面是Xwindow系统。Xwindow可以做MSWindows下的所有事情，而且更有趣、更丰富，用户甚至可以在几种不同风格的窗口之间来回切换。

7.具有强大的网络功能

实际上，Linux就是依靠互联网才迅速发展了起来，Linux具有强大的网络功能也是自然而然的事情。它可以轻松地与TCP/IP、LANManager、Windows for Workgroups、Novell Netware或Windows NT网络集成在一起，还可以通过以太网或调制解调器连接到Internet上。Linux不仅能够作为网络工作站使用，更可以胜任各类服务器，如X应用服务器、文件服务器、打印服务器、邮件服务器、新闻服务器等等。

8.是完整的UNIX开发平台

Linux支持一系列的UNIX开发工上，几乎所有的主流程序设计语言都已移植到Linux上并可免费得到，如C、C++、Fortran7

7、ADA、PASCAL、Modual2和

3、Tcl/TkScheme、SmallTalk/X等。总而言之，Unix就是可供各种用户选择的对象。一个操作系统已经使分布式计算成为现实。一个操作系统正在使新形式的交互娱乐成为现实并正确领导通向新的工程和商业应用的路。这就是Unix所体现的精神。但Unix还不止于此。主要地，Unix给用户选择最佳应用、最佳开发环境、最佳网络功能和最佳硬件的自由，以满足用户的业务要求。Unix还给用户选择何时升级系统的自由，甚至当用户改变主意时，用户可以以最少的痛苦来安装一个新系统，只要业务需要。Unix专门献身于使用户保持选择的权力。

（二）UNIX操作系统WINDOWS操作系统比较

unix操作系统是主要是用于服务器类行,一些功能大多是以命令来实现的,大型企业大多

用这个做服务器,安全全性很好.WINDOWS一般是用于家庭,现在对于图形界面是最好的选择．

UNIX系统的安全性和权限分配上要比WINDOWS好的多，但是WINDOWS更适合家庭及普通办公人员使用，有些要求安全性较高的场所，向一些服务器，重要地点机房，还是要用unix的。

windows的优点是用户多，一般软件产商做个人桌面软件时都会有windows版本

linux的优点是可定制强，你安装系统可以选择不同版本内核、桌面（GNOME、KDE 都很漂亮，很好用）、和软件包管理软件等等。而且都是免费的，而且现在的基于linux的系统（ubuntu、fedora）安装软件都比较方便，它的添加删除程序里只要你选择了你要安装的软件包，就可以自己下载自己安装（官方的源里都有上万个软件包，而且免费）。 unix一般用于服务器，但是很少用于桌面，

（三）Linux操作系统与Unix操作系统的比较

某些PC机的Unix和Linux在实现方面相类似。几乎所有的商业Unix版本都基本支持同样的软件、程序设计环境和网络特性。然而，Linux和Unix的商业版本依然存在许多差别。Linux支持的硬件范围和商业Unix不一样。一般来说，商业Unix支持的硬件多一些，可是Linux支持的硬件也在不断扩大。突出的是，Linux至少和商用Unix一样稳定。对许多用户来说，最重要的因素是价格。Linux是免费软件，用户可以从Internet网上下载。如果上网不方便，可以很便宜地通过邮购得到Linux的磁盘或CD-ROM。当然也可以直接从朋友那里得到。商业Unix的价值不应被贬低。除了软件本身的价格外，用户还需支付文档、售后支持和质保费。对于较大的机构，这些都很重要，但是PC机用户也许从中得不到什么好处。许多商业公司和大学等单位已经发现，在实验室用廉价的PC机运行Linux比用工作站运行商业Unix还好。Linux可以在PC机上提供工作站的功能，而PC机的价格是工作站的几分之一。也有一些针对PC机的便宜的Unix，其中最有名的是386BSD。在许多方面，386BSD软件包和Linux兼容，但Linux更适合用户的需求。最显著的是，Linux的开发是开放的，任何志愿者都可以对开发过程做出贡献。相比之下，386BSD是由封闭的团队开发的。正是这样，这两种产品存在着严重的概念上和设计上的差别：Linux的目标是从头开始开发一个完整的Unix系统；386BSD的目标则是对现有的BSD做些修改，以适合80386系统。

第19篇：操作系统学习心得

操作系统学习心得

会计092班 姓名：潘东辉 学号：0904042062 1.下面就操作系统从2000年以来的发展做一个较简单的介绍。从一些文献中，我可以了解到：至2005年为止，用于通用计算机上的分布的操作系统主要两个家族：类Unix家族和微软Windows家族。而主机系统和嵌入式操作系统使用多样的系统，并且很多和Windows、Unix都没有直接的联系。类Unix家族包括多个组织的操作系统，其中有几个主要的子类包括System V、BSD和Linux。这里\'Unix\'是一个商标，开发组织允许使用操作系统在一个定义前提下自由地开发。这名字是通用大型设置操作系统类似组织 Unix。Unix系统运行在从巨型机到嵌入式系统的多种机器架构上。Unix主要使用于重要的商务服务器系统以及学院和工程环境中的工作站之上。和 AT&T Unix不同，自由软件比如Linux和BSD逐步开始流行，并且开始进入桌面操作系统领域。和一些Unix操作系统不同，像惠普公司的HPUX和IBM 公司的AIX是设计仅运行在客户购买的设备上，其中有一些特殊的（比如SUN公司的Solaris）可以运行在客户购买设备和基于工业标准的PC上。 APPLE公司的Mac OS X是一个BSD特例，以取代早期小型市场上的苹果公司Mac OS，众多流行的Unix操作系统正在走向一体。 微软公司的Windows操作系统家族起源于早期的IBM PC环境中的MS-DOS，现在版本是基于新的Windows NT内核，第一次是在OS/2中制定。和Unix不同，Windows只能运行在32位和64位的x86 CPU（如Intel或者AMD的芯片）上，尽管早期有版本运行于DEC Alpha，MIPS 和 PowerPC体系结构。今天Windows是一个流行的操作系统，在全球桌面市场中占有90%左右的份额，同时在中低端服务器市场也有广泛的应用，如 Web服务器和数据库服务器。

大型机系统，比如IBM公司的Z/OS，和嵌入式操作系统比如QNX、eCOs和PalmOS都是和Unix和Windows无关的操作系统，而 Windows CE、Windows NT Embedded 4.0和Windows XP Embedded都是和Windows相关的。

老的操作系统停留在市场包括类似IBM Windows的OS/

2、来自惠普的VMS(以前的DEC);苹果公司的Mac OS操作系统、非Unix先驱苹果公司Mac OS X，以及AmigaOS，第一个图形用户界面的操作系统，包括对于普通用户的高级的多媒体能力。

2.下面我简单的总结了一下操作系统的作用：操作系统在计算机系统中占据着一个非常重要的地位，它不仅是硬件与所有其他软件之间的接口，而且任何数字电子计算机都必须在其硬件平台上加载相应的操作系统之后，才能构成一个可以协调运转的计算机系统。只有在操作系统的指挥控制下，各种计算机资源才能被分配给用户使用。也只有在操作系统的支撑下，其他系统软件如各类编译系统、程序库和运行支持环境才得以取得运行条件。没有操作系统，任何应用软件都无法运行。有了操作系统就像是我们去饭店点菜一样方便，为我们提供了一个良好的平台，更好更直观的管理自己的计算机。操作系统主要有两方面重要的作用。

1)操作系统要管理系统中的各种资源，包括硬件及软件资源。操作系统对每一种资源的管理都必须进行以下几项工作：监视这种资源。该资源有多少，资源的状态如何，它们都在哪里，谁在使用，可供分配的又有多少，资源的使用历史等内容都是监视的含义。实施某种资源分配策略，以决定谁有权限可获得这种资源，何时可获得，可获得多少，如何退回资源等。分配这种资源。按照已决定的资源分配策略，对符合条件的申请者分配这种资源，并进行相应的管理事务处理。回收这种资源。在使用者放弃这种资源之后，对该种资源进行处理，如果是可重复使用的资源，则进行回收、整理，以备再次使用。2)操作系统要为用户提供的良好的界面。 操作系统，必须为最终用户和系统用户这两类用户的各种工作提供良好的界面，以方便用户的工作。典型的操作系统界面有两类：一类是命令行界面，如Unix和MS-DOS；另一类则是图形化的操作系统界面，典型的图形化的操作系统界面是MS Windows。

3．下面我就谈谈我在学习操作系统这门公选课时所得到的感悟。老师的教学风格既保守又开放，完全不限制学生太多的想象空间，让我们能够尽情发挥自己的创造力。本来我感觉操作系统一定是一门枯燥乏味的学科，但是却被我们的老师讲述的生动具体。从学习操作系统的过程中，我感受到就算是一个操作系统学科也蕴含了很多知识，要想学得透彻，完全搞明白也不是那么容易的。随着科学技术的日益发展，计算机技术的提高速度是相当惊人的，过一段时间就会有所更新。我们在买来电脑时，就已经注定着它的技术在淘汰了，只要几个月的时间，也许它就会被超越，计算机在我们国家的发展还是在起步阶段。有很多地方时需要我们向别人学习的我们应该思考为什么我们必须要用微软的windous，而我们就没有更好的操作系统来取代它吗？我们作为一个大学生，虽然我不是计算机专业的，但是我们一定要想着多学一些知识来武装自己，不使自己过早的被时代所淘汰。更何况是现在这样一个竞争如此激烈的年代，我们更应该为自己的将来做长期的打算。

第20篇：操作系统复习提纲

操作系统

一、复习重点和要求

第1章操作系统概述

考核学生对操作系统的定义、主要功能、主要类型、操作系统的特征以及分时概念等内容的学习情况。

【掌握】

1.操作系统的概念

操作系统是控制和管理计算机系统内各种硬件和软件资源、有效地组织多道程序运行的系统软件（或程序集合），是用户与计算机之间的接口。

记忆要点：操作系统是什么——是系统软件；

操作系统管什么——控制和管理计算机系统内各种资源；

操作系统有何用——扩充硬件功能，方便用户使用。

2.操作系统的主要功能

操作系统的五大主要功能：存储管理、进程和处理机管理、文件管理、设备管理、用户接口管理。

【理解】

1.操作系统的特征：并发、共享和异步性。

理解模拟：并发——“大家都前进了”；

共享——“一件东西大家用”；

异步性——“你走我停”，“走走停停”。

2.操作系统的主要类型

操作系统的主要类型有：多道批处理系统、分时系统、实时系统、网络操作系统、个人机操作系统、分布式系统和嵌入式操作系统。

UNIX系统是著名的分时系统。

3.分时概念：主要是指若干并发程序对CPU时间的共享。

【了解】

1.操作系统的形成；

2.分时和实时操作系统的特点；

3.操作系统在计算机系统中的地位：是裸机之上的第一层软件，是建立其他所有软件的基础。

4.操作系统结构设计：整体结构、层次结构、虚拟机结构和客户机-服务器结构。

5.操作系统为用户提供的三种用户接口：图形用户接口、命令行接口和程序接口。

系统调用是操作系统内核与用户程序、应用程序之间的接口。在UNIX/Linux系统，系统调用以C函数的形式出现。

第2章 进程管理

考核学生对进程定义、进程的状态及其转换、进程的组成、竞争条件和临界区、进程的同步与互斥、信号量和Ｐ、Ｖ操作及其一般应用、死锁的概念和产生死锁的必要条件等内容学习情况。

【掌握】

1.

2.进程的定义：进程是程序在并发环境中的执行过程。进程的状态及其转换 进程与程序的主要区别。进程最基本的属性是动态性和并发性。

进程的3种基本状态是：运行态、就绪态和阻塞态。掌握教材38页的进程状态及其转换图。

3.

4.进程的同步与互斥的概念。可以简单理解为：同步是协作，互斥是竞争。 信号量和Ｐ、Ｖ操作及其一般应用。

运用信号量机制和Ｐ、Ｖ操作，解决并发进程一般的互斥和同步问题。解决此类问题的一般方式： ① 根据问题给出的条件，确定进程有几个或几类；

② 确定进程间的制约关系——是互斥，还是同步；

③ 各相关进程间通过什么信号量实现彼此的制约，标明信号量的含义和初值；

④ 用P、V操作写出相应的代码段；

⑤ 验证代码的正确性：设以不同的次序运行各进程，是否能保证问题的圆满解决。切忌按固定顺序

执行各进程。

【理解】

1.

2.

3.

4.

的动作。

5.

件。

【了解】

1.进程间的3种高级通信：共享内存、管道文件和消息传递。死锁的概念；死锁的4个必要条件：互斥条件、不可抢占条件、占有且申请条件、循环等待条多道程序设计概念及其优点。 进程的一般组成，应深入理解进程控制块的作用。每个进程有惟一的进程控制块。 Linux进程管理的基本命令：ps、kill、sleep。 理解进程临界资源和临界区的概念，进程进入临界区的调度原则。信号量概念，P、V操作执行

第3章处理机调度

考核学生对作业状态、作业调度和进程调度的功能、性能评价标准、常用调度算法、Linux常用调度命令、中断处理过程、shell命令执行过程等内容的学习情况。

【掌握】

1.

备的。

2.

的计算。

要求：能利用图表形式列出各作业或进程的有关时间值，如到达时间、运行时间、开始时间、完成时间等，利用评价公式计算出各指标的值，如周转时间、平均周转时间。

【理解】

1.作业的四种状态：提交、后备、执行和完成。

2.作业调度与进程调度的关系。简单比喻：作业调度是演员上场前的准备，进程调度是让演员上场

表演。

3.调度性能评价标准

评价调度算法的指标：吞吐量、周转时间、带权周转时间、平均周转时间和平均带权周转时间。

4.中断处理过程：保存现场、分析原因、处理中断和中断返回。

5.shell命令的一般执行过程。

【了解】

1.调度的三个级别：高级调度、中级调度和低级调度，其中高级调度又称作业调度，低级调度又称常用调度算法 掌握三种基本调度算法（先来先服务法、时间片轮转法、优先级法）的实现思想，并能进行评价指标作业调度和进程调度的功能 作业调度的功能见教材85页，进程调度的功能见教材86页。在一般操作系统中，进程调度是必须具

进程调度。

2.调度策略的选择。

3.中断概念

中断是指CPU对系统发生的某个事件做出的一种反应，它使CPU暂停正在执行的程序，保留现场后自动执行相应的处理程序，处理该事件后，如被中断进程的优先级最高，则返回断点继续执行被“打断”的程序。

第4章存储管理

考核学生对重定位、分区法、分页的概念、虚拟存储概念、请求分页存储管理技术、常用页面置换算法。

【掌握】

1.

2.掌握以下概念：逻辑地址、物理地址、逻辑地址空间、物理地址空间、重定位、静态重定位、动态重定位、碎片、虚拟存储器。分区法

分区法分为固定分区法和动态分区法两种。要掌握其基本原理、数据结构、地址转换、内存空间的分配与释放、分配算法、优点和缺点。

3.

4.分页技术 虚拟存储器 掌握分页存储管理的基本方法，如地址表示、从逻辑地址到物理地址的转换、数据结构等。

虚拟存储器（Virtual Memory）是用户能作为可编址内存对待的虚拟存储空间，它使用户逻辑存储器与物理存储器分离，是操作系统给用户提供的一个比真实内存空间大得多的地址空间。

虚拟存储器的基本特征：虚拟扩充、部分装入、离散分配、多次对换。此外，虚拟存储器的容量不是无限大的，它主要受到地址的字长和外存容量的限制

5.

储器。

实现请求分页，系统必须提供一定容量的内存和外存，以及支持分页机制，还需要有页表机制、缺页中断机构以及地址转换机构。

6.常用页面置换算法

能应用先进先出法（FIFO）、最佳置换法（OPT）、最近最少使用置换法（LRU）的实现思想计算页面淘汰序列、缺页次数以及缺页率。

【理解】

1.重定位

把逻辑地址转变为内存物理地址的过程称作重定位。根据重定位的时机，分为静态重定位和动态重定位。理解它们的概念、实现思想和优缺点。

。

【了解】

1.存储器层次

了解典型的存储器层次结构：寄存器、高速缓存、内存、磁盘、磁带。

2.

3.用户程序的地址空间 对换技术的实现思想。 请求分页技术 请求分页存储管理技术是在单纯分页技术基础上发展起来的，二者根本区别在于请求分页提供虚拟存用户程序的主要处理阶段：编辑、编译、链接、装入和运行。

第5章 文件系统

考核学生对文件的分类、文件系统的功能、文件的逻辑组织和物理组织、文件的目录结构、文件存储空间的管理、文件的存取控制等内容的学习情况。

【掌握】

1.文件系统的功能

一般说来，文件系统应具备以下功能：文件管理、目录管理、文件存储空间的管理、文件的共享和保护、提供方便的接口。

2.

3.文件的逻辑组织和物理组织 文件的目录结构 掌握文件的逻辑组织和物理组织的概念，以及相应的组织形式。

文件目录的基本组织方式有单级目录、二级目录、树形目录。

4.文件存储空间的管理

文件存储空间的管理是对外存空间中空闲盘块的管理。对空闲盘块的管理方式主要有：空闲盘块表、空闲块链接、位示图和空闲块成组链接等。

【理解】

1.文件的分类

按用途分为：系统文件、库文件、用户文件；

按文件中的数据形式分为：源文件、目标文件、可执行文件；

按存取权限分为：只读文件、读写文件、可执行文件；

按保存时间分为：临时文件、永久文件；

在UNIX/Linux和MS-DOS系统中，文件分为普通文件、目录文件和特殊文件。而普通文件又分为ASCII文件和二进制文件两种。

2.文件的存取控制

为了实现文件系统的安全，文件需要保护和保密。对文件的存取控制可分别由存取类型来设定，如读、写、执行等，也可以通过命名、口令、存取权限或者加密的方法实现对文件的保护和保密

【了解】

1.文件的链接

Linux具有为一个文件起多个名字的功能，称为链接。文件链接是实现文件共享的有效途径，分为硬链接和符号链接。

第6章 设备管理

考核学生对设备管理功能、设备分配技术、缓冲技术、SPOOLing系统、设备驱动程序概念、磁盘调度和管理等内容的学习情况。

【掌握】

1.设备管理的功能

操作系统中设备管理的功能简单地说就是：监视设备状态；进行设备分配；完成I/O操作；缓冲管理与地址转换。

2.设备分配技术

设备分配技术主要有：独占分配、共享分配和虚拟分配。独占分配适用于独占设备，系统效率低；共享分配适用于高速、大容量直接存储的共享设备，设备的利用率较高；虚拟分配技术利用共享设备去实现独占设备的功能，从而使独占设备“感觉上”成为可共享的、快速的I/O设备。

3.设备驱动程序概念

设备驱动程序是控制设备动作（如设备的打开、关闭、读、写等）的核心模块，用来控制设备上数据的传输。

4.

法。

【理解】

1.设备独立性

设备独立性是设备管理要达到的目标之一，就是说，用户程序应与实际使用的物理设备无关，由操作系统考虑因实际设备不同而需要使用不同的设备驱动程序等问题。

2.SPOOLing系统

实现虚拟分配最成功的技术是SPOOLing（外部设备联机并行操作），也称假脱机技术。SPOOLing系统用常驻内存的进程去模拟一台外围机，用一台主机就可完成脱机技术中需用三台计算机完成的工作。

理解SPOOLing系统的功能和实现思想。

3.缓冲技术

理解引入缓冲技术的主要目的和缓冲区的设置方式。

【了解】

1.

2.设备分类和标识 处理I/O请求的步骤 了解设备的一般分类：存储设备（块设备），输入/输出设备（字符设备）。 磁盘调度算法 常用的磁盘调度算法有：先来先服务法、最短寻道时间优先法和电梯法。重点掌握前两种磁盘调度算

第7章 现代操作系统发展

考核学生对现代操作系统发展、嵌入式和分布式操作系统的一般知识的学习情况。

【了解】

1.嵌入式操作系统的概念、功能和特性

嵌入式操作系统是嵌入式系统中使用的操作系统。作为一种操作系统，它具有一般操作系统的基本功能，但是，由于嵌入式操作系统的硬件平台和应用环境与一般操作系统不同，所以它有自身的特点，其的最大特点就是可定制性。

2.分布式操作系统的概念、功能和特性。

分布式操作系统是配置在分布式系统上的共用操作系统。分布式操作系统实施系统整体控制，对分布在各节点上的资源进行统一管理，并且支持对远程进程的通信协议。

分布式操作系统要求实现用户面前的虚拟单处理机系统到具体的分布式系统的映射。它有如下三个基本功能：进程管理；通信管理和资源管理。

3.未来操作系统应具有的新特征。

更强的分布式处理能力，更高的安全性和可靠性，符合开放式模型，更方便的用户界面。

《操作系统心得体会.doc》

将本文的Word文档下载到电脑，方便编辑。

推荐度：

点击下载文档