操作系统面试（精选多篇）

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

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操作次数。

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

转眼间，学习了一个学期的计算机操作系统课程即将结束。在这个学期中，通过老师的悉心教导，让我深切地体会到了计算机操作系统的一些原理和具体操作过程。在学习操作系统之前，我只是很肤浅地认为操作系统只是单纯地讲一些关于计算机方面的操作应用，并不了解其中的具体操作过程和实用性。通过这一学期的学习，我才知道操作系统(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

李大鹏

指导教师

张博

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

长春理工大学 软件学院 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(); }

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

湖北民族学院信息工程学院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

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

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

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

指导

信息技术学院课设书

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

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

课设项目指导书

课设项目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）、写出课程设计报告书。

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

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级操作系统课程设计论文（设计）

装

订

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

操作系统心得体会

电脑使用一段时间后机箱里会存积大量的灰尘，这些灰尘会影响硬件的散热，尤其会影响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干脆就照着参考资料打上去了。于是老师认为我不熟，在那题上打了个半钩。当时心里确实感到十分地遗憾和沮丧，心想所谓台上一分钟，台下十年功，一分钟若把握不好，也同样尽毁十年功啊！

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

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

课程实验报告

课程名称：

操作系统原理课程设计

专业班级： 学

号： 姓

名 指导教师： 报告日期：

计算机科学与技术学院

目录

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

推荐第9篇：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秒后重新启动。

区域和语言设置选用默认值就可以了。

输入你想好的姓名和单位，这里的姓名是你以后注册的用户名。

输入安装序列号。

安装程序自动为你创建又长又难看的计算机名称,自己可任意更改。 输入系统管理员密码。

设置好日期和时间。

开始安装,复制系统文件、安装网络系统。

让你选择网络安装所用的方式，选典型设置。

顺利安装完成。

推荐第10篇：操作系统实验报告

实验二

进程调度

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 姓名：明章辉

指导教师：徐军利

第11篇：操作系统教案

操作系统

教案

操作系统课程简介

（一）课程性质

本课程是计算机科学与技术专业的核心课程之一，属于必修课程。

“操作系统”是计算机系统不可缺少的软件组成部分，负责对系统中各种资源进行有效的管理和对各种活动进行正确的组织，使整个计算机系统协调一致且高效地工作，指挥计算机系统正常运行。操作系统基于硬件，并对硬件实施管理，并构成对所有软件运行的支持平台，给用户使用计算机提供方便灵活友好的接口。

本课程的先修课为计算机组成原理、微机原理、数据结构、高级语言程序设计；后续课程为数据库系统原理、计算机网络、分布式系统等。

（二）教学目的

通过本课程的学习，使学生在深刻理解计算机系统整体概念的基础之上，掌握操作系统的基本原理及实现方法，掌握操作系统对计算机系统中各种资源的管理和控制功能，从而使学生具备一定的系统软件开发技能，为以后从事的研究、开发工作提供必要的软件基础和基本技能。

（三）教学内容

本课程内容包括：绪论，是对操作系统的一般性描述，包括什么是操作系统，操作系统在整个计算机系统的地位及其发展历史，它的功能、分类等；作业管理和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 设计计算机操作系统时与哪些硬件器件有关？ 【下课】

第12篇：操作系统比较

常见操作系统比较

一、三种操作系统简介

（一）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系统。

第13篇：操作系统学习心得

操作系统学习心得

会计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，而我们就没有更好的操作系统来取代它吗？我们作为一个大学生，虽然我不是计算机专业的，但是我们一定要想着多学一些知识来武装自己，不使自己过早的被时代所淘汰。更何况是现在这样一个竞争如此激烈的年代，我们更应该为自己的将来做长期的打算。

第14篇：操作系统复习提纲

操作系统

一、复习重点和要求

第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.未来操作系统应具有的新特征。

更强的分布式处理能力，更高的安全性和可靠性，符合开放式模型，更方便的用户界面。

第15篇：操作系统实验报告

许昌学院

《操作系统》实验报告书

学号：姓名：闫金科班级：成绩:

5006140057

14物联网工程 2016年02月实验一 Linux的安装与配置

一、实验目的

1.熟悉Linux系统的基本概念，比如Linux发行版、宏内核、微内核等。2.掌握Linux系统的安装和配置过程，初步掌握Linux系统的启动和退出方法。 3.熟悉Linux系统的文件系统结构，了解Linux常用文件夹的作用。

二、实验内容

1.从网络上下载VMware软件和两个不同Linux发行版镜像文件。2.安装VMware虚拟机软件。

3.在VMware中利用第一个镜像文件完成第一个Linux的安装，期间完成网络信息、用户信息、文件系统和硬盘分区等配置。

4.在VMware中利用第二个镜像文件完成第二个Linux的安装，并通过LILO或者GRUB解决两个操作系统选择启动的问题。

5.启动Linux系统，打开文件浏览器查看Linux系统的文件结构，并列举出Linux常用目录的作用。

三、实验过程及结果

1、启动VMware，点击新建Linux虚拟机，如图所示：

2、点击下一步，选择经典型，点击下一步在选择客户机页面选择Linux，版本选择Red Hat Enterprise Linux 5，如图所示：

3、点击下一步创建虚拟机名称以及所要安装的位置，如图所示：

4、点击下一步，磁盘容量填一个合适大小，此处选择默认值大小10GB，如图所示：

5、点击完成，点击编辑虚拟机设置，选择硬件选项中的CD-ROM （IDE...）选项，在右侧连接中选择“使用ISO镜像（I）”选项，点击“浏览”，找到Linux的镜像文件，如图所示：

6点击确定按钮后，点击启动虚拟机按钮，来到Linux的安装界面，如图所示：

7、到此页面之后，等待自动检测安装，如图所示：

8、等到出现如图所示页面后点击“skip”按钮，跳过检测，直接进入安装设置界面，如图所示：

9、安装设计界面如图所示：

10、点击Next按钮进入设置语言界面，设置语言为“简体中文”，如图所示：

11、点击Nest按钮进入系统键盘设置按钮，设置系统键盘为“美国英语式”，如图所示：

12、点击下一步按钮，弹出“安装号码”对话框，选择跳过输入安装号码，如图所示：

13、按照提示，一直点击下一步按钮，如图所示：

14、到设置最后一步，点击下一步按钮进入开始安装Red Hat Enterprise Linux Sever界面，如图所示：

15、安装完成后，进入欢迎界面，按照提示点击前进按钮知道进入Linux桌面，如图所示：

16、安装成功的Linux系统桌面如图所示,桌面包含五个图标，分别为：计算机、jk’s Home、回收站、RHEL/5.3 i386DVD。

四、实验总结

通过安装虚拟机等操作让我认识到Linux这系统一些基本特点，本次试验学会了安装虚拟机并且使用虚拟机安装操作系统，掌握了红帽Linux系统的安装和配置过程，以及对镜像ISO文件的使用，有别于我们机器上使用的系统，通过虚拟机这个软件还可以在已有系统的基础上使用其他操作系统。安装过程中一定要注意选择版本的时候要选择Red Hat Enterprise Linux 5版本，否则安装不能成功。自己动手成功的安装了Linux系统，自己对Linux的学习产生更大的兴趣。

实验二 Linux操作系统的运行模式

一、实验目的

1.熟悉Linux系统终端工作环境的使用，了解Linux命令的格式，使用学会利用常用的Linux命令来完成系统的管理和维护。

2.了解X-Windows的特点，熟悉Linux图形用户接口的使用，掌握GNOME桌面环境的基本操作。

3.了解和掌握在Linux环境下安装软件包的方法，如QQ for Linux等用软件的安装方法。

二、实验内容

1.启动Linux系统打开虚拟终端界面，使用Linux的在线帮助指令man或help获得ls、uname、date、cal、mkdir、cp等Linux命令的帮助手册，了解这些命令的具体使用方法。同时，也可以通过执行“命令名 –help”来显示该命令的帮助信息，如“ls –help”,试用这些命令。

2.通过uname命令的执行，查看并给出相关系统信息：操作系统的名称、系统域名、系统CPU名称等。

3.在主目录下创建一个名为myetc的子目录，将/etc目录下与网络相关的文件和子目录拷贝到该目录，并将这些文件的执行权限设置为可执行。

4.在主目录/home下创建目录program、music 和temp，然后在program下建立目录java和C，列出完成该过程的所有命令。

5.在图形界面环境中，查看GNOME桌面的面板和桌面，设置GNOME，包括屏幕保护程序、更改背景和指定关联程序等。6.实现对光盘的加载和访问，然后卸载。

三、实验过程及结果

1、打开终端，输入 【ls –help】来查看【ls】指令的使用方法，同理查看uname、date 、cal、mkdir、cp的使用方法。

2、在终端中输入【uname –a】显示操作系统名系统cpu名和系统域名

3、重启系统，用【root】用户名进入系统，以获得权限。在终端中输入【mkdir myetc】，在主目录下创建【myrtc】的目录，【ls】查看是否创建。输入【cd..】返回至【/】文件，输入【cp –r etc root/myetc】讲etc中内容复制到myetc中，进入myetc文件【ls】查看。输入

【chmod u+x etc】赋予文件可执行的权限，输入【ll】查看。

4、在home下，输入【mkdir {program,music,temp}】,可在home下创立这三个目录，输入【ls】查看。在program下输入【mkdir{java,C}】，可创立java和C两个目录，【ls】查看。

5、在桌面上方选择【系统】-【首选项】，即可设置屏幕保护程序和更改背景和指定关联程序

5、在桌面上可见看到有CD光盘，双击浏览，右键【弹出】即卸载。

四、实验总结和体会

Linux的指令系统是学习Linux操作系统很重要的一部分，指令系统相当于在Windows操作系统下的doc，可以省去图形化界面。通过这次的实验让我了解了Linux的强大功能，了解到Linux有许多方便快捷的设置基本配置的方法，这使我更喜欢上Linux的使用。在使用指令的过程中，有时候对文件的操作需要一定的权限，这时需要在登陆时用户名使用【root】，而不是我们在安装时使用的用户名，这样就获得了管理员权限，可以对一些系统文件进行操作。

实验三 Linux应用软件与系统管理

一、实验目的

1.了解OpenOffice.Org集成办公软件，掌握利用OpenOffice.Org的套件来完成文档和图片的处理。

2.了解Linux网络管理的知识，熟悉Linux网络配置的方法，掌握在Linux环境下配置Web服务器和ftp服务的方法。

二、实验内容

1.配置Linux系统的网络环境，安装FTP和Web服务器，并配置相关的属性，利用FTP实现WINDOWS和Linux之间的数据交换。

2.利用FTP程序上传自己的照片到FTP服务器，利用OpenOffice的文字处理工具OpenOffice Writer制作一份表格形式的个人简历。个人简历中至少包含学号、姓名、性别、专业、照片和学习经历等内容，并保存为网页格式(html格式)。 3.将个人简历网页设置为WEB服务器的首页，然后在客户端利用浏览器访问WEB服务器，查看效果。

4.通过读取proc文件系统，获取系统各种信息（如主机名、系统启动时间、运行时间、版本号、所有进程信息、CPU使用率等），并以比较容易的方式显示。

三、实验过程及结果

1.配置网络环境：在 （服务.cmd）.里面进行以下操作：在服务里选择3按回车

完成后，可在本地连接看到VMware已连接上网络

在虚拟机设置中设置以太网网络连接方式为

网关地址填虚拟机的网管，IP地址设为虚拟机的一个子网：

四、总结：

在linux系统下，make是我们经常用到的编译命令，所以关于make代码和他的操作指令一定要记清楚。所以，熟练掌握了make和makefile工具之后，源码安装软件就变的像windows下安装软件一样简单。

实验四 进程控制与管理

一、实验目的

1.掌握GCC编译器的用法，学会利用GCC编辑器来编辑C语言程序，学会利用GDB调试器来调试C语言程序。

2.理解进程和程序的区别和联系，

3.掌握在Linux环境下观察进程运行情况和CPU工作情况的命令。4.了解fork()系统调用，掌握利用fork()创建进程的方法。

5.了解Linux系统其他与进程相关的系统调用，如exec、wait和exit等。6.了解Linux常用的进程通信机制。

二、实验内容

1.利用Linux的进程管理命令ps、top来监视和跟踪进程，体会进程和程序的关系。2.利用Linux的文字编辑器编写文件复制的C语言程序，并用gcc编译该程序，然后运行该程序。

3.编写一段程序，使用系统调用fork( )创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示\'a\'，子进程分别显示字符\'b\'和字符\'c\'。试观察记录屏幕上的显示结果，并分析原因。

4.修改上述程序，每一个进程循环显示一句话。子进程显示\'daughter „\'及\'son „„\'，父进程显示 \'parent „„\'，观察结果，分析原因。 5.用fork( )创建一个进程，再调用exec( )用新的程序替换该子进程的内容。

三、实验过程及结果

1、利用Linux的进程管理命令ps、top来监视和跟踪进程，体会进程和程序的关系。从用户身份切换到ROOT身份

输入命令 ps 查看进程

输入命令 top 跟踪进程

2、利用Linux的文字编辑器编写一个计算机100个自然数和的C语言程序，并用gcc编译该程序，然后运行该程序。

创建一个.C文件 并进入进行编辑

用GCC 进行编译，再查看文件，发现产生执行文件 a.out

执行这个可执行文件得到结果5050

1、编写一段程序，使用系统调用fork( )创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示\'a\'，子进程分别显示字符\'b\'和字符\'c\'。试观察记录屏幕上的显示结果，并分析原因。

穿件一个.C文件 并进行编写程序代码

反复执行2次该程序

可以看出两次执行的结果 a b c 出现的顺序不同，原因是，3个进程的输出次序是随机的，并不会按规定的顺序出现，所以会出现上述结果。

4、修改上述程序，每一个进程循环显示一句话。子进程显示\'daughter „\'及\'son „„\'，父进程显示 \'parent „„\'，观察结果，分析原因。 重新修改代码

执行这段程序

原分析：

因和之前一样，可以看出执行的结果 3个单词出现的顺序不同，原因是， 3个进程的输出次序是随机的，并不会按规定的顺序出现，所以会出现上述结果。

5、用fork( )创建一个进程，再调用exec( )用新的程序替换该子进程的内容。

编写代码

执行的结果

结果表明 execl 替代了ｓｏｎ的内容

四、实验总结和体会

这个实验考察的是进程之间存在很多可能性以及对编辑器的使用。本次实验学习了在linux环境下用gcc编译器运行c语言程序，在linux环境下编写程序用到了vi编辑器，知道了该编辑器也需要各种命令来操作。编写C语言程序时用到了fork()函数，再调用execl()用新的程序替换该子进程的内容。

实验五 进程调度模拟程序的设计与实现

一、实验目的

1.了解进程调度的概念，掌握常用进程调度算法的原理。2.掌握Linux程序设计编辑、编译和调试的技巧。

二、实验内容

1.编写程序实现进程调度调度算法先来先服务、优先级高优先和时间片轮转调度算法。（编程语言不限）

2.输入数据，输出运行结果。

三、实验过程及结果

1先来先服务

＃i nclude float t,d;

struct { int id;

float ArriveTime; float RequestTime; float StartTime; float EndTime; float RunTime; float DQRunTime; int Status; }arrayTask[4]; GetTask() { int i; float a;

for(i=0;i

printf(\"input the the ArriveTime of arrayTask[%d]:\",i); scanf(\"%f\",&a);

arrayTask[i].ArriveTime=a;

printf(\"input the RequestTime of arrayTask[%d]:\",i); scanf(\"%f\",&a);

arrayTask[i].RequestTime=a; arrayTask[i].StartTime=0; arrayTask[i].EndTime=0; arrayTask[i].RunTime=0; arrayTask[i].Status=0;

} }

int fcfs()

{

int i,j,w=0;

for(i=0;i

{

if(arrayTask[i].Status==0)

{

t=arrayTask[i].ArriveTime;

w=1;

}

if(w==1)

break;

}

for(i=0;i

{

if(arrayTask[i].ArriveTime

t=arrayTask[i].ArriveTime;

}

for(i=0;i

{

if (arrayTask[i].ArriveTime==t)

return i;

}

}

int sjf() {

int i,x=0,a=0,b=0; float g;

for(i=0;i

if(arrayTask[i].Status==1) {g=arrayTask[i].EndTime; x=1; } }

if(x==0){

t=arrayTask[0].ArriveTime;

for(i=0;i

if(arrayTask[i].ArriveTime

t=arrayTask[i].ArriveTime; a=i; } }

return a; } else {

for(i=0;ig) g=arrayTask[i].EndTime; }

for(i=0;i

if(b!=0) /*有进程到达则按SJF*/ { for(i=0;i

if(arrayTask[i].Status==0&&arrayTask[i].ArriveTime

return a; } else{ /*否则按FCFS*/ for(i=0;i

{if(arrayTask[i].Status==0) t=arrayTask[i].ArriveTime; }

for(i=0;i

if(arrayTask[i].Status==0&&arrayTask[i].ArriveTime

return a; } } }

new(int s) /*定义执行进程后相关数据的修改*/ { int i,g=0; for(i=0;i

if(arrayTask[i].Status==0) continue; else { g=1; break; } }

if(g==0) /*当处理的是第一个未执行的进程时执行*/ {

arrayTask[s].StartTime=arrayTask[s].ArriveTime;

arrayTask[s].EndTime=arrayTask[s].RequestTime+arrayTask[s].ArriveTime; arrayTask[s].RunTime=arrayTask[s].RequestTime; arrayTask[s].Status=1; g=2; }

if(g==1) /*当处理的不是第一个未执行的进程时执行*/ {

arrayTask[s].Status=1; for(i=0;i

if(arrayTask[i].Status==1) d=arrayTask[i].EndTime; }

for(i=0;i

if(arrayTask[i].EndTime>d&&arrayTask[i].Status==1) d=arrayTask[i].EndTime; }

if(arrayTask[s].ArriveTime

arrayTask[s].StartTime=arrayTask[s].ArriveTime;

arrayTask[s].EndTime=arrayTask[s].StartTime+arrayTask[s].RequestTime; arrayTask[s].RunTime=arrayTask[s].EndTime-arrayTask[s].ArriveTime; }

arrayTask[s].DQRunTime=arrayTask[s].RunTime/arrayTask[s].RequestTime; }

Printresult(int j) /*定义打印函数*/ {

printf(\"%d\\t\",arrayTask[j].id);

printf(\"%5.2f\\t\",arrayTask[j].ArriveTime); printf(\"%5.2f\\t\",arrayTask[j].RequestTime); printf(\"%5.2f\\t\",arrayTask[j].StartTime); printf(\"%5.2f\\t\",arrayTask[j].EndTime); printf(\"%5.2f\\t\",arrayTask[j].RunTime); printf(\"%5.2f\\n\",arrayTask[j].DQRunTime); } main() {

int i,b,k,a,c=0; int d[4]; clrscr();

printf(\"\\t F.FCFS \\n\"); printf(\"\\t S.SFJ \\n\"); printf(\"\\t Q.EXIT \\n\"); for(i=0;;i++) { if(c) break;

printf(\"please input the number a:\\n\"); scanf(\"%d\",&a); switch(a) {

case Q: c=1; break;

case F:printf(\"please input the different-ArriveTime of arrayTasks\\n\"); GetTask();

printf(\"*****************************the result of fcfs\\n\"); printf(\"Number\\tArrive\\tServer\\tStart\\tFinish\\tTurnove\\tTake power turnover time\\n\");

for(b=0;b

k=fcfs(); d[b]=k; new(k); }

for(b=0;b

Printresult(d[b]);/*调用打印函数打出结果*/ continue;

case S: printf(\"please input the different-RequestTime of array

Tasks\\n\"); GetTask();

printf(\"******************************the result of sjf\\n\"); printf(\"Number\\tArrive\\tRequest\\tStart\\tEnd\\tRun\\tDQRun time\\n\"); for(b=0;b

for(b=0;b

default:printf(\"the number Error.please input another number!\\n\"); } } }

四、实验总结和体会

通过做本实验，让我对进程或作业先来先服务、高优先权、按时间片轮转调度算法以及进程调度的概念和算法，有了更深入的认识！理解进程的状态及变化，动态显示每个进程的当前状态及进程的调度情况。进程调度是处理机管理的核心内容。优先级高优先是根据作业的优先级，总是选择优先级最高者进入队列。轮转调度算法是调度程序每次把CPU分配给就绪队列首进程/线程使用规定的时间间隔，就绪队列中都路保留巡行一个时间片。

第16篇：操作系统实验报告

实验项目二 进程管理

一、实验目的

1.理解进程的概念，掌握父、子进程创建的方法。

2.认识和了解并发执行的实质，掌握进程的并发及同步操作。

二、实验内容

1.编写一C语言程序，实现在程序运行时通过系统调用fork( )创建两个子进程，使父、子三进程并发执行，父亲进程执行时屏幕显示“I am father”，儿子进程执行时屏幕显示“I am son”，女儿进程执行时屏幕显示“I am daughter”。

2.多次连续反复运行这个程序，观察屏幕显示结果的顺序，直至出现不一样的情况为止。记下这种情况，试简单分析其原因。

3.修改程序，在父、子进程中分别使用wait()、exit()等系统调用“实现”其同步推进，并获取子进程的ID号及结束状态值。多次反复运行改进后的程序，观察并记录运行结果。

三、源程序及运行结果

源程序1：

#include #include #include int main(int argc, char ** argv ) { int pid=fork(); if(pid

printf(\"error!\");

else if( pid == 0 )

{

printf(\"I am son!\\n\");

}

else

{

int pid=fork();

if (pid

printf(\"error!\");

else if( pid == 0 )

{

printf(“I am daughter! \\n\");

}

else

printf(\"I am father!\\n\");

} sleep(1); return 0; }

运行结果：

源程序2：

#include #include #include int main(int argc, char ** argv ) { char *meage; int n;

int pid=fork(); if(pid

printf(\"error!\");

else if( pid == 0 )

{

meage=\"I am daughter!\";

pid=getpid();

n=3;

}

else

{

int pid=fork();

if (pid

printf(\"error!\");

else if( pid == 0 )

{

meage=\"I am son!\";

pid=getpid();

n=3;

}

else

meage=\"I am father!\";

n=3;

}

for(;n>0;n--) { puts(meage); sleep(1); }

return 0; }

运行结果：

四、实验分析与总结

1.实验内容1运行结果为什么无固定顺序，fork()函数创建进程是如何并发执行的。

答：因为进程是并发执行的，fork()函数创建的三个进程抢占

cpu不同，从而导致三个程序被cpu 调度顺序不同，所以实验一结果无固定顺序。Fork()函数调用成功后，子进程与父进程并发执行的代码相同，但由于子进程也继承父进程的程序指针，所以子进程是从fork()后执行的，另外fork在子进程和父进程中返回值是不同的。在父进程中返回子进程的pid，而在子进程中返回0，使父进程和子进程执行不同的分支。

2.实验内容3是如何实现父子进程的同步执行的。

答：wait（）会暂时停止目前进程的执行，直到有信号来到或子进程结束。程序段主要使用了函数wait（）和，exit（）这是因为父进程必须等待两个子进程终止后才终。在父进程中调用wait()函数，则父进程被阻塞，进入等待队列，等待子进程结束。子进程终止时执行exit（）向父进程发终止信号，当接到信号后，父进提取子进程的结束状态值，从wait()返回继续执行原程序，从而实现了父、子进程的同步推进。

总结：通过进程管理实验，了解fork()函数创建进程是并发执行的，wait()进程表示会暂时停止目前进程的执行，可以灵活运用fork()和wait()进程解决有关问题。在实验中遇到许多问题，如：实验中调用fork()进程失败，可能的原因有系统中有太多的进程或者实际用户ID的进程总数超过了系统的限制。刚接触VMware这个系统，操作不熟悉，多次操作后，了解这个系统有关操作，实验做起来就比较简单了。对实验代码也不熟悉，最后通过请教老师和同学，终于实验理解透彻，并成功运行了。不仅上课要认真听课，要想真正学会，课下也要付出努力。

第17篇：操作系统心得体会

操作系统心得体会

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

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

第18篇：操作系统教学大纲

《计算机操作系统原理》教学大纲

一、课程的性质、地位：

《计算机操作系统原理》是大学计算机专业的核心专业课程。通过系统学习计算机操作系统原理的基本理论与基本概念以及相关的操作系统的内涵，重点掌握操作系统进程管理、处理机调度、存储管理、设备管理和文件系统。基本知识与基本原理，掌握操作系统在计算机专业中的重要作用。为今后进一步学习计算机知识和技术打下良好的基础。

二、教学目的及要求

为了使本专业学生系统、深入地掌握计算机有关知识，为信息系统的分析和开发打下良好的基础，特开设此课程。本课程要求学生掌握操作系统的基本特征、发展过程、功能及操作系统的结构设计；了解作业管理和用户接口；了解进程和线程的基本概念、同步与通信、调度与死锁，以及处理机管理；了解连续式、离散式存储器的管理方式及虚拟存储器；了解设备管理、文件管理、网络操作系统以及操作系统的实例UNIX系统等。本课程是专业基础课，学习本课程前要求学生已学习计算机基本原理程序设计以及数据结构等课程。

三、课程教学目标：

《计算机操作系统原理》是计算机专业的核心必修课，通过《计算机操作系统原理》课程的教学，培养学生掌握计算机操作系统原理，学会使用计算机操作系统的原理来理解计算机的工作，并为进一步深入学习本专业的计算机理论打下坚实的基础。

四、课程教学的基本要求：

教学中，要坚持精讲、多练，原理部分不容易理解，要注意在实际中的应用。提倡任务驱动的教学方法，但要避免教一会一的死板教学。要以学生为中心，培养学生探究的能力，鼓励同学之间的讨论和交流，达到全面提高学生能力的目标。

五、本课程与相关课程的联系：

本课程属于专业核心课，其任务是使学生掌握计算机操作系统的原理知识及其应用，学习和掌握操作系统中的经典算法，为今后其他专业课的学习做好准备。

六、实践教学要求：

上机实验是学习计算机必不可少的实践环节，主要目的是锻炼和培养学生对原理和经典算法的验证。通过学习，学生应能够掌握计算机操作系统中进程管理、处理机调度、存储管理、设备管理和文件系统。实验课时课为10课时。

七、课程教学内容：（以*方式注明重点、难点） 第一章 操作系统概述（3学时）

教学基本要求：

1.了解操作系统的形成过程，建立操作系统的整体概念， 2.熟悉操作系统的基本类型和服务方式。 3.掌握操作系统的定义、特征和功能。 第一节 操作系统的定义

一、操作系统的虚拟机观点

二、操作系统的资源管理观点

三、操作系统的用户服务观点

四、操作系统的进程管理观点 第二节 操作系统的形成过程

一、人工操作阶段

二、单道批处理阶段

三、多道程序系统阶段

四、进一步发展阶段

第三节 操作系统的基本类型

一、多道批处理系统

二、分时系统

三、实时系统

四、通用操作系统

第四节 操作系统的特征

一、并发

二、共享

三、虚拟

四、异步行

第五节 操作系统的服务

一、操作系统的公共服务

二、操作系统的服务方式 第六节 操作系统的功能

一、用户接口

二、处理机管理

三、存储管理

四、设备管理

五、文件管理

第七节 操作系统的结构

一、整体式系统

二、层次式系统

三、客户/服务器系统

第二章 操作系统用户接口*（3学时）

教学基本要求：

1.了解用户接口的类型及各种接口的实现方法，尤其是图形接口的有关知识 2.熟悉命令接口在不同工作方式下的主要功能，作业和作业管理的基本概念 3.掌握系统调用的定义及其执行过程。

第一节 用户接口概述

一、程序的执行和作业的概念

二、作业管理概述 第二节 命令接口

一、脱机命令接口

二、联机命令接口 第三节 程序接口

一、系统调用概述

二、系统调用类型

三、系统调用过程 第四节 图形接口

第三章 进程管理*（12学时）

教学基本要求：

1.了解进程的引入原因和控制方法，进程互斥与同步的概念，进程间通信的概念，线程的概念及其与进程的关系。

2.进程互斥与同步中的信号量机制及pv操作的定义和物理意义，进程通信的类型和方法，消息缓冲通信的实现过程。

3.掌握进程的定义和特征，进程互斥与同步的机构和方法，能用信号量机制解决进程互斥同步问题。

第一节 进程的基本概念

一、进程的引入

二、进程的定义和特征 第二节 进程的描述

一、进程控制块

二、进程控制块的组织方式 第三节 进程状态及其转换

一、进程的基本状态

二、进程基本状态的转换 第四节 进程控制

一、进程控制机构

二、进程控制原语 第五节 进程同步与互斥

一、互斥的概念

二、进程同步的概念

三、互斥与同步机制

四、用PV原语实现互斥与同步的方法

五、用PV原语解决经典的互斥与同步的方法 第六节 进程间通信

一、进程间通信的类型

二、消息传递

三、消息传递的实例——消息缓冲通信 第七节 线程的概念

一、线程的引入和定义

二、线程的属性和状态

三、进程与线程的比较

第四章 处理机调度*（12学时）

教学基本要求：

1.了解各级调度的功能，各种系统的调度模型。

2.掌握各调度的算法，及平均周转时间和平均带权周转时间的计算。

3.掌握先来先服务、短作业优先、时间片轮转、优先级和多级反馈队列调度算法 第一节 调度的存次与分类

一、调度的层次

二、调度的分类

第二节 调度算法的设计目标和性能

一、设计目标

二、性能指标 第三节 调度算法

一、先来先服务调度算法

二、短作业优先调度算法

三、高相应比优先调度算法

四、时间片轮转调度算法

五、优先级调度算法

六、多级反馈队列调度算法 第四节 实时系统调度

一、实现实时调度的基本条件

二、实时调度的分类

三、常用的几种实时调度算法

第五章 死锁及其对策（3学时）

教学基本要求：

1.了解死锁问题在操作系统中的危害及死锁产生的原因。

2.熟悉死锁及死锁定理的概念，死锁问题的解决途径及死锁预防、避免、检测和恢复的方法。

3.掌握死锁产生的必要条件、资源分配图的化简和银行家算法的使用。第一节 死锁的概念

一、资源

二、死锁定义

第二节 死锁的产生及对策

一、死锁产生的原因

二、死锁产生的必要条件

三、死锁的描述

四、处理死锁的方法 第三节 死锁的预防

一、破坏互斥条件

二、破坏占用并等待条件

三、破坏不剥夺条件

四、破坏环路等待条件 第四节 死锁的避免

一、系统状态的安全性

二、银行家算法

三、银行家算法举例 第五节 死锁的检测和解除

一、利用资源分配图检测死锁

二、利用死锁检测算法检测死锁

三、死锁的恢复

第六章 存储管理*（6学时）

教学基本要求：

1.了解各种不同的存储管理方式以及它们的优缺点和适用场合。

2.熟悉各种存储管理方式所需的软、硬件支持以及各种算法的基本思想和实现方法。3.掌握存储管理的目的和功能、存储器的分配方式等基本概念，虚拟存储器的概念，各种虚拟管理方法的基本思想、实现原理和地址变换过程。

第一节 存储管理的基本概念

一、存储器的层次

二、地址重定位

三、存储管理的目的和功能

四、存储分配方式 第二节 存储管理技术

一、单一连续区管理

二、固定式和可变式分区存储管理

三、可重定位分区存储管理

四、分区的存储保护

第三节 虚拟存储系统的基本概念

一、虚拟存储器

二、实现虚拟存储器的基本原理

三、高相应比优先调度算法 第四节 分页存储管理

一、的实现原理

二、简单分页存储管理

三、请求式分页存储管理

四、请求式调页存储器管理的页眉置换算法

五、页面抖动和工作集模型

六、页面保护

七、页式存储器管理的优缺点 第五节 请求分段存储管理

一、段式存储器管理的基本思想

二、段式存储器管理的实现原理

三、段的共享与保护

四、分段与分页的区别与联系

五、段式存储器管理的优缺点 第六节 段页式存储管理

一、段页式存储管理的基本思想

二、段页式存储管理的地址变换过程

三、段页式存储管理的优缺点

第七章 设备管理（3学时）

教学基本要求：

1.了解操作系统的形成过程，建立操作系统的整体概念， 2.熟悉操作系统的基本类型和服务方式。 3.掌握操作系统的定义、特征和功能。

7．1 概述

7．2 设备管理的实现技术 7．3 设备管理软件的层次 7．4 虚拟设备

7．5 磁盘驱动调度

第八章 文件系统*（6学时）

教学基本要求：

1.了解操作系统的形成过程，建立操作系统的整体概念， 2.熟悉操作系统的基本类型和服务方式。 3.掌握操作系统的定义、特征和功能。

8．1 文件系统概述

8．2 文件的逻辑结构及其存取方法 8．3 文件的物理结构及其存取方法 8．4 文件存储空间管理 8．5 文件目录管理

8．6 文件系统的安全性

8．7 文件的操作与使用

第九章 Windows NT（3学时）

教学基本要求：

1.了解操作系统的形成过程，建立操作系统的整体概念， 2.熟悉操作系统的基本类型和服务方式。 3.掌握操作系统的定义、特征和功能。

9．1 系统结构

9．2 Windows NT内核 9．3 虚拟内存管理 9．4 对象管理程序 9．5 I/O系统 9．6 文件系统

四、教材

《操作系统》，刘滕红主编，科学出版社，2004

五、主要参考资料

1.《操作系统》.孟庆昌.电子工业出版社.2004年5月第一版 2.《操作系统》.凤羽翚等.电子工业出版社.2004年3月第一版 3.《计算机操作系统》.张尧学，史美林.清华大学出版社.2000年8月第二版

4.《操作系统原理与实例分析》.蒲晓蓉等.机械工业出版社.2004年6月

六、成绩评定

期末考试占50％，作业占30％，考勤及课堂成绩占10％，上机实习占10％

第19篇：《操作系统》教学大纲

操作系统

一、说明

（一）课程性质

本课程是计算机科学与技术专业的核心课程之一，属于必修课程。

“操作系统”是计算机系统不可缺少的组成部分，负责对系统中各种资源进行有效的管理和对各种活动进行正确的组织，使整个计算机系统协调一致且高效地工作，指挥计算机系统正常运行。操作系统基于硬件，并对硬件实施管理，并构成对所有软件运行的支持平台，给用户使用计算机而提供方便灵活友好的接口。

本课程的先修课为计算机组成原理、微机原理、数据结构、高级语言程序设计；后续课程为数据库系统原理、计算机网络、分布式系统等。

（二）教学目的

通过本课程的学习，使学生在深刻理解计算机系统整体概念的基础之上，掌握操作系统的基本内容及实现方法，掌握操作系统对计算机系统中各种资源的管理和控制功能，从而使学生具备一定的系统软件开发技能，为以后从事的研究、开发工作（如设计、分析或改进各种系统软件和应用软件）提供必要的软件基础和基本技能。

（三）教学内容

本课程内容包括：绪论，是对操作系统的一般性描述，包括什么是操作系统，操作系统在整个计算机系统的地位及其发展历史，它的功能、分类等；作业管理和Linux用户接口，介绍作业和操作系统用户接口，包括作业的基本概念和作业的建立过程、Linux介绍和它所提供的用户接口等；进程管理，主要介绍进程和线程的概念、进程控制、进程同步/互斥、死锁、进程间通信、线程等；处理机调度，主要介绍作业调度、进程调度、各种调度算法及其评价等；存储管理，介绍常见存储管理的方法，虚拟存储管理的实现等；Linux进程和存储管理；文件系统，包括文件系统的概念、文件结构和文件存取、文件目录管理、Linux文件管理等；设备管理；面向对象的操作系统和分布式操作系统。

（四）教学时数

课内学时：72

（五）教学方式

本课程的教学环节包括：课堂讲授、习题课、课堂讨论、批改作业、课外辅导、实验相结合，并逐步采用CAI、网络教学等教学手段。通过本课程各个教学环节的教学，重点培养学生的自学能力、分析问题解决问题的能力。

教学方法：采用启发式教学，鼓励学生自己针对某种操作系统进行分析和研究，培养学生的自学能力，以“少而精”为原则，精选教学内容，精讲多练，调动学生学习的主观能动性。

教学手段：开展电子教案、CAI课件的研制、引进和应用，研制多媒体教学系统。

考试环节：考试形式采用笔试，考试题型分为：填空题、选择题、判断题、简答题、分析设计题。

二、本文

第1章 绪论

教学要点：

操作系统的概念及其发展历史、分类，操作系统功能，研究操作系统的观点。本章是对操作系统的一般性描述。 教学时数：4学时 教学内容：

1 1.1 操作系统概念 （0.5学时）

掌握操作系统的概念及其在计算机系统中的作用。 1.2 操作系统的发展历史

（1学时） 了解操作系统的发展历史。

1.3 操作系统的基本类型

（1学时）

理解批处理系统、分时操作系统、实时操作系统、个人计算机操作系统、网络和分布式操作系统的特点。

1.4 操作系统的功能

（1学时）

掌握操作系统的处理机管理、存储管理、设备管理、文件管理和用户接口五大功能。 1.5 研究操作系统的几种观点

（0.5学时）

了解操作系统是计算机资源的管理者观点，用户界面观点，进程管理观点。 考核要求：

1． 识记：什么是操作系统，操作系统的分类。

2． 领会：操作系统的功能，操作系统的发展历史及研究观点。

第2章

作业管理和Linux用户接口

教学要点：

作业的概念和建立过程，操作系统为用户提供的接口，Linux用户接口，Linux shell编程。 教学时数：8学时 教学内容：

2.1 作业的基本概念 （1学时） 掌握作业的定义，作业的组织。 2.2 作业的建立过程

（1学时）

掌握作业的输入方式、JCB的建立；掌握SPOOLING系统。 2.3 用户接口

（1学时）

掌握作业控制、系统调用；了解用户接口的演变。 2.4 分时作业管理

（0.5学时） 了解分时作业管理。

2.5 Linux简介

（1学时）

了解Linux的发展历史和发展前景，Linux系统的特点，Linux系统结构。 2.6 Linux的Shell （1.5学时）

理解Shell提供的命令种类，程序语言Shell，make命令。 2.7 Linux的系统调用

（1学时）

理解有关设备管理的系统调用，有关文件系统的系统调用，有关进程控制的系统调用，有关进程通信的系统调用，有关存储管理的系统调用。 2.8 Linux桌面环境KDE介绍

（1学时） 了解Linux桌面环境KDE介绍。 考核要求：

1． 识记并领会：作业的概念，JCB的建立，SPOOLING系统，操作系统用户接口。 2． 分析：Linux的Shell，Linux的系统调用。

第3章

进程管理

教学要点：

进程的概念和描述，进程的同步和互斥，进程通信，死锁。 教学时数：10学时 教学内容：

2 3.1 进程和线程的概念 （1学时）

掌握程序的并发执行、进程的定义、作业和进程的关系；了解线程的概念。 3.2 进程的描述

（1学时）

掌握进程控制块PCB，进程上下文。 3.3 进程状态及其转换

（1学时）

掌握进程的三种基本状态：执行状态、等待状态、就绪状态，三种状态间的转换。 3.4 进程控制

（1学时）

理解进程的创建与撤消，进程的阻塞与唤醒。 3.5 进程互斥

（2学时）

掌握资源共享所引起的制约，互斥的加锁实现，信号量和P、V原语，用P、V原语实现进程互斥。 3.6 进程同步

（1学时）

掌握同步的概念，私用信号量，用P、V原语实现同步；理解生产者——消费者问题。 3.7 进程通信

（1.5学时）

理解进程的通信方式，消息缓冲机制，邮箱通信。 3.8 死锁问题

（1.5学时）

掌握死锁的概念，死锁的排除方法，银行家算法。 考核要求：

1． 识记：进程的概念和描述，进程的互斥和同步，死锁的产生条件，线程的概念。 2． 领会：进程控制，进程通信， 死锁的排除方法和各种算法。

第4章

处理机调度

教学要点：

作业调度，进程调度，各种调度算法及其评价，多处理机调度机制。 教学时数：6学时 教学内容：

4.1 分级调度 （1学时）

作业的状态和转换，调度的层次。 4.2 作业调度

（1学时）

掌握作业调度功能，作业调度目标与性能衡量。 4.3 进程调度

（1学时）

掌握进程调度的功能，进程调度的时机，进程上下文切换；理解进程调度性能评价。 4.4 调度算法 （1学时）

掌握先来先服务调度算法，轮转法，多级反馈轮转法，优先级法，静态优先级，动态优先级。 4.5 算法评价

（1学时）

理解FCFS方式的调度性能分析，轮转法调度性能评价，线性优先级法的调度性能。 4.6 多处理机调度

（1学时）

了解多处理机系统的概念，多处理机操作系统的分类，多处理机系统调度策略。 考核要求：

1． 识记：作业调度的功能和目标。

2． 领会：进程调度，调度算法的性能评价。 3． 分析及应用进程调度算法。

第5章

存储管理

教学要点：

虚拟存储器的概念，分区存储管理，页式存储管理，段式与段页式存储管理。

3 教学时数：12学时 教学内容：

5.1 存储管理的功能 （1.5学时）

掌握虚拟存储器，内外存数据传输的控制，内存的分配与回收；理解地址变换，内存信息的共享与保护。

5.2 单道环境下的存储管理

（0.5学时）

理解单一连续区分配；了解单一连续区管理方式的优缺点。 5.3 分区存储管理

（2学时）

理解分区管理基本原理，分区的分配与回收。 5.4 覆盖与交换技术

（1学时） 理解覆盖技术，交换技术。 5.5 页式管理 （3学时）

掌握页式管理的基本原理，静态页面管理，动态页式管理，存储保护；理解请求页式管理中的置换算法；了解页式管理的优缺点。 5.6 段式与段页式管理 （3学时）

掌握段式管理的基本思想，段页式管理的基本思想；理解段式管理的实现原理，段页式管理的实现原理；了解段式管理的优缺点。

5.7 局部性原理和抖动问题 （1学时） 掌握局部性原理；理解工作集概念。 考核要求：

1.识记：存储管理的功能，虚拟存储器的概念，页式管理的基本原理，动态页式管理，页式管理存储保护，段式管理和段页式管理的基本思想，局部性原理。

2.领会：地址变换，分区管理的基本原理，分区的分配与回收，静态页式管理，段页式管理的实现原理，工作集概念。

3.应用：请求页式管理中的置换算法。

第6章

Linux进程和存储管理

教学要点：

Linux进程结构、进程控制，Linux进程调度与交换，进程间通信，Linux存储管理方式。 教学时数：8学时 教学内容：

6.1 Linux进程和存储管理介绍 （1学时） 6.2 Linux进程结构 （1学时）

掌握Linux进程的概念，进程的虚地址结构，进程上下文，进程的状态和状态转换。 6.3 Linux进程控制

（1学时）

了解Linux启动和进程树的形成，理解Linux进程控制。 6.4 Linux进程调度与交换

（1学时） 掌握Linux进程调度，交换。 6.5 进程间通信 （2学时）

掌握Linux的低级通信，进程间通信IPC。 6.6 Linux存储管理

（2学时）

掌握Linux虚存空间划分和管理思想；理解Linux的内存分配与释放，地址变换过程，Linux的请求调页技术。 考核要求：

1.领会：Linux进程控制，内存的分配与释放，Linux进程结构。

4 2.分析：Linux进程调度，进程间通信，Linux的页式存储管理。

第7章

文件系统

教学要点：

文件系统的作用，文件的结构与存取，文件的目录管理。 教学时数：12学时 教学内容：

7.1 文件系统的概念 （1学时）

掌握文件系统的引入，文件与文件系统的概念，文件的分类。 7.2 文件的逻辑结构与存取方法

（1学时）

理解文件的逻辑结构，存取方法，顺序存取法，随机存取法，按键存取法。 7.3 文件的物理结构与存储设备

（1学时）

理解文件的物理结构：连续文件，串联文件，索引文件；理解文件存储设备：顺序存取设备，直接存取设备。

7.4 文件存储空间管理

（1学时）

掌握三种不同的空闲块管理方法：空闲文件目录，空闲块链，位示图。 7.5 文件目录管理

（2学时）

掌握文件的组成，文件目录，可共享的文件目录，目录管理。 7.6 文件存取控制

（1学时）

理解文件存取控制的目标，存取控制方法。 7.7 文件的使用

(0.5学时) 了解文件的使用。

7.8 文件系统的层次模型 （0.5学时） 了解文件系统的层次模型。

7.9 Linux文件系统的特点与数据结构、文件类别

（1.5学时）

掌握Linux文件系统的特点，Linux文件分类，文件系统的数据结构及其关系。 7.10 Linux文件系统的资源管理和地址映射

（1.5学时）

理解磁盘i-node的分配与释放，内存i-node的分配与释放，系统打开文件表的分配与释放，地址映射。

7.11 Linux系统中的目录与搜索方法，以及文件系统的系统调用 （1学时） 理解散列搜索法，算法描述；理解Linux系统调用。 考核要求：

1.识记：文件系统的功能，文件系统的层次模型。

2.领会：文件的逻辑与物理结构，文件存取方法及其存取控制，文件目录管理。

3.分析：Linux文件系统的数据结构及其相互关系，Linux文件系统的资源管理和地址映射、系统中的目录与搜索方法，Linux文件系统的系统调用。4.应用层次：文件的使用。

第8章

设备管理

教学要点：

主要介绍设备管理的基本概念，包括中断、缓冲、设备分配和控制。 教学时数：8学时 教学内容：

8.1 引言 （0.5学时）

掌握设备的类别，设备管理的功能和任务。 8.2 数据传送控制方式

（1学时）

5 掌握程序直接控制方式，中断方式，DMA方式，通道控制方式。 8.3 中断技术

（1学时）

掌握中断的基本概念，中断的分类与优先级，软中断；理解中断处理过程。 8.4 缓冲技术

（1学时）

掌握缓冲的目标，缓冲的种类，缓冲池的管理。 8.5 设备分配

（1学时）

掌握设备分配用的数据结构，设备分配的原则，设备分配办法。 8.6 I/O进程控制与设备驱动程序

（0.5学时）

了解I/O控制的功能，I/O控制的实现，设备驱动程序。 8.7 Linux的中断和异常处理

（1学时）

理解中断和异常总控过程，中断分类和处理，异常处理。 8.8 Linux缓冲区管理 （1学时）

掌握Linux缓冲池结构，缓冲区的分配与释放，缓冲区数据读写。 8.9 块设备驱动与字符设备驱动

（

1学时）

理解块设备驱动：设备配置，设备驱动程序的接口；理解字符设备驱动：主要数据结构，包括缓冲区结构、缓冲队列的控制结构、字符设备开关表。 考核要求：

1.识记：数据传送控制方式，缓冲技术，设备分配。

2.领会：中断技术，Linux缓冲区管理，Linux的中断和异常处理。

第9章

面向对象、网络、分布式操作系统

教学要点：

介绍面向对象的操作系统和网络操作系统，以及分布式操作系统的概念。 教学时数：4学时 教学内容：

9.1 面向对象和操作系统 （1学时）

了解面向对象的基本概念，面向对象操作系统的概念及其开发方法，面向对象操作系统的分类。 9.2 网络操作系统

（1学时）

了解网络操作系统的构成，文件与打印服务，电子邮件服务。 9.3 分布式操作系统

（2学时）

了解进程迁移，分布进程同步，分布式进程通信，分布式系统中的死锁。 考核要求：

识记面向对象操作系统的概念，分布式操作系统的基本概念；领会网络操作系统的构成与服务。

三、参考书目

1.2.3.4.张尧学，史美林，《计算机操作系统》，清华大学出版社。

Tanenbaum AS, Operating System Design and Implementation, Prentice-Hall, 1987。 郭玉东，《Linux操作系统结构分析》，西安电子科技大学出版社，2002。 汤子赢，《计算机操作系统》，西安电子科技出版社，2000。

第20篇：《操作系统》教学大纲

《操作系统》教学大纲

学时：85学时

学分：3+2学分 理论学时：51学时

实验学时：34学时 适用专业：计算机科学与技术

大纲执笔人：章昭辉

大纲审核人：

一、教学大纲说明

1、课程的性质、地位和任务

操作系统（Operating System）是当代计算机软件系统的核心，是计算机系统的基础和支撑，它管理和控制着计算机系统中的所有软、硬件资源，可以说操作系统是计算机系统的灵魂。操作系统课程是计算机专业学生必须学习和掌握的基础课程, 是计算机应用人员深入了解和使用计算机的必备知识, 是进行系统软件开发的理论基础，也是计算机科学与技术专业的一门理论性和实践性并重的核心主干课程。

2、课程教学的基本要求

本课程的目标是使学生掌握现代计算机操作系统的基本原理、基本设计方法及实现技术，具有分析现行操作系统和设计、开发实际操作系统的基本能力。本课程主要讲述操作系统的基本概念、基本原理及其实现技术，包括处理器管理、存储器管理、设备管理和文件管理等内容。

3、课程教学改革

通过剖析某个实用的操作系统（如UNIX或 Linux）的内核，使学生了解这种操作系统是如何对计算机资源进行管理的，以及操作系统的发展趋势。

二、教学内容

（一）本课程理论教学内容

第一章 操作系统引论

主要内容：操作系统的目标、作用和模型、操作系统的发展过程、操作系统的特征和服务、操作系统的功能、操作系统的进一步发展。 重点：操作系统的概念、特征和服务、操作系统的功能。

第二章 进程管理

主要内容：前驱图和程序执行、进程的描述、进程控制、线程的基本概念。进程同步的基本概念、信号量机制、经典进程同步问题、进程通信。 重点：进程的描述、进程控制。临界资源、临界区、软件解决互斥、硬件解决互斥、信号量机制、进程通信。 难点：进程控制。进程同步问题。

第三章 处理机调度与死锁

主要内容：调度类型、调度算法、死锁的概念、原因、产生的必要条件、处理死锁的基本方法、安全状态、银行家算法、死锁的检测与解除。

重点：调度类型、调度算法、死锁的概念、产生的必要条件、处理死锁的基本方法、安全状态、银行家算法、死锁的预防和避免。 难点：银行家算法、死锁的预防和避免。

第四章 存储器管理

主要内容：程序的装入和链接、连续分配存储管理方式、分页存储管理方式、分段存储管理。虚拟存储器的基本概念、请求分页存储管理方式、页面置换、请求分页系统的性能分析、请求分段存储管理方式。

重点：动态分区分配、分页存储管理方式、分段存储管理。虚拟存储器的基本概念、请求分页存储管理方式、页面置换、请求分段存储管理方式。

难点：分页存储管理方式。页面置换算法。

第五章 设备管理

主要内容：I/O系统的组成、控制方式、缓冲管理、设备分配、SPOOLING技术、设备处理。磁盘I/O、外存分配方法、空闲存储空间的管理、磁盘容错技术、文件系统性能的改善、数据一致性控制。 重点：I/O控制方式、缓冲管理、SPOOLING 原理、设备分配。磁盘调度算法。 难点：设备分配。

第六章 文件系统

主要内容：文件和文件系统、文件逻辑结构、目录管理、文件共享、文件保护。 重点：文件逻辑结构、目录管理、文件共享、文件保护。外存分配方法、空闲存储空间的管理。

难点：目录管理、文件保护。外存分配方法、空闲存储空间的管理。

第七章 操作系统接口

主要内容：联机用户接口、shell命令、系统调用、图形接口 重点：用户接口、程序接口 难点：用户接口、程序接口

（二）本课程实验内容

实验一：写一个程序描述进程状态迁移过程。 目标：理解进程概念、状态转换及其控制。

要求：提供导致进程状态变化的调用接口，包括创建、删除、调度、阻塞、时间到、挂起、激活等。实现进程列表显示的接口。注：这里设计的进程是一个假设的对象实体，是由程序自己创建和删除，不是系统维护的进程。

实验二：编程实现生产者消费者或读写者的同步问题 目标：掌握信号量实现进程同步及其应用

要求：利用线程模拟进程；可视化显示模拟同步

实验三：设计一个程序，实现四种调度算法：1。先来先服务算法2。短作业优先算法3。优先权算法4。基于时间片的多级反馈队列算法 目标：掌握四种算法的原理

要求：通过若干个实例实现各种算法的优劣性对比；结果要求可视化展示

实验四：编程实现银行家算法

目标：掌握银行家算法实现死锁预防的原理

要求：输入实例，能够使用银行家算法判断资源分配后是否存在安全序列。

实验五：模拟基本分页式的地址变换机构及其变换方法 目标：掌握页表概念、基本分页式的地址变换

要求：要有页表，通过页表等实现地址变换；图示化变换过程

实验六：实现LRU算法和FIFO算法

目标：理解页面置换算法

要求：给出任意的输入流，计算缺页率。输入流长度、cache尺寸可定制。图示化置换过程。

测试：Cache＝5， 从0－9可数字的任意排序，长度为30。例如：12568,36536,56892,70495,36745,87345

实验七：实现缓冲池的管理（重点是getbuff和putbuff的操作） 目标：掌握缓冲池的管理方法，进一步理解进程同步信号量的使用

要求：定义输入、输出和空缓冲3个队列，以及4种缓冲区；图示化表示缓冲区的管理及其相关的操作。

实验八：实现SSTF算法和SCAN算法

目标：掌握SSTF算法和SCAN算法的原理

要求：给出任意的输入流、计算平均寻道长度。输入流长度、磁头移动方向可定制。 测试：设有100个磁道，访问序列如下：

23，5，98， 14，66，25，78，34，66，74，56，87，12，39，71，49，58。当前磁头在50道，上次访问的磁道是18道。

实验九：模拟FAT和FDT，实现文件的物理块分配与回收，以及通过文件目录实现文件的访问，如文件copy（可自己定义一个文件访问命令）。要求能表示FAT的分配信息和FDT的管理信息。

目标：掌握FAT的分配原理；掌握FDT实现文件管理的原理。 要求：可视化实现文件管理

（三）课程考核方式、方法

理论教学内容的考核：闭卷笔试。 实验教学内容的考核：实验报告。

三、参考书目

汤小丹，梁红兵，哲凤屏，汤子瀛编著，《计算机操作系统》（第三版），西安电子科技大学出版社

ANDREW S.TANENBAUM, ALBERT S.WOODHULL 著，《操作系统：设计与实现》电子工业出版社。2000年第二版。

《操作系统面试.doc》

将本文的Word文档下载到电脑，方便编辑。

推荐度：

点击下载文档