操作系统课程设计----模拟银行家算法避免死锁
操作系统实验报告-死锁的避免
操作系统实验报告-死锁的避免操作系统实验（二）死锁的避免1.实验内容使用C++实现模拟随机算法和银行家算法2.实验目的（1）了解死锁的产生原因（随机算法）（2）理解死锁的解决办法（银行家算法）3.实验题目使用随机算法和银行家算法设计程序4.程序流程图主要过程流程图银行家算法流程图安全性算法流程图5.程序代码和运行结果#include <stdio.h>#include<stdlib.h> typedef struct{int A;int B;int C;}RES;#define false 0#define true 1//系统中所有进程数量#define PNUMBER 3//最大需求矩阵RES Max[PNUMBER];//已分配资源数矩阵RES Allocation[PNUMBER];//需求矩阵RES Need[PNUMBER];//可用资源向量RES Available={0,0,0};//安全序列int safe[PNUMBER];void setConfig(){int i=0,j=0;printf("================开始手动配置资源==================\n");//可分配资源printf("输入可分配资源\n");scanf("%d%d%d",&Available.A,&Available.B,&Available.C);//最大需求矩阵MAXprintf("输入最大需求矩阵%dx%d\n",PNUMBER,PNUMBER );for (i=0;i<PNUMBER;i++){scanf("%d%d%d",&Max[i].A,&Max[i].B,&Max[i].C);}//已分配矩阵Allocprintf("输入已分配矩阵%dx%d\n",PNUMBER,PNUMBER);for (i=0;i<PNUMBER;i++){scanf("%d%d%d",&Allocation[i].A,&Allocation[i].B,&Allocation[i].C);}//需求矩阵printf("输入需求矩阵%dx%d\n",PNUMBER,PNUMBER);for (i=0;i<PNUMBER;i++){scanf("%d%d%d",&Need[i].A,&Need[i].B,&Need[i].C);}printf("================结束配置资源==================\n");}void loadConfig(){FILE *fp1;if ((fp1=fopen("config.txt","r"))==NULL){printf("没有发现配置文件,请手动输入\n");setConfig();}else{int i=0;printf("发现配置文件,开始导入..\n");//可分配资源fscanf(fp1,"%d%d%d",&Available.A,&Available.B,&Available.C);//最大需求矩阵MAXfor (i=0;i<PNUMBER;i++){fscanf(fp1,"%d%d%d",&Max[i].A,&Max[i].B,&Max[i].C);}//已分配矩阵Allocfor (i=0;i<PNUMBER;i++){fscanf(fp1,"%d%d%d",&Allocation[i].A,&Allocation[i].B,&Allocation[i].C);}//需求矩阵for (i=0;i<PNUMBER;i++){fscanf(fp1,"%d%d%d",&Need[i].A,&Need[i].B,&Need[i].C);}}}//试探分配void ProbeAlloc(int process,RES *res){Available.A -= res->A;Available.B -= res->B;Available.C -= res->C;Allocation[process].A += res->A;Allocation[process].B += res->B;Allocation[process].C += res->C;Need[process].A -= res->A;Need[process].B -= res->B;Need[process].C -= res->C;}//若试探分配后进入不安全状态，将分配回滚void RollBack(int process,RES *res){Available.A += res->A;Available.B += res->B;Available.C += res->C;Allocation[process].A -= res->A;Allocation[process].B -= res->B;Allocation[process].C -= res->C;Need[process].A += res->A;Need[process].B += res->B;Need[process].C += res->C;}//安全性检查bool SafeCheck(){RES Work;Work.A = Available.A;Work.B = Available.B;Work.C = Available.C;bool Finish[PNUMBER] = {false,false,false};int i;int j = 0;for (i = 0; i < PNUMBER; i++){//是否已检查过if(Finish[i] == false){//是否有足够的资源分配给该进程if(Need[i].A <= Work.A && Need[i].B <= Work.B && Need[i].C <= Work.C){//有则使其执行完成，并将已分配给该进程的资源全部回收Work.A += Allocation[i].A;Work.B += Allocation[i].B;Work.C += Allocation[i].C;Finish[i] = true;safe[j++] = i;i = -1; //重新进行遍历}}}//如果所有进程的Finish向量都为true则处于安全状态，否则为不安全状态for (i = 0; i < PNUMBER; i++){if (Finish[i] == false){return false;}}return true;}//资源分配请求bool request(int process,RES *res){//request向量需小于Need矩阵中对应的向量if(res->A <= Need[process].A && res->B <= Need[process].B && res->C <=Need[process].C){//request向量需小于Available向量if(res->A <= Available.A && res->B <= Available.B && res->C <= Available.C){//试探分配ProbeAlloc(process,res);//如果安全检查成立，则请求成功，否则将分配回滚并返回失败if(SafeCheck()){return true;}else{printf("安全性检查失败。
操作系统实验报告 预防进程死锁的银行家算法
操作系统实验预防进程死锁的银行家算法一、需求分析：1、实验目的：通过这次实验，加深对进程死锁的理解，进一步掌握进程资源的分配、死锁的检测和安全序列的生成方法。
2、问题描述：设计程序模拟预防进程死锁的银行家算法的工作过程。
假设系统中有n个进程P1, … ,P n，有m类可分配的资源R1, … ,R m，在T0时刻，进程P i分配到的j类资源为Allocation ij个，它还需要j类资源Need ij个，系统目前剩余j类资源Work j个，现采用银行家算法进行进程资源分配预防死锁的发生。
3、程序要求：1）判断当前状态是否安全，如果安全给出安全序列；如果不安全给出理由。
2）对于下一个时刻T1，某个进程P k会提出请求Request(R1, … ,R m)，判断分配给P k进程请求的资源之后系统是否安全。
3）输入：进程个数n，资源种类m，T0时刻各个进程的资源分配情况（可以运行输入，也可以在程序中设置）；4）输出：如果安全，输出安全的进程序列，不安全则提示信息。
二、概要设计：1、进程调度的实现过程2、程序中的变量及数据结构struct ResItem{string Name;int Number;}; //资源项typedef vector<ResItem> Resource;struct Progress{string Name;Resource Max; //最大需求Resource Allocation; //分配Resource Need; //需求}; //进程vector <Progress> Progresses; //所有进程vector <ResItem> Available; //可利用资源向量vector <Progress> SafeOrder; //安全序列3、主要函数//初始化数据void InitData(int &n);//判断rs1是否小于等于rs2，是返回true，否则返回falseinline bool LessThan(Resource rs1,Resource rs2);//安全性算法bool SafeAlg();//银行家算法bool BankerAlg(Resource request,Progress &pro);4、主函数int main(){int n;InitData(n);cout<<"\n\n=============================================\n ";if(SafeAlg()){cout<<"由安全性检查可知：可以找到一个安全序列为：{";for(int i = 0 ; i < SafeOrder.size(); i++)cout<<SafeOrder[i].Name<<",";cout<<"}。
银行家死锁避免算法模拟
银行家死锁避免算法模拟一. 课程设计目得通过本次实验掌握银行家死锁避免算法得基本思想。
当进程提出资源申请时,能够用该算法判断就是否拒绝进程请求。
二.课程设计摘要银行家算法:我们可以把操作系统瞧作就是银行家,操作系统管理得资源相当于银行家管理得资金，进程向操作系统请求分配资源相当于用户向银行家贷款。
操作系统按照银行家制定得规则为进程分配资源,当进程首次申请资源时，要测试该进程对资源得最大需求量,如果系统现存得资源可以满足它得最大需求量则按当前得申请量分配资源，否则就推迟分配。
当进程在执行中继续申请资源时,先测试该进程已占用得资源数与本次申请得资源数之与就是否超过了该进程对资源得最大需求量。
若超过则拒绝分配资源，若没有超过则再测试系统现存得资源能否满足该进程尚需得最大资源量,若能满足则按当前得申请量分配资源,否则也要推迟分配.四.课程设计原理分析在多道程序系统中，虽可借助于多个进程得并发执行，来改善系统得资源利用率，提高系统得吞吐量，但可能发生一种危险-—死锁.所谓死锁，就是指多个进程在运行过程中因争夺资源而造成得一种僵局,当进程处于这种僵局状态时，若无外力作用，它们都将无法再向前推进。
为保证系统中诸进程得正常运行,应事先采取必要得措施,来预防死锁.最有代表性得避免死锁得方法，就是Dｉjkstra得银行家算法。
死锁：死锁得产生,必须同时满足四个条件,第一个为互斥条件，即一个资源每次只能由一个进程占用;第二个为请求与保持条件，指进程已经保持了至少一个资源,但又提出了新得资源请求,而该资源又被其她进程占有,此时请求进程阻塞,但又对自己已获得得其她资源保持不放；第三个为非剥夺条件,即在出现死锁得系统中一定有不可剥夺使用得资源；第四个为循环等待条件，系统中存在若干个循环等待得进程，即其中每一个进程分别等待它前一个进程所持有得资源。
防止死锁得机构只能确保上述四个条件之一不出现,则系统就不会发生死锁。
银行家算法原理：银行家算法就是避免死锁得一种重要方法，通过编写一个简单得银行家算法程序,加深了解有关资源申请、避免死锁等概念，并体会与了解死锁与避免死锁得具体实施方法。
操作系统课程设计报告 银行家算法
操作系统课程设计报告题目：银行家算法操作系统课程设计报告题目：银行家算法摘要在多道操作系统中，可以利用多个进程并发执行来改善系统资源利用率，提高系统的吞吐量，但也可能发生人们不想看到的危险——死锁。
为了解决这个问题，人们引入了多种机制处理死锁问题。
本文主要介绍了操作系统如何运用银行家算法和安全性算法避免死锁的产生。
同时运用Java编程语言模拟计算机内部资源分配的过程。
让读者对银行家算法有更深刻的认识。
关键字：死锁银行家算法安全性算法资源分配IAbstractIn much road OS, improve the systematic handling capacity, but also may people happened not thinking of dangerous dead lock seeing that to come to improve system resource utilization ratio being able to make use of many course concurrency to carry out. Have led into various mechanism for problem , people resolving this handle lock fast problem. The main body of a book has been introduced mainly how to apply the banker algorithm and the security algorithm to avoid lock fast creation. Wield Java programming language analog computer inside resource assignment process at the same time. Let reader have deeper cognition to banker algorithm.Key words: Algorithmic algorithmic security of dead lock banker resource assignmentII目录中文摘要 (I)英文摘要 (II)1绪论 (1)2需求分析 (2)3概要设计 (3)4详细设计 (4)5测试与分析 (6)6总结 (11)7参考文献 (12)附录 (13)1绪论银行家算法诞生的背景：操作系统作为裸机上安装的第一层软件，起着控制和管理计算机内部软硬件资源，合理组织计算机工作流程，提高计算机工作效率，用户和计算机硬件接口的重要作用。
操作系统课程设计任务书
操作系统集中上机实验1：银行家算法一、目的和要求银行家算法是避免死锁的一种重要方法,本实验要求用高级语言编写和调试一个简单的银行家算法程序。
加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
二、实验内容1.设计进程对各类资源最大申请表示及初值确定。
2.设定系统提供资源初始状况。
3.设定每次某个进程对各类资源的申请表示。
4.编制程序，依据银行家算法，决定其申请是否得到满足。
三、算法描述银行家可以把一定数量的资金供多个用户周转使用，为保证资金的安全银行家规定：1.当一个用户对资金的最大需求量不超过银行家现有的资金就要接纳该用户；2.用户可以分期贷款,但贷的总数不能超过最大需求量；3.当银行家现有的资金不能满足用户的沿需贷数时,对用户的贷款可推迟支付,但总能使用户在有限的时间里得到贷款；4.当用户得到所需的全部资金后,一定能在有限的时间里归还所有的资金。
实验2：时间片轮转法基本思想：将CPU的处理时间划分成一个个时间片，就绪队列中的诸进程轮流运行一个时间片，当时间片结束时，就强迫运行进程让出CPU,该进程进入就绪队列，等待下一次调度，同时,进程调度又去选择就绪队列中的一个进程,分配给它一个时间片，以投入运行。
在轮转法中，时间片长度的选择非常重要,将宜接影响系统开销和响应时间。
如果时间片长度很小，则调度程序剥夺处理机的次数频繁,加重系统开销；反之，如果时间片长度选择过长，比方说一个时间片就能保证就绪队列中所有进程都执行完毕，则轮转法就退化成先进先出算法。
实验3-4：抢占式(或非抢占式)优先级调度算法基本思想：该算法的基本思想是进程优先级高者优先调度，是一种常用的进程调度算法。
该算法的关键是如何确定优先数。
通常确定优先数的方法有两种，即静态法和动态法。
(1)静态优先权是在创建进程时确定的，其运行特征是优先数确定之后在整个进行运行期间不再改变。
确定静态优先权的依据有进程的类型、进程所使用的资源、进程的估计运行时间等因素。
操作系统课设(模拟实现银行家算法实现死锁避免)
计算机与信息工程系《计算机系统与系统软件》课程设计报告题目：模拟实现银行家算法实现死锁避免专业：信息管理与信息系统班级：信管082班学号：姓名：指导老师：2010年9 月9 日一、实验题目模拟实现银行家算法实现死锁避免二、目的：1、了解进程产生死锁的原因，了解为什么要进行死锁的避免。
2、掌握银行家算法的数据结构，了解算法的执行过程，加深对银行家算法的理解。
三、内容：模拟实现银行家算法实现死锁避免。
要求：初始数据（如系统在T0时刻的资源分配情况、每一种资源的总数量）从文本文件读入，文件中给出最大需求矩阵Max、分配矩阵Allocation，在程序中求得需求矩阵Need和可利用资源向量Available。
四、实验提示：1、整个银行家算法的思路。
先对用户提出的请求进行合法性检查，再进行预分配，利用安全性检查算法进行安全性检查。
2、算法用到的主要数据结构和C语言说明。
（1）、可利用资源向量INT A V AILABLE[M] M为资源的类型。
（2）、最大需求矩阵INT MAX[N][M] N为进程的数量。
（3）、已分配矩阵INT ALLOCA TION[N][M]（4）、还需求矩阵INT NEED[N][N]（5）、申请各类资源数量int Request[x]; //（6）、工作向量int Work[x];（7）、int Finish[y]; //表示系统是否有足够的资源分配给进程，0为否，非0为是3、银行家算法（主程序）（1）、系统初始化。
输入进程数量，资源种类，各进程已分配、还需求各资源数量，各资源可用数量等（2）、输入用户的请求三元组（I，J，K），为进程I申请K个J类资源。
（3）、检查用户的请求是否小于还需求的数量，条件是K<=NEED[I,J]。
如果条件不符则提示重新输入，即不允许索取大于需求量（4）、检查用户的请求是否小于系统中的可利用资源数量，条件是K<=A V ALIABLE[I,J]。
操作系统课程设计(银行家算法设计)
《 操作系统 》课程设计报告系 别： 信息科学与技术系专业班级：学生姓名：指导教师：（课程设计时间：2010年7月5日——2010年7月9日）目 录一、课程设计目的和意义 (3)二、课程设计题目描述及算法 (3)三、课程设计报告内容 (3)1.算法描述 (3)2.数据结构 (4)3.主要函数说明 (4)4.算法流程图 (5)5.运行结果及说明 (7)6.附录清单及分析 (8)四、总结 (14)一、课程设计目的和意义了解掌握银行家算法，学会模拟实现资源分配，同时有要求编写和调试一个系统分配资源的简单模拟程序，观察死锁产生的条件，并使用适当的算法，有效的防止和避免死锁的发生二、课程设计题目描述及算法题目：银行家算法设计设计要求：编制银行家算法通用程序，并检测所给状态的系统安全性。
设进程I提出请求Request[N]，则银行家算法按如下规则进行判断。
(1)如果Request[N]<=NEED[I，N]，则转(2)；否则，出错。
(2)如果Request[N]<=AVAILABLE，则转(3)；否则，出错。
(3)系统试探分配资源，修改相关数据：AVAILABLE=AVAILABLE-REQUESTALLOCATION=ALLOCATION+REQUESTNEED=NEED-REQUEST(4)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。
上述三个矩阵存在如下关系：Need[i,j]= Max[i，j]- Allocation[i，j]三、课程设计报告内容1.算法描述设Request[i] 是进程Pi的请求向量，如果Requesti[j]=K,表示进程Pi需要K 个Rj类型的资源，当Pi发出资源请求后，系统按下面步骤进行检查：，便转向步骤2；否则认为出错，因为它所需（1）如果Requesti[j]<=Need[i,j]要的资源数已超过它所宣布的最大值。
操作系统实验报告-利用银行家算法避免死锁
计算机操作系统实验报告题目利用银行家算法避免死锁一、实验目的：1、加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
2、要求编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用银行家算法，有效的防止和避免死锁的发生。
二、实验内容：用银行家算法实现资源分配：设计五个进程{p0,p1,p2,p3,p4}共享三类资源{A,B,C}的系统，例如，{A,B,C}的资源数量分别为10，5，7。
进程可动态地申请资源和释放资源，系统按进程的申请动态地分配资源，要求程序具有显示和打印各进程的某一个时刻的资源分配表和安全序列；显示和打印各进程依次要求申请的资源号以及为某进程分配资源后的有关资源数据。
三、问题分析与设计：1、算法思路：先对用户提出的请求进行合法性检查，即检查请求是否大于需要的，是否大于可利用的。
若请求合法，则进行预分配，对分配后的状态调用安全性算法进行检查。
若安全，则分配；若不安全，则拒绝申请，恢复到原来的状态，拒绝申请。
2、银行家算法步骤：（1）如果Requesti＜or =Need,则转向步骤(2)；否则，认为出错，因为它所需要的资源数已超过它所宣布的最大值。
（2）如果Request＜or=Available,则转向步骤（3）；否则，表示系统中尚无足够的资源，进程必须等待。
（3）系统试探把要求的资源分配给进程Pi,并修改下面数据结构中的数值：Available=Available-Request[i];Allocation=Allocation+Request;Need=Need-Request;(4)系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。
3、安全性算法步骤：（1）设置两个向量①工作向量Work。
它表示系统可提供进程继续运行所需要的各类资源数目，执行安全算法开始时，Work=Allocation;②布尔向量Finish。
它表示系统是否有足够的资源分配给进程，使之运行完成，开始时先做Finish[i]=false，当有足够资源分配给进程时，令Finish[i]=true。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
模拟通过银行家算法避免死锁
一、银行家算法产生的背景及目的
1：在多道程序系统中，虽然借助于多个进程的并发执行来改善系统的利用率，提高系统的吞吐量，但可能发生一种危险—死锁。
死锁就是多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵局状态时，如无外力作用，他们将无法再向前进行，如再把信号量作为同步工具时，多个Wait 和Signal操作顺序不当，会产生进程死锁。
然而产生死锁的必要条件有互斥条件，请求和保持条件，不剥夺条件和环路等待条件。
在预防死锁的几种方法中，都施加了较强的限制条件，在避免死锁的方法中，所施加的条件较弱，有可能获得令人满意的系统性能。
在该方法中把系统的状态分为安全状态和不安全状态，只要能使系统都处于安全状态，便可避免死锁。
2：实验目的：让学生独立的使用编程语言编写和调试一个系统分配资源的简单模拟程序，了解死锁产生的原因及条件。
采用银行家算法及时避免死锁的产生，进一步理解课堂上老师讲的相关知识点。
银行家算法是从当前状态出发，逐个按安全序列检查各客户中谁能完成其工作，然后假定其完成工作且归还全部贷款，再进而检查下一个能完成工作的客户。
如果所有客户都能完成工作，则找到一个安全序列，银行家才是安全的。
二：银行家算法中的数据结构
1：可利用资源向量Available。
这是一个含有m个元素的数组，其中的每个元素代表一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源的数目，其数值随该类资源的分配和回收而动态的改变。
如果Available[j]=k，z
则表示系统中现有Rj类资源K 个。
2：最大需求矩阵Max。
这是一个n*m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。
如果Max[i,j]=k，表示第i个进程需要第Rj类资源的最大数目k个.
3: 分配矩阵Allocation,也是n*m的矩阵，若Allocation[i,j]=k,表示第i
个进程已分配Rj类资源的数目为k个。
4：需求矩阵Need。
也是一个n*m的矩阵，Need[i,j]=k,表示第i个进程还需Rj类资源k个。
三、银行家算法及安全性算法
1：银行家算法
设Request[i]是进程Pi的请求向量，若Request[i][j]=k;表示进程需要j 类资源k个。
当Pi发出资源请求时，系统按下属步骤进行检查；
(1)如果Request[i][j]<=Need[i][j];便转向步骤（2），否则认
为出错，因为它所需要的资源数已超过他所宣布的最大值。
(2)如果Request[i][j]<=Available[i][j],便转向步骤（3），
否则认为尚无足够资源，进程需等待。
(3)系统试探着把资源分配给进程，并修改下面数据结构的数据
Available[i][j]=Available[i][j]-Request[i][j];
Allocation[i][j]=Allocation[i][j]+Request[i][j];
Need[i][j]=Need[i][j]-Request[i][j];
(4)系统执行安全性算法，检查此次资源分配后系统是否处于安
全状态。
若安全，才正式将资源分配给进程Pi，已完成此次分配。
否则，将本次的试探分配作废，回复原来的资源分配状态，将进程Pi等待。
2：安全性算法
（1）设置两个向量；
1：工作向量Work，表示系统可提供给进程运行所需的各类资源数目，它含有m个元素，初始时Work=Available
2：Finish ,表示系统是否有足够的资源分配给进程，使之运行完成。
开始时先做Finish[i]=true
（2）从进程中找到一个能满需下属条件的进程
1；Finish[i]=false；
2：Need[i][j]<=Work[j];若找到执行步骤（3），否则执行步骤（4）
（3）当进程Pi顺利获得资源后，直至完成，并释放分配给它的资源，执行：
Work[j]=Work[j]+Allocation[i][j];
Finish[i]=true;
Go to step (2);
(5)如果所有的进程Finish[i]都满足，则表示系统处于安全状
态，否则，处于不安全状态。
四、模块设计与分析及整体功能概述
模块设计与分析：
整个银行家算法分为初始化函数Init（），安全性算法函数 safe（），银行家算法函数bank（）三部分。
初始化函数生成开始时刻系统中的进程和资源情况，安全性算法判断当某进程申请资源时，系统能否处于安全状态。
在本实验中，若系统处于安全状态，便生成一个安全进程序列（安全序列可能有多个）。
银行家算法函数bank（）负责整体的检查与异常判断。
整体功能概述：
死锁会引起系统陷入僵局，操作系统必须防止此现象的发生。
本实验通过一个动态分配资源的模拟程序，更清楚的理解死锁产生的原因和条件。
Dijkstra的银行家算法是最有代表性的避免死锁的方法。
运行程序时用户设定系统中进程和可利用资源的种类数目。
输入各进程的可利用资源Available，最大需求MAX，已分配资源Allocation ，需求资源Need，之后各系统发出资源请求Request，利用实验中的安全性算法判断能否产生一个安全性队列，若能，则给该进程分配成功，否则，不予分配。
五、流程图设计
六、源代码及调试分析
#include<>
#define MAXm 50
用Vc++编译
程序编写银行家算法，进一步理解到通过银行家算法避免死锁的思想,同时也理解了系统死锁产生的原因及条件。
2.在实验过程中所有的设计步骤遵循老师教授的程序功能化的思想，分别定义了三个函数，init()初始化函数,safealg()安全性算法函数，bank（）银行家算法函数，体现了函数的模块化思想。
这样的话，不仅提高了程序的可读性和可操作性，而且还提高了CPU的利用率和内存的利用率，因为程序的运行是局部性的，这种思想对于段页式存储管理系统尤为重要。
3.实验过程中遇到的种种疑难问题通过自己上网查找答案，锻炼了自己纠错能力和搜索有价值信息的能力及自学的能力，并且进一步巩固了自己以前学过的专业知识。