华南理工大学

操作系统课程实验报告

第二篇：操作系统实验报告3

华北电力大学

实验报告

|

|

                实验名称     进程调度/银行家算法/存储器管理      

课程名称               操作系统                  

|

|

专业班级：                      学生姓名：

学    号：                      成    绩：

指导教师：                     实验日期：2010.5.

实验一   进程调度实验

一、实验目的与要求  

通过通过实验使学生更好地掌握操作系统的基本概念、基本原理、及基本功能。特别是进程的概念、进程控制块的概念以及进程的三种基本状态等概念。培养学生程序设计的方法和技巧，提高学生编制清晰、合理、可读性好的系统程序的能力，加深对操作系统课程的理解，拓宽学生的知识领域，锻炼学生的实践技能。

本实验模拟单处理器系统的进程调度，加深对进程的概念及进程调度算法的理解。用某种语言编写和调试一个进程调度的算法程序，有一些简单的界面，能够运行，仿真操作系统中进程调度的原理和过程。进程调度要求使用高响应比优先的动态优先级调度算法。

二、实验所需仪器、设备

PC机

三、实验原理

动态优先权是指，在创建进程时所赋予的优先权，是可以随进程的推进或随其等待时间的增加而改变的，以便获得更好的调度性能。例如，我们可以规定，在就绪队列中的进程，随其等待时间的增长，其优先权以速率a提高。若所有的进程都具有相同的优先权初值，则显然是最先进入就绪队列的进程，将因其动态优先权变得最高而优先获得处理机，此即FCFS算法。若所有的就绪进程具有各不相同的优先权初值，那么，对于优先权初值低的进程，在等待了足够的时间后，其优先权便可能升为最高，从而可以获得处理机。当采用抢占式优先权调度算法时，如果再规定当前进程的优先权以速率b下降，则可防止一个长作业长期地垄断处理机。

高响应比优先调度算法是一种动态优先权调度算法，其优先权的变化规律可描述为：

 

由于等待时间与服务时间之和，就是系统对该作业的响应时间，故该优先权又相当于响应比RP。据此，又可表示为

 

高响应比优先(HRRN)调度算法计算举例：

 T=0：只有作业A已到达，调度作业A运行。

 T=4：作业A完成，作业B、C、D、E已到达，计算作业B、C、D、E响应比RP分别为： 1+3/3、1+2/5、1+1/2、1+0/4，作业B响应比最大调度运行。

 T=7：作业B完成，作业C、D、E已到达，计算作业C、D、E响应比RP分别为： 1+5/5、1+4/2、1+3/4，作业D响应比最大调度运行。

 T=9：作业D完成，作业C、E已到达，计算作业C、E响应比RP分别为： 1+7/5、1+5/4，作业C响应比最大调度运行。

 T=14：作业C完成，只有作业E未完成，调度作业E运行。

四、实验方法与步骤

本实验采用的是C#编程方式，先通过设定良好的操作界面，进入程序运行之后，再统一输入实验数据，通过对确定键的设定，以及list列表将结果数据打印出来，来达到实验目的的实现：

1.程序源的是、主要部分在于最后确定键的设定，首先利用一系列标记值，反映出列表完整显示后对应的列名，尤其是各调用过程不同的优先权值；

2.根据实验原理，计算每次迭代时的等待时间，以高响应比优先(HRRN)调度算法为例，根据优先权公式计算数值，并完整的在列表中显示出来，同时根据优先权初值低的进程，在等待了足够的时间后，其优先权便可能升为最高，从而可以获得处理机，并对其分配计算。之后，进行下一作业任务的调度以及相应处理，最后完成所有输出结果。

3.结合输出结果和理论知识原理，再次分析进程管理的高响应比优先调度算法，充分理解其理论意义与应用深度。

五、实验结果与数据处理

下图中对应输入数据为各作业的到达时间以及服务时间，之后为调度过程相应优先权值：

六、讨论与结论

最简单最直观的进程调度策略是基于优先级的调度，多数实时系统采用基于优先级的调度，每个进程根据它重要程度的不同被赋予不同的优先级，调度器在每次调度时，总选择优先级最高的进程开始执行。基于优先级的进程调度虽然很好的满足了高优先级进程的要求，但是对优先级低而占用系统资源少的进程很不公平。

   

实验二   银行家算法实验

一、实验目的与要求

熟悉银行家算法，理解系统产生死锁的原因及避免死锁的方法,加深记意。

用高级语言编写和调试一个描述银行家算法的程序。设计五个进程{P0，P1，P2，P3，P4}共享三类资源{A，B，C}的系统，{A，B，C}的资源数量分别为10，5，7。进程可动态地申请资源和释放资源，系统按各进程的申请动态地分配资源。要求程序具有显示和打印各进程的某一时刻的资源分配表和安全序列；显示和打印各进程依次要求申请的资源号以及为某进程分配资源后的有关资源数据。

二、实验所需仪器、设备

PC机

三、实验原理

利用银行家算法避免死锁

1、银行家算法中的数据结构

（1）可利用资源向量Available

（2）最大需求规阵Max

（3）分配矩阵Allocation

（4）需求矩阵Need

2、银行家算法

（1）如果Requesti＜或=Need,则转向步骤2；否则，认为出错，因为它所需要的资源数已超过它所宣布的最大值。

（2）如果Request＜或=Available,则转向步骤（3）；否则，表示系统中尚无足够的资源，P1必须等待。

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

Available:=Available-Requesti;

Allocation:=Allocationi+Request;

Needi:=Needi-request;

(4)系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。

3、安全性算法

系统所执行的安全性算法可描述如下：

（1）设置两个向量

①工作向量Work。它表示系统可提供进程继续运行所需要的各类资源数目，它含有m个元素，执行安全算法开始时，Work:=Allocation;

②Finish。它表示系统是否有足够的资源分配给进程，使之运行完成，开始时先做Finish[i]:=false;当有足够资源分配给进程时，令Finish[i]:=true。

（2）从进程集合中找到一个能满足下述条件的进程：

①Finish[i]:=false

②Need</=Work

如找到，执行步骤（3）；否则，执行步骤（4）。

（3）当进程P获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：

Work：=Work+Allocation;

Finish[i]：=true;

Go to step 2;

（4）如果所有进程的Finish[i]=true,则表示系统处于安全状态；否则，系统处于不安全状态。

4、银行家算法之例

假设有五个进程{P0,P1,P2,P3,P4}和三种类型的资源{A，B，C}，每一种资源的数量分别为10、5、7，在T0时刻的资源分配情况如图1所示。

                                图1

（1）T0时刻的安全性

利用安全性算法对T0时刻的资源分配情况进行分析，可得下表所示的T0时刻的安全性分析，从中得知，T0时刻存在着一个安全序列{P1，P3，P4，P2，P0}，故系统是安全的，如图2所示。

                                图2          

（2） P1请求资源

P1发出请求向量Request(1,0,2),系统按银行家算法进行检查：

(1)Request1(1,0,2)≤Need(1,2,2)

(2)Request1(1,0,2)≤Available(3,3,2)

(3)系统先假定可为P1分配资源，并修改Aailable，Allocation1和Need1向量，由此形成的资源变化情况如图1中的圆括号所示。

（4）我们再利用安全性检查此时系统是否安全。

由所进行的安全性检查得知，可以找到一个安全序列{P1，P3，P4，P2，P0}。因此，系统是安全的，可以立即将P1所申请的资源分配给它。

（3）P4请求资源

P4发出请求向量Request(3,3,0),系统按银行家算法进行检查：

(1)Request4(3,3,0)≤Need4(4,3,1)。

(2)Request4(3,3,0)>Available(2,3,0)，让P4等待。

（4） P0请求资源

P0发出请求向量Request0(0,2,0),系统按银行家算法进行检查：

（1）Request0(o,2,0)<或=Need0(7,4,3));

（5）进行安全性检查

可用资源Available{2,1,0}已不能满足任何进程的需要，故系统进入不安全状态，此时系统不分配资源。

四、实验方法与步骤

本实验采用C++编程方式，通过对原理的充分理解之后，可知整个程序的设计大致可以分为以下三部分：

1.数据矩阵的初始化

结合所给实例，可看到在这里存在最大需求矩阵、分配矩阵、可用资源矩阵等多种矩阵形式，故在此将矩阵初始化，设成二维或部分一维矩阵。即按要求设定所有进程数与资源数，以便得知接下来各矩阵为几行几列矩阵；

2.安全性算法

先对进程标记其状态，再根据原理进行算法的具体编译，当满足所有条件，输出系统安全的标志，并进行下一步操作。

即先初始化资源分配至进程前的状态为false，再根据工作向量与需求矩阵地动态对比，逐个分析系统资源，满足条件的就合理释放出分配给它的资源，并将进程状态做相应修改true，直至所有进程都满足，则表示系统处于安全状态，否则，处于不安全状态；

具体流程图如下：

 

3.银行家算法

确定需要申请资源的进程号和资源数，由原理设置具体程序，在输入数据进行计算之前，要先验证，所需资源数是否条件满足，不会溢出，计算之后还要进行一次安全性检验。

即操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。若超过则拒绝分配资源，基没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配；

具体流程图如下：

 

五、实验结果与数据处理

请确定进程的数目：5

请确定资源的数目：3

请输入每个进程最大需求矩阵，按照5*3阶矩阵输入

7 5 3

3 2 2

9 0 2

2 2 2

4 3 3

请输入每个进程相应的分配矩阵，按照5*3阶矩阵输入

0 1 0

2 0 0

3 0 2

2 1 1

0 0 2

请输入可利用资源向量：

3 3 2

系统是安全的，且安全序列为：

13024

请输入想要申请资源的进程号：1

请输入进程1所申请各资源的数量：

102

系统是安全的，且安全序列为：

13024可分配资源！

六、讨论与结论

对于已编译并调试好的程序中，将输入数据后得到的结果，与教材所提供的结果进行对比，发现并不相同。于是在对已有程序进行详细检查之后确定没有错误的可能之后，又上网进行相关内容的查询，得知此答案并不唯一，也就是会出现多种满足条件的结果，只要判断情况合理，完全出现不同的安全序列。

    除本实验所提供的数据之外，在通过几个实际例子的不断演算，发现在现有剩余资源的前提下应尽可能早的首先给最大需求量大的进程分配资源，但不是完全正确的。在上面这个条件下，有时候，也不能完全正确的找到路径，因为中间存在着最大需求量值同样最大的情况，或者当前资源剩余量无法满足进程对资源的最大需求量。

用银行家算法实现资源分配。多个进程动态共享系统的资源可能会产生死锁现象。但只要资源分配策多个进程动态共享系统的资源可能会产生死锁现象。但只要资源分配策略能保证进程不出现循环等待，系统就不会发生死锁。本实验通过编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用适当的算法，有效的防止和避免死锁的发生

通过本次银行家算法实验，加深了我对银行家算法的了解，掌握了如何利用银行家算法避免死锁。实验中遇到点问题，通过查阅资料得以解决，通过这次的实践，使我的理论知识更加的牢固。

实验三   存储器管理实验

一、实验目的、要求 

    存储器管理的主要功能是，合理地分配内存空间，数据存储和查询。其中，请求页式存储管理是一种具有虚拟空间技术的存储器管理系统。

    本实验的目的是，设计请求页式存储管理中的页面置换算法，加深了解虚拟存储技术的特点，掌握各种页面置换的算法。

（１）通过随机数产生一个指令序列，共３２０条指令。指令的地址按下述原则生成：

①  ５０％的指令是顺序执行的。

②  ２５％的指令均匀分布在低地址部分。

③  ２５％的指令均匀分布在高地址部分。

具体实施的方法是：

①　在［０，３１９］的指令地址之间随机产生一个起点m；

②　顺序执行一条指令，即执行m＋１处的执行；

③　在地址［０，m＋１］中随机选取一条指令执行，该指令的地址为m１；

④　顺序执行一条指令，即执行m1＋１处的执行；

⑤　在地址［m1＋2,319］中随机选取一条指令执行；

⑥　重复上述步骤直到执行了３２０条指令为止。

（２）将指令序列改变为页地址流，并假设：

①  页面尺寸为１Ｋ。

②  用户的内存容量为４页到３２页。

③  用户的虚存容量为３２Ｋ。

在用户虚存中，按每Ｋ存放１０条指令来排列虚存地址，即３２０条指令在虚存放方式为：

第０条～第９条为０号页（对应的虚存地址为［０，９］）。

第１０条～第１９条为１号页（对应的虚存地址为［１０，１９］）。

…　…　…　…

第3１０条～第3１９条为3１号页（对应的虚存地址为［3１０，3１９］）。

按上述方式，用户指令可组成32页。

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

①  先进先出算法（FIFO）。

②  最近最少使用算法（LRU）。

③  最佳淘汰算法。

④  最少访问页面算法（LFR）。

其中，命中率为：

                  命中率=(1+缺页次数)/页地址流长度

    本实验中，页的地址流长度为320，页面失效次数为每次访问响应指令时，该指令对应的页面不在内存中的次数。

3．随机数的产生方法

    在VC中设计到随机数有两个函数srand() and rand()。srand() 的作用是是一个种子，提供每次获得随机数的基数而已，rand()根据种子而产生随机数。

注意

       1：srand() 里的值必须是动态变化的，否则得到的随机数就是一个固定数

       2：如果我们想得到一个 0-60的随机数那么可以写成

           int i;

           srand(GetTickCount());

           i=rand()%60;

二、实验所需仪器、设备

PC机

三、实验原理

1、分页请求系统

    为了能实现请求调页和置换功能，系统必须提供必要的硬件支持，其中，最重要的是：

（1）请求分页的页表机制。它是在分页的页表机制上增加若干个项而形成的，作为请求分页的数据结构；

（2）缺页中断机构。每当用户程序要访问的页面尚未调入内存时，便产生一缺页中断，以请求OS将所缺的页面调入内存；

（3）地址变换机构。它同样是在分页的地址变换机构的基础上发展形成的。

为了实现请求调页还须得到OS的支持，在实现请求调页功能时，石油OS将所需的页从外存调入内存；在实现置换功能时，也是由OS将内存的某些页调至外存。

2、页面置换算法

一、最佳（Optimal）置换算法

    采用最佳置换算法可保证获得最低的缺页率。但由于人们目前还无法预知一个进程在内存的若干个页面中，哪一个页面是未来最长时间内不在被访问的，因而该算法也是无法实现的，但是可利用该算法去评价其它算法。图6-3示出了利用最佳置换算法时的置换图。由图可看出，采用最佳置换算法，只发生了6次页面置换。

二、先进先出页面置换算法

    该算法总是淘汰最先进入内存的页面，即选择在内存中的驻留时间最久的页面予以淘汰。该算法实现简单，只需把一个进程已调入内存的页面，按先后次序链接成一个队列，并设置一个指针，称为替换指针，使它总是指向最老页面。但该算法与进程实际运行的规律不相适应，因为在进程中，有些页面经常被访问，含有全局变量、常用函数、例程等的页面，FIFO置换算法并不能保证这些页面不被淘汰。

三、最近最久未使用LRU置换算法

1、LRU（Least Recently Used）算法的描述

    FIFO置换算法之所以性能较差，是因为它所依据的条件是各个页面调入内存的时间，而页面调入的先后并不能反映页面的使用情况。而最近最久未使用（LRU）的页面置换算法，，则是根据页面调入内存后的使用情况。由于无法预测各页面将来的使用情况，只能利用“最近的过去”作为“最近的将来”的近似。因此，LRU置换算法是选择最近最久未使用的页面予以淘汰。

2、LRU算法的硬件支持

     把LRU算法作为页面置换算法是比较好的，它对于各种类型的程序都能适用，但实现起来有相当大的难度，因为它要求系统具有较多的支持硬件。所要解决的问题有：

    1.一个进程在内存中的各个页面各有多久时间未被进程访问；

    2.如何快速地知道哪一页最近最久未使用的页面。为此，须利用以下两类支持硬件：

（1）寄存器

用于记录某进程在内存中各页的使用情况。

（2）栈

    可利用一个特殊的栈来保存当前使用的各个页面的页面号。每当进程访问某页面时，便将该页面的页面号从栈中移出，将它压入栈顶。

四、Clock 置换算法

1、简单的Clock置换算法

    利用Clock算法时，只须为每页设置一位访问位，在将内存中的所有页面都通过链接指针链成一个循环队列。当某页被访问时，其访问位被置1。置换算法在选择一页淘汰时，只须检查其访问位。

2、改进型Clock置换算法

    在将一个页面换出时，如果该页已被修改过，便须将它重新写到磁盘上；但如果该页未被修改过，则不必将它拷回磁盘。同时满足两条件的页面作为手癣淘汰的页。由访问位A和修改位M可以组合成下面四种类型的页面：

1 类（A=0，M=0）。表示该页最近既未被访问、又未被修改，是最佳淘汰页。

2 类（A=0，M=1）。表示该页最近未被访问，但已被修改，并不是很好的淘汰页。

3 类（A=1，M=0）。最近已被访问，但未被修改，该页有可能再被访问。

4 类（A=1，M=1）。最近已被访问且被修改，该页有可能再被访问。

    在内存中的每个页必定是这四类页面之一，在进行页面置换时，可采用与简单Clock算法相类似的算法，其差别在于须同时检查访问位和修改位，以确定该页是四类页面中的那一种。此算法称

为改进型Clock算法。其执行过程可分成以下三步：

（1）从指针所指示的当前位置开始，扫描循环队列，寻找A=0且M=0的第一类页面，将所遇到的第一个页面作为所选中的淘汰页。在第一次扫描期间不改变访问位A。

（2）如果第一步失败，即查找一周后未遇到第一类页面，则开始第二轮扫描，寻找A=0且M=1的第二类页面，将所遇到的第一个这类页面作为淘汰页。在第二轮扫描期间，将所有经过的页面的访问位置0。

（3）如果第二步也失败，即未找到第二类页面，则将指针返回到开始的位置，并将所有的访问位复0。然后，重复第一步，如果仍失败，必要时在重复第二步，此时就一定能够找到被淘汰的页。

五、其它置换算法

1、最少使用（Least Frequently Used）置换算法

    在采用该算法时，应为在内存中的每个页面设置一移位寄存器，用来记录该页面被访问的频率，该置换算法选择在最近时期使用最少的页面作为淘汰页。

2、页面缓冲算法（Page Buffering Algorithm）

    虽然LRU和Clock置换算法都比FIFO算法好，但它们都需要一定的硬件支持，置换一个已修改的页的开销要大。而页面缓冲算法则既改善分页系统的性能，又可采用一种较简单的置换策略。

六、请求分页系统的性能分析

1、缺页率对有效访问的时间的影响

    缺页时须先调入该页的情况时，有效访问时间表示为：有效访问时间=（1-p） ma+p 缺页中断时间。

2、缺页中断时间的组成

（1）缺页中断时间服务时间；

（2）将缺页中断读入的时间；

（3）进程重新执行时间。

    由于CUP速度很快，所以其中地（1）和（3）两部分可以不超过1ms;而将一磁盘块读入内存的时间，则包括寻道时间、旋转时间和数据传送时间三部分，大体上是24ms。由此可得知缺页中断时间约为25ms。此处尚未考虑到进程可能因排队等待所花费的时间。将上述数据代入到工集，有效访问时间。

四、实验方法与步骤

此实验同样以C++进行编写：

（1）  首先应对以下要调用的函数进行声明，之后设置主函数，需模拟一个拥有若干个虚页的进程在给定的若干个实页中运行，产生指令队列，并在缺页中断发生时分别使用FIFO、LRU 、Optimal和LFU算法进行页面置换的情形；

（2）  之后针对以声明过的各置换算法进行编译，方便调用，要求程序运行时屏幕能显示出置换过程中的状态信息并输出访问结束时的页面命中率；

（3）  最后运行程序时能够完整的显示页面置换算法下的各个命中率；

五、实验结果与数据处理

运行程序后直接显示的结果为：

4 page frames:

FIFO:0.4375

LRU:0.5375

OPT:0.375

LFU:0.284375

 5 page frames:

FIFO:0.471875

LRU:0.55

OPT:0.4

LFU:0.29375

 6 page frames:

FIFO:0.496875

LRU:0.5625

OPT:0.415625

LFU:0.3125

 7 page frames:

FIFO:0.534375

LRU:0.578125

OPT:0.428125

LFU:0.33125

 8 page frames:

FIFO:0.553125

LRU:0.59375

OPT:0.4625

LFU:0.340625

 9 page frames:

FIFO:0.571875

LRU:0.615625

OPT:0.478125

LFU:0.365625

10 page frames:

FIFO:0.59375

LRU:0.625

OPT:0.509375

LFU:0.403125

11 page frames:

FIFO:0.603125

LRU:0.646875

OPT:0.53125

LFU:0.41875

12 page frames:

FIFO:0.609375

LRU:0.653125

OPT:0.55

LFU:0.4375

13 page frames:

FIFO:0.640625

LRU:0.671875

OPT:0.56875

LFU:0.478125

14 page frames:

FIFO:0.671875

LRU:0.69375

OPT:0.596875

LFU:0.49375

15 page frames:

FIFO:0.684375

LRU:0.696875

OPT:0.621875

LFU:0.503125

16 page frames:

FIFO:0.7125

LRU:0.71875

OPT:0.640625

LFU:0.525

17 page frames:

FIFO:0.728125

LRU:0.7375

OPT:0.659375

LFU:0.546875

18 page frames:

FIFO:0.73125

LRU:0.75625

OPT:0.671875

LFU:0.58125

19 page frames:

FIFO:0.746875

LRU:0.765625

OPT:0.696875

LFU:0.60625

20 page frames:

FIFO:0.75625

LRU:0.78125

OPT:0.715625

LFU:0.628125

21 page frames:

FIFO:0.759375

LRU:0.7875

OPT:0.740625

LFU:0.7

22 page frames:

FIFO:0.784375

LRU:0.8

OPT:0.7625

LFU:0.715625

23 page frames:

FIFO:0.784375

LRU:0.809375

OPT:0.79375

LFU:0.746875

24 page frames:

FIFO:0.825

LRU:0.815625

OPT:0.821875

LFU:0.778125

25 page frames:

FIFO:0.846875

LRU:0.821875

OPT:0.840625

LFU:0.8125

26 page frames:

FIFO:0.846875

LRU:0.840625

OPT:0.8625

LFU:0.8375

27 page frames:

FIFO:0.859375

LRU:0.85

OPT:0.871875

LFU:0.85625

28 page frames:

FIFO:0.865625

LRU:0.86875

OPT:0.8875

LFU:0.865625

29 page frames:

FIFO:0.86875

LRU:0.878125

OPT:0.9

LFU:0.890625

30 page frames:

FIFO:0.884375

LRU:0.890625

OPT:0.9

LFU:0.890625

31 page frames:

FIFO:0.9

LRU:0.9

OPT:0.9

LFU:0.896875

32 page frames:

FIFO:0.9

LRU:0.9

OPT:0.9

LFU:0.9

六、讨论与结论

通过上机，我了解了许多关于操作系统的专业知识。无论是在批处理系统还是分时系统中，用户进程数一般都多于处理机数、这将导致它们互相争夺处理机。另外，系统进程也同样需要使用处理机。这就要求进程调度程序按一定的策略，动态地把处理机分配给处于就绪队列中的某一个进程，以使之执行。

进程调度的具体功能可总结为如下几点：

（1）记录系统中所有进程的执行情况；

（2）选择占有处理机的进程；

（3）进行进程上下文切换。

进程调度有以下两种基本方式：

非剥夺方式:分派程序一旦把处理机分配给某进程后便让它一直运行下去，直到进程完成或发生某事件而阻塞时，才把处理机分配给另一个进程。

剥夺方式:当一个进程正在运行时，系统可以基于某种原则，剥夺已分配给它的处理机，将之分配给其它进程。剥夺原则有：优先权原则、短进程、优先原则、时间片原则。

实现进程有许多的算法，例如:先进先出算法，最短CPU运行期优先调度算法，轮转法，简单轮转法，多级队列方法，多级反馈队列等等。

这次的实验使我懂得了进程调度的概念方法和基本的实现方法，达到了实验的目的。在实验编程中也遇到了许多的困难，通过查阅资料并且不断的调试程序，最终完成了。在今后的课堂学习和上机实验中要更加努力的学习和掌握这门专业课。