合肥工业大学操作系统课程设计报告
操作系统课程设计报告
操作系统课程设计报告概述：本课程设计旨在使学生熟悉文件管理系统的设计方法，加深对所学各种文件操作的了解及其操作方法的特点。
通过模拟文件系统的实现，深入理解操作系统中文件系统的理论知识，加深对教材中的重要算法的理解。
同时通过编程实现这些算法，更好地掌握操作系统的原理及实现方法，提高综合运用各专业课知识的能力。
主要任务：本课程设计的主要任务是设计和实现一个简单的文件系统，包括建立文件存储介质的管理机制、建立目录（采用一级目录结构）、文件系统功能（显示目录、创建、删除、打开、关闭、读、写）和文件操作接口（显示目录、创建、删除、打开、关闭、读、写）。
系统设计：本系统模拟一个文件管理系统，要完成对文件的基本操作，包括文件、文件夹的打开、新建、删除和读取写入文件，创建更改目录，列出目录内容等信息。
系统建立了文件目录树，存储文件系统中的所有文件。
对于用户名下的文件，用文件目录树的分支来存储。
采用命令行操作界面很直观，也方便用户进行操作，用户只要按照操作界面所显示的命令来操作即可。
整体设计框架：系统初始化界面由创建用户存储空间、管理文件、退出系统三个模块组成。
用户创建由创建用户存储空间、进入目录、删除用户存储空间、显示所有用户存储空间等模块组成。
然后各个模块再由一些小模块组成。
其中创建文件、打开关闭文件、读写文件等文件操作模块包括在进入目录模块里面。
系统实现：以下是本课程设计的主要内容的实现程序代码：cincludeincludeincludetypedef struct file{ char name[10];struct file *next; File;typedef struct content{ char name[10];File *file;int f_num;struct content *next; Content;typedef struct user{ char name[10];char psw[10]; Content *con;struct user *next; User;char cur_user[20];XXX;int user_num=0;添加文件：在该函数中，我们首先需要获取文件名，然后检查是否已经存在该文件。
合肥工业大学操作系统实验报告
操作系统实验报告班级：计算机科学与技术姓名：学号：实验3 进程的创建一、实验目的练习使用EOS API 函数CreateProcess 创建一个进程，掌握创建进程的方法，理解进程和程序的区别。
调试跟踪CreateProcess 函数的执行过程，了解进程的创建过程，理解进程是资源分配的单位。
二、实验过程记录1./*Hello.c*/#include "EOSApp.h"int main(int argc, char* argv[]){int i;for (i = 1; i <= 5; i++) {printf("Hello,world! %d\n", i);Sleep(1000);}printf("Bye-bye!\n");return 0;}作用:测试软盘镜像中的程序。
输出"Hello,world! I”并循环输出五次,每次挂起1000ms,最后输出” Bye-b ye!”。
结果:2./*NewProc.c*/#include "EOSApp.h"int main(int argc, char* argv[]){STARTUPINFO StartupInfo;PROCESS_INFORMATION ProcInfo;ULONG ulExitCode; // 子进程退出码INT nResult = 0; // main 函数返回值。
0 表示成功，非0 表示失败。
#ifdef _DEBUG__asm("int $3\n nop");#endifprintf("Create a process and wait for the process exit...\n\n");//// 使子进程和父进程使用相同的标准句柄。
//StartupInfo.StdInput = GetStdHandle(STD_INPUT_HANDLE);StartupInfo.StdOutput = GetStdHandle(STD_OUTPUT_HANDLE);StartupInfo.StdError = GetStdHandle(STD_ERROR_HANDLE);//// 创建子进程。
合肥工业大学操作系统课程设计报告
一.设计题目第9题：进程死锁的检测：绘制资源分配图要求：1)建立资源分配图的数据结构描述；2)建立绘制资源分配图的历程，包括结点和有向边；3)可以删除、添加节点或有向边。
4)可以鼠标在串口的任意位置指点，确定结点或者有向边的位置；5)可以拖动现有结点的位置，使之相关的结点移动6)可以存入文件和从文件中读取。
二.设计原理及算法描述UNIX命令:ls [选项]列出文件信息(默认为当前目录)ls无参显示一个目录中的文件和子目录ls -l每行仅显示一个目录或名称ls --help 显示此帮助信息并离开mkdir目录若目录不存在则创建目录mkdir --help显示此帮助信息并离开rmdir目录若目录没有数据则删除目录rmdir --help显示此帮助信息并离开cp来源文件目的文件将来源文件复制到目的文件cp --help显示此帮助信息并离开cat文件或：cat 文件1 >> 文件2显示文件内容或连接两个文件，并将结果输出到显示屏上cat文件将文件的内容输出到显示屏上cat 文件1 >> 文件2将文件1连接到文件2的结尾，并输出到显示屏上cat --help 显示此帮助信息并离开more文件使文件能逐行(回车键)或逐页(空格键)显示并显示当前文件所占总文件的百分比more --help显示此帮助信息并离开mv文件1 文件2或：mv 文件目录重命名或移动文件mv 文件1 文件2将文件1名字改为文件2的名字mv 文件目录将指定文件移动到指定目录下mv --help显示此帮助信息并离开sort文件将文本文件内容加以排序sort --help显示此帮助信息并离开按照每个命令的功能编写一个实现函数。
通过c++字符串操作从输入流获得指令以及参数，通过对指令以及参数的判别调用对应指令的函数，实现对windows内文件的各项操作。
三.开发环境硬件环境：个人PC机软件环境：Microsoft Windows XPMicrosoft Visual C++ 6.0四.重要算法和设计思路描述命令以及参数的获取：由于命令加参数最多能有四部分，所以申请4个字符串数组。
合工大操作系统课程设计
合工大操作系统课程设计一、课程目标知识目标：1. 理解操作系统的基本概念，掌握操作系统的发展历程、功能及分类。
2. 学会分析操作系统的核心组成部分，如进程管理、内存管理、文件系统、设备管理。
3. 掌握操作系统的基本原理，如进程调度、内存分配、文件权限控制等。
技能目标：1. 能够运用进程管理的基本方法，编写简单的进程同步与互斥程序。
2. 学会使用操作系统提供的API进行文件操作和设备控制。
3. 能够分析并优化操作系统的性能，提高系统资源利用率。
情感态度价值观目标：1. 培养学生对操作系统的学习兴趣，激发他们探索计算机科学领域的热情。
2. 培养学生的团队协作精神，提高他们在项目实践中的沟通与协作能力。
3. 培养学生具备良好的计算机伦理道德观念，尊重知识产权，遵循法律法规。
本课程针对合肥工业大学高年级本科生，课程性质为专业核心课。
结合学生特点，课程目标注重理论与实践相结合，培养学生具备扎实的操作系统能力。
在教学过程中，要求学生积极参与讨论、实践，达到学以致用的目的。
课程目标分解为具体学习成果，以便后续教学设计和评估，确保学生能够全面掌握操作系统知识，提高实践能力。
二、教学内容本课程教学内容主要包括以下几部分：1. 操作系统概述：介绍操作系统的发展历程、功能、分类及其在计算机系统中的作用。
2. 进程管理：讲解进程与线程的概念、进程调度算法、进程同步与互斥、死锁与饥饿问题。
3. 内存管理：阐述内存分配策略、虚拟内存技术、页式和段式存储管理、内存碎片问题。
4. 文件系统：介绍文件和目录结构、文件权限控制、文件系统性能优化、磁盘空间分配策略。
5. 设备管理：讲解设备驱动程序、I/O调度策略、中断处理、设备分配与回收。
6. 操作系统实例分析：以Linux操作系统为例，分析其内核架构、进程管理、内存管理、文件系统等关键技术。
7. 操作系统性能评价与优化：介绍操作系统性能指标、性能评价方法、常用优化策略。
教学内容根据课程目标和教材章节进行合理安排，保证教学内容的科学性和系统性。
操作系统课程设计报告
操作系统课程设计报告1. 引言操作系统是计算机系统中最核心的软件之一，它负责管理和优化计算机资源的分配和调度，为用户和应用程序提供一个可靠、高效的执行环境。
在操作系统课程设计中，我们通过设计一个简单的操作系统，深入理解操作系统的原理和功能，提升对操作系统的理解和实践能力。
本报告将详细介绍我们小组在操作系统课程设计过程中所完成的工作和实现的目标。
2. 设计目标在本次操作系统课程设计中，我们的设计目标包括：•实现一个基本的中断处理、进程调度和内存管理机制；•设计一个简单的文件系统；•确保操作系统的稳定性和可靠性；•实现用户命令解析和执行功能。
3. 系统架构我们的操作系统设计采用了经典的分层结构，主要由硬件抽象层、内核和用户接口层组成。
1.硬件抽象层：负责与硬件进行交互，提供基本的底层硬件接口，如处理器管理、中断处理、设备控制等。
2.内核：实现操作系统的核心功能，包括进程管理、内存管理、文件系统管理等。
这一层是操作系统的核心，负责管理和调度系统资源。
3.用户接口层：为用户提供简单友好的界面，解析用户输入的命令并调用内核功能进行处理。
用户可以通过命令行或图形界面与操作系统进行交互。
4. 功能实现4.1 中断处理中断是操作系统与外部设备通信的重要机制，我们的操作系统设计中实现了基本的中断处理功能。
通过在硬件抽象层中捕获和处理硬件的中断信号，内核可以对中断进行相应的处理，保证系统的响应能力和稳定性。
4.2 进程调度进程调度是操作系统中的重要任务之一，它决定了系统如何分配和调度上下文切换。
我们的操作系统设计中实现了一个简单的进程调度算法，通过时间片轮转算法和优先级调度算法来管理多个进程的执行顺序，以提高系统的吞吐量和响应性能。
4.3 内存管理内存管理是操作系统中必不可少的功能，它负责对系统内存的分配和回收。
我们的操作系统设计中实现了基本的内存管理功能，包括内存分区、内存空闲管理和地址映射等。
通过合理的内存管理，可以提高系统的内存利用率和性能。
操作系统课程设计报告
实践课设计报告课程名称操作系统课程设计模拟设计内存管理中的地址题目转换（动态分区、页式十进制）学院班级学号姓名指导教师年月日课程设计任务书学生姓名：专业班级：指导教师：工作单位：题目: 模拟设计内存管理中的地址转换（动态分区、页式十进制）初始条件：1．预备内容：阅读操作系统的内存管理章节内容，理解动态分区、页式、段式和段页式存储管理的思想及相应的分配主存的过程。
2．实践准备：掌握一种计算机高级语言的使用。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）1．下列内部存储器管理中地址转换，在完成指定存储管理技术中的地址转换基础上还可以选择其它内部存储器管理中的地址转换进行模拟设计并实现：⑴动态分区方案，用最先适用算法对作业实施内存分配，然后把作业地址空间的某一逻辑地址转换成相应的物理地址。
能够处理以下的情形：输入某一逻辑地址，程序能判断地址的合法性，如果合法，计算并输出相应的物理地址。
如果不能计算出相应的物理地址，说明原因。
⑵页式存储管理中逻辑地址到物理地址的转换（十进制）。
能够处理以下的情形：输入某一十进制逻辑地址，能检查地址的合法性，如果合法进行转换，否则显示“地址非法”；物理地址用十进制表示。
⑶页式存储管理中逻辑地址到物理地址的转换（八进制）。
能够处理以下的情形：输入某一八进制逻辑地址，能检查地址的合法性，如果合法进行转换，否则显示“地址非法”；物理地址用八进制表示。
⑷页式存储管理中逻辑地址到物理地址的转换（十六进制）。
能够处理以下的情形：输入某一十六进制逻辑地址，能检查地址的合法性，如果合法进行转换，否则显示“地址非法”；物理地址用十六进制表示。
⑸段式存储管理中逻辑地址到物理地址的转换。
能够处理以下的情形：指定内存的大小，进程的个数，每个进程的段数及段大小；能检查地址的合法性，如果合法进行转换，否则显示地址非法的原因。
⑹段页式存储管理中逻辑地址到物理地址的转换。
合肥工业大学操作系统绘制前驱图
课 程 设 计绘制描述事件先后顺序的前驱图计算机科学与技术09-22010 年 6 月20日设计题目 学 号专业班级 学生姓名指导教师合肥工业大学课程设计任务书第一章课程设计概述1.1 设计任务:设计一个可以绘制前驱图的界面程序1.2 设计要求：建立前驱图的数据结构描述；建立绘制前驱图的例程，包括结点和有向边；可以删除、添加结点或有向边；可用鼠标在窗口的任意位置指点，确定结点或有向边位置；可以拖动现有结点的位置，与该结点相连的有向边也随之移动；可以将前驱图存入文件，从文件中取出；第二章开发环境Java jdk1.6，eclipse第三章程序算法与实现●绘制结点算法简述先绘制一个圆，将数字转化为字符，再在圆中绘制字符●绘制带剪头直线算法简述先绘制一条直线，在直线的一端绘制一个三角形第四章程序实现---数据结构Vector<Point>利用vector向量容器存放point数据结构第五章程序实现---程序清单Node.javapackage com.draw;import java.awt.Graphics2D;public class Node {/*绘制结点函数*/public void drawNode(int x,int y, int n,Graphics2D g){String str=Integer.toString(n);g.drawOval(x, y, 20, 20);g.drawString(str, x+7, y+15);}}Line.javapackage com.draw;import java.awt.Graphics2D;import java.awt.geom.GeneralPath;public class Line {/*绘制直线函数*/public void drawLine(int sx, int sy, int ex, int ey,Graphics2D g){double H = 10; // 箭头高度double L = 4; // 底边的一半int x3 = 0;int y3 = 0;int x4 = 0;int y4 = 0;double awrad = Math.atan(L / H); // 箭头角度double arraow_len = Math.sqrt(L * L + H * H); // 箭头的长度double[] arrXY_1 = rotateVec(ex - sx, ey - sy, awrad, true, arraow_len); double[] arrXY_2 = rotateVec(ex - sx, ey - sy, -awrad, true, arraow_len); double x_3 = ex - arrXY_1[0]; // (x3,y3)是第一端点double y_3 = ey - arrXY_1[1];double x_4 = ex - arrXY_2[0]; // (x4,y4)是第二端点double y_4 = ey - arrXY_2[1];Double X3 = new Double(x_3);x3 = X3.intValue();Double Y3 = new Double(y_3);y3 = Y3.intValue();Double X4 = new Double(x_4);x4 = X4.intValue();Double Y4 = new Double(y_4);y4 = Y4.intValue();// 画线g.drawLine(sx, sy, ex, ey);GeneralPath triangle = new GeneralPath();triangle.moveTo(ex, ey);triangle.lineTo(x3, y3);triangle.lineTo(x4, y4);triangle.closePath();//实心箭头g.fill(triangle);//非实心箭头//g.draw(triangle);}public static double[] rotateVec(int px, int py, double ang,boolean isChLen, double newLen) {double mathstr[] = new double[2];// 矢量旋转函数，参数含义分别是x分量、y分量、旋转角、是否改变长度、新长度 double vx = px * Math.cos(ang) - py * Math.sin(ang);double vy = px * Math.sin(ang) + py * Math.cos(ang);if (isChLen) {double d = Math.sqrt(vx * vx + vy * vy);vx = vx / d * newLen;vy = vy / d * newLen;mathstr[0] = vx;mathstr[1] = vy;}return mathstr;}}Recorder.javapackage com.recorder;import java.awt.Point;import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.FileReader;import java.io.FileWriter;import java.util.Vector;import com.view.DrawPanel;public class Recorder {FileWriter fw=null;BufferedWriter bw=null;FileReader fr=null;BufferedReader br=null;//保存结点记录public void keepNodeRecord(){try {//创建fw=new FileWriter("D://myNodeRecording.txt");bw=new BufferedWriter(fw);for(int i=0;i<DrawPanel.nodes.size();i++){Point p=DrawPanel.nodes.get(i);String recode=p.x+" "+p.y;bw.write(recode+"\r\n");}} catch (Exception e) {e.printStackTrace();}finally{try {bw.close();fw.close();} catch (Exception e2) {e2.printStackTrace();}}}//重置nodes的值public void setNodes(){try {fr=new FileReader("D://myNodeRecording.txt");br=new BufferedReader(fr);String n="";DrawPanel.nodes.clear();while((n=br.readLine())!=null){String[] xy=n.split(" ");Point p=new Point(Integer.parseInt(xy[0]),Integer.parseInt(xy[1]));DrawPanel.nodes.add(p);}} catch (Exception e) {e.printStackTrace();}finally{try {br.close();fr.close();}catch (Exception e2) {e2.printStackTrace();}}}//保存point记录public void keepPointRecord(){try {//创建fw=new FileWriter("D://myPointRecording.txt");bw=new BufferedWriter(fw);for(int i=0;i<DrawPanel.point2.size();i++){Point p1=DrawPanel.point1.get(i);Point p2=DrawPanel.point2.get(i);String recode=p1.x+" "+p1.y+" "+p2.x+" "+p2.y;bw.write(recode+"\r\n");}} catch (Exception e) {e.printStackTrace();}finally{try {bw.close();fw.close();} catch (Exception e2) {e2.printStackTrace();}}}//设置point1的值public void setPoint(){try {fr=new FileReader("D://myPointRecording.txt");br=new BufferedReader(fr);String n="";DrawPanel.point1.clear();DrawPanel.point2.clear();while((n=br.readLine())!=null){String[] x1y1x2y2=n.split(" ");Point p1=new Point(Integer.parseInt(x1y1x2y2[0]),Integer.parseInt(x1y1x2y2[1]));DrawPanel.point1.add(p1);Point p2=new Point(Integer.parseInt(x1y1x2y2[2]),Integer.parseInt(x1y1x2y2[3]));DrawPanel.point2.add(p2);}} catch (Exception e) {e.printStackTrace();}finally{try {br.close();fr.close();}catch (Exception e2) {e2.printStackTrace();}}}}DrawPanel.javapackage com.view;import java.awt.Color;import java.awt.Graphics;import java.awt.Graphics2D;import java.awt.Point;import java.awt.event.MouseEvent;import java.awt.event.MouseListener;import java.awt.event.MouseMotionListener;import java.util.Vector;import javax.swing.JPanel;import com.draw.Line;import com.draw.Node;public class DrawPanel extends JPanel implements MouseMotionListener,MouseListener{ static int command;//被选中索引int selectNode=-1;int selectLine=-1;//定义结点向量组public static Vector<Point> nodes=new Vector<Point>();//第一直线点向量组public static Vector<Point> point1=new Vector<Point>();public static Vector<Point> point2=new Vector<Point>();ToolPanel toolPanel=new ToolPanel();Line l=new Line();Node n=new Node();DrawPanel(){addMouseMotionListener(this);addMouseListener(this);setBackground(Color.WHITE);//设置drawpanel背景色}public void paint(Graphics g) {super.paint(g);Graphics2D g2 = (Graphics2D) g;if(nodes!=null){for(int i=0;i<nodes.size();i++){Point nodestmp=nodes.get(i);n.drawNode(nodestmp.x, nodestmp.y,i, g2);}}if(point1!=null&&point2!=null){for(int j=0;j<point2.size();j++){Point linetmp1=point1.get(j);Point linetmp2=point2.get(j);l.drawLine(linetmp1.x, linetmp1.y, linetmp2.x, linetmp2.y, g2);}}repaint();}/*判断鼠标是否选中结点*/boolean isSelectedNode(int x,int y){boolean isSelected=false;for(int i=0;i<nodes.size();i++){int m=nodes.get(i).x;int n=nodes.get(i).y;if(x>=m&&x<=m+20&&y>=n&&y<=y+20){isSelected=true;selectNode=i;}}return isSelected;}/*判断鼠标是否选中直线*/boolean isSelectedLine(int x,int y){boolean isSelected=false;Point p=new Point(x, y);for(int i=0;i<point2.size();i++){Point start=point1.get(i);Point end=point2.get(i);if(isPointOnLine(p, start, end)){isSelected=true;selectLine=i;}}return isSelected;}/*判断点是否在直线上*/boolean isPointOnLine(Point p,Point start,Point end) {int div=10;int xEnd=end.x-start.x;int yEnd=start.y-end.y;int x2=p.x-start.x;int y1=start.y-p.y- div;int y2=start.y-p.y+div;double tan1=Math.atan2(yEnd,xEnd);double tan2=Math.atan2(y1,x2);double tan3=Math.atan2(y2,x2);return tan1>=tan2&&tan1<=tan3;}/*MouseListener*//*按下并释放触发*/public void mouseClicked(MouseEvent e) {int x=e.getX();int y=e.getY();Point p=new Point(x, y);if(command==toolPanel.drawNode){nodes.add(p);}if(command==toolPanel.deleteCommand){if(isSelectedNode(x, y)){nodes.remove(selectNode);// System.out.println(select+"isSelected");}if(isSelectedLine(x, y)){point1.remove(selectLine);point2.remove(selectLine);}}}/*按下鼠标键触发*/public void mousePressed(MouseEvent e) {if(command==toolPanel.drawLine){int x1 = e.getX();int y1 = e.getY();Point p1=new Point(x1, y1);point1.add(p1);}}/*释放鼠标键触发*/public void mouseReleased(MouseEvent e) {if(command==toolPanel.drawLine){int x2 = e.getX();int y2 = e.getY();Point p2=new Point(x2, y2);point2.add(p2);}}/*鼠标指针进入主键触发*/public void mouseEntered(MouseEvent e) {}/*鼠标指针离开触发*/public void mouseExited(MouseEvent e) {}ToolPanel.javapackage com.view;import java.awt.Button;import java.awt.Color;import java.awt.FileDialog;import java.awt.FlowLayout;import bel;import java.awt.TextField;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import javax.swing.JPanel;import com.recorder.Recorder;public class ToolPanel extends JPanel implements ActionListener{//定义一个recorder对象Recorder recorder=new Recorder();/*命令值*/int clearCommand=0;int openCommand=1;int saveCommand=2;int drawNode=3;int drawLine=4;int moveCommand=5;int deleteCommand=6;FlowLayout flowLayou;//添加布局Label label1;//工具栏标签Label label2;//当前动作标签Button clear;Button open;Button save;Button node;Button line;Button move;Button delete;TextField field;//显示动作文本区//定义两个类对象，方便调用MainFrame frame;//定义对话框// FileDialog fileDialog_save=new FileDialog(frame, "保存文件对话框", FileDialog.SAVE);;// FileDialog fileDialog_load=new FileDialog(frame, "打开文件对话框", FileDialog.LOAD);ToolPanel(){FlowLayout flowLayout=new FlowLayout();setBackground(Color.LIGHT_GRAY);//设置toolpanel背景色//添加控件label1=new Label("工具栏:");clear=new Button("清空");open=new Button("打开");save=new Button("保存");node=new Button("结点");line=new Button("连线");move=new Button("移动");delete=new Button("删除");label2=new Label(" 当前动作:");field=new TextField(10);//控件添加到控件组件上add(label1);add(clear);add(open);add(save);add(node);add(line);add(move);add(delete);add(label2);add(field);//注册监听clear.addActionListener(this);open.addActionListener(this);save.addActionListener(this);node.addActionListener(this);line.addActionListener(this);move.addActionListener(this);delete.addActionListener(this);//布局定义flowLayout.setAlignment(flowLayout.LEADING);setLayout(flowLayout);}/*设置命令类型*/void setCommand(int style){mand=style;}public void actionPerformed(ActionEvent e) {if(e.getSource()==clear){field.setText(clear.getLabel());setCommand(clearCommand);DrawPanel.nodes.clear();DrawPanel.point1.clear();DrawPanel.point2.clear();}if(e.getSource()==open){field.setText(open.getLabel());setCommand(openCommand);//fileDialog_load.setVisible(true);recorder.setNodes();recorder.setPoint();}if(e.getSource()==save){field.setText(save.getLabel());setCommand(saveCommand);//fileDialog_save.setVisible(true);recorder.keepNodeRecord();recorder.keepPointRecord();// System.out.println("保存");}if(e.getSource()==node){field.setText(node.getLabel());setCommand(drawNode);}if(e.getSource()==line){field.setText(line.getLabel());setCommand(drawLine);}if(e.getSource()==move){field.setText(move.getLabel());setCommand(moveCommand);}if(e.getSource()==delete){field.setText(delete.getLabel());setCommand(deleteCommand);}}}MainFrame.javapackage com.view;import java.awt.BorderLayout;import javax.swing.JFrame;import javax.swing.border.Border;public class MainFrame extends JFrame{public static void main(String args[]){MainFrame mainFrame=new MainFrame("绘制前驱图");}MainFrame(String s){setTitle(s);//设置标题setDefaultCloseOperation(EXIT_ON_CLOSE);//设置window窗口上的关闭setBounds(100, 100, 900, 500);//设置frame大小setVisible(true);//设置frame为可见ToolPanel toolpanel=new ToolPanel();//创建toolpanel对象add(toolpanel,BorderLayout.NORTH);//添加panel到frame上DrawPanel drawPanel=new DrawPanel();//创建toolpanel对象add(drawPanel);//添加panel到frame上}}第六章总结通过这次课程设计，使我们更加熟悉的掌握了java语言。
操作系统课程设计报告
《操作系统课程设计》一、课程设计目的1、进程调度是处理机管理的核心内容。
2、本设计要求用C语言编写和调试一个简单的进程调度程序。
3、通过设计本可以加深理解有关进程控制块、进程队列的概念，并体会和了解最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法的具体实施办法。
二、课程设计主要内容1、项目名称设计一个有 N个进程共行的进程调度程序2、实验设备及环境：软件要求：WINDOWS NT 系列操作系统，VC、VB、TURBO C等多种程序设计开发工具。
硬件要求：P4 2.0以上CPU、256M、40G硬盘。
3、课程设计类型综合设计型4、课程设计内容与要求1）进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。
2）每个进程有一个进程控制块（ PCB）表示。
进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
3）进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。
进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
4）每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
5）就绪进程获得 CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后，进程的已占用 CPU 时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
6）每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。
7）重复以上过程，直到所要进程都完成为止。
5、课程设计方法及步骤1）充分了解各项设计要求。
深入理解有关进程控制块、进程队列的概念，并体会和了解最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法的具体实施办法。
《操作系统》课程实验报告
《操作系统》课程实验报告一、实验目的本次《操作系统》课程实验的主要目的是通过实际操作和观察，深入理解操作系统的工作原理、进程管理、内存管理、文件系统等核心概念，并掌握相关的操作技能和分析方法。
二、实验环境1、操作系统：Windows 10 专业版2、开发工具：Visual Studio Code3、编程语言：C/C+＋三、实验内容（一）进程管理实验1、进程创建与终止通过编程实现创建新进程，并观察进程的创建过程和资源分配情况。
同时，实现进程的正常终止和异常终止，并分析其对系统的影响。
2、进程同步与互斥使用信号量、互斥锁等机制实现进程之间的同步与互斥。
通过模拟多个进程对共享资源的访问，观察并解决可能出现的竞争条件和死锁问题。
（二）内存管理实验1、内存分配与回收实现不同的内存分配算法，如首次适应算法、最佳适应算法和最坏适应算法。
观察在不同的内存请求序列下，内存的分配和回收情况，并分析算法的性能和优缺点。
2、虚拟内存管理研究虚拟内存的工作原理，通过设置页面大小、页表结构等参数，观察页面的换入换出过程，以及对系统性能的影响。
（三）文件系统实验1、文件操作实现文件的创建、打开、读取、写入、关闭等基本操作。
观察文件在磁盘上的存储方式和文件系统的目录结构。
2、文件系统性能优化研究文件系统的缓存机制、磁盘调度算法等，通过对大量文件的读写操作，评估不同优化策略对文件系统性能的提升效果。
四、实验步骤（一）进程管理实验步骤1、进程创建与终止（1）使用 C/C+＋语言编写程序，调用系统函数创建新进程。
（2）在子进程中执行特定的任务，父进程等待子进程结束，并获取子进程的返回值。
（3）通过设置异常情况，模拟子进程的异常终止，观察父进程的处理方式。
2、进程同步与互斥（1）定义共享资源和相关的信号量或互斥锁。
（2）创建多个进程，模拟对共享资源的并发访问。
（3）在访问共享资源的关键代码段使用同步机制，确保进程之间的正确协作。
（4）观察并分析在不同的并发情况下，系统的运行结果和资源竞争情况。
操作系统课程设计(银行家算法设计)
《 操作系统 》课程设计报告系 别： 信息科学与技术系专业班级：学生姓名：指导教师：（课程设计时间：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]要的资源数已超过它所宣布的最大值。
合肥工业大学操作系统实验报告
操作系统实验报告班级：计算机科学与技术姓名：学号：实验3 进程的创建一、实验目的练习使用EOS API 函数CreateProcess 创建一个进程，掌握创建进程的方法，理解进程和程序的区别。
调试跟踪CreateProcess 函数的执行过程，了解进程的创建过程，理解进程是资源分配的单位。
二、实验过程记录1./*Hello.c*/#include "EOSApp.h"int main(int argc, char* argv[]){int i;for (i = 1; i <= 5; i++) {printf("Hello,world! %d\n", i);Sleep(1000);}printf("Bye-bye!\n");return 0;}作用:测试软盘镜像中的程序。
输出"Hello,world! I”并循环输出五次,每次挂起1000ms,最后输出” Bye-bye!”。
结果:2./*NewProc.c*/#include "EOSApp.h"int main(int argc, char* argv[]){STARTUPINFO StartupInfo;PROCESS_INFORMATION ProcInfo;ULONG ulExitCode; // 子进程退出码INT nResult = 0; // main 函数返回值。
0 表示成功，非0 表示失败。
#ifdef _DEBUG__asm("int $3\n nop");#endifprintf("Create a process and wait for the process exit...\n\n");//// 使子进程和父进程使用相同的标准句柄。
//StartupInfo.StdInput = GetStdHandle(STD_INPUT_HANDLE);StartupInfo.StdOutput = GetStdHandle(STD_OUTPUT_HANDLE);StartupInfo.StdError = GetStdHandle(STD_ERROR_HANDLE);//// 创建子进程。
操作系统课程设计总结
操作系统课程设计总结一、背景介绍操作系统是计算机科学中的重要课程之一，是计算机系统中最基本的软件之一。
操作系统课程设计是对操作系统原理和实践的实践性应用，旨在让学生通过设计和实现一个简单的操作系统来深入理解操作系统的原理和机制。
二、设计目标本次操作系统课程设计的目标是设计并实现一个简单的操作系统，包括内存管理、进程管理、文件管理等模块，并能够运行一些基本的应用程序。
具体目标如下：1. 实现内存管理模块，包括内存分配、释放等功能；2. 实现进程管理模块，包括进程创建、销毁等功能；3. 实现文件管理模块，包括文件读写、创建删除等功能；4. 能够运行基本的应用程序，如文本编辑器、计算器等。
三、设计思路1. 内存管理模块：采用分页式内存管理方式，将物理内存划分为大小相等且固定的页框，并将虚拟地址空间划分为大小相等且固定的页面。
通过页表将虚拟地址映射到物理地址上。
2. 进程管理模块：采用多级反馈队列调度算法，根据进程优先级和运行时间分配CPU时间片。
实现进程的创建、销毁和切换等功能。
3. 文件管理模块：采用文件控制块（FCB）的方式管理文件，实现文件的读写、创建删除等功能。
同时实现了目录管理功能，支持目录的创建、删除和查看等操作。
4. 应用程序：实现了文本编辑器和计算器两个基本应用程序，能够在操作系统上运行。
四、设计过程1. 内存管理模块：首先进行内存初始化，将物理内存划分为大小相等的页框，并建立页表。
接着实现内存分配和释放函数，通过修改页表来完成内存分配和释放操作。
2. 进程管理模块：首先定义进程控制块（PCB），包括进程ID、状态、优先级、时间片等信息。
然后实现进程的创建、销毁和切换函数，并根据多级反馈队列调度算法来完成进程调度。
3. 文件管理模块：定义文件控制块（FCB），包括文件名、大小、类型等信息。
然后实现文件读写函数和目录管理函数，通过修改FCB来完成文件读写和目录操作。
4. 应用程序：实现了文本编辑器和计算器两个基本应用程序，文本编辑器支持打开、保存和关闭文本文件；计算器支持加减乘除等基本计算功能。
操作系统课程设计报告书
操作系统课程设计题目： 操作系统课程设计学 院 工商学院学 部 信息科学与工程专 业 计算机类学 号 20144229166姓 名 赵林华指导教师 王煜装订线 河北大学工商学院2016 年 6 月24 日目录目录 (2)一、引言 (1)1.1课程设计目的 (1)1.2课程设计内容 (1)1.3小组人数及编程语言 (1)二、需求分析 (1)设备管理 (2)2.1设计任务 (2)2.2设计要求 (2)三算法及数据结构 (2)3.1算法的总体思想（流程） (3)3.2 Equipment模块 (3)3.2.1 功能 (3)3.2.2 数据结构 (3)3.3 cpu模块 (4)3.3.1 功能 (4)3.3.2 数据结构 (4)3.3.3 算法 (5)3.4 form1模块 (5)3.4.1 功能 (5)3.4.2 算法 (6)四、程序设计及实验 (6)五、总结和讨论 (9)六、代码 (10)一、引言1.1课程设计目的通过模拟操作系统的实现，加深对操作系统工作原理理解，进一步了解操作系统的实现方法，并可练习合作完成系统的团队精神和提高程序设计能力。
1.2课程设计内容模拟采用多道程序设计方法的单用户操作系统，该操作系统包括进程管理、存储管理、设备管理、文件管理和用户接口四部分。
1.3小组人数小组人员:赵林华张铭二、需求分析设备管理设备管理设备管理主要包括设备的分配和回收。
模拟系统中有鼠标、键盘、打印机和视频四种设备，采用安全分配方式。
设备采用设备状态的变化还有设备颜色的变化来判断设备所处的状态，当创建文件是就指明了要调用的设备，让后等进程运行时来知道调用的什么设备，最后颜色和状态的变化来反应调用的设备与每个设备所处的状态。
设备用JButton 图标显示，通过灰色和可见色判断是否被调用2.1设计任务设计一个设备管理分配程序，按先来先服务的算法，对设备进行分配。
2.2设计要求设备管理主要包括设备的分配和回收。
合肥工业大学操作系统实验报告
合肥工业大学计算机与信息学院实验报告课程：计算机操作系统专业班级：计算机科学与技术2班学号：姓名：实验1 实验环境的使用一.实验目的1.熟悉操作系统集成实验环境OS Lab的基本使用方法。
2.练习编译、调试EOS操作系统内核以及EOS应用程序。
二.实验内容1．启动OS Lab2. 学习OS Lab的基本使用方法2.1新建Windows控制台应用程序项目2.2生成项目2.3执行项目2.4调试项目2.4.1 使用断点中断执行2.4.2单步调试2.4.3查看变量的值2.4.4调用堆栈3. EOS内核项目的生成和调试3.1新建EOS内核项目3.2生成项目3.3调试项目3.4查看软盘镜像文件中的内容3.5查看EOS SDK（Software Development Kit）文件夹4. EOS应用程序项目的生成和调试4.1新建EOS应用程序项目4.2生成项目4.3调试项目4.4查看软盘镜像文件中的内容4.5修改EOS应用程序项目名称5 退出OS Lab6 保存EOS内核项目三.实验结果本实验主要是熟悉EOS操作系统的基本操作，练习了：（1）新Windows控制台应用程序项，1.“文件”菜单中选择“新建”，然后单击“项目”。
2. 在“新建项目”对话框中，选择项目模板“控制台应用程序 (c)”。
3. 在“名称”中输入新项目使用的文件夹名称“oslab”。
4. 在“位置”中输入新项目保存在磁盘上的位置“C:\test”。
新建完毕后， OS Lab 会自动打开这个新建的项目。
（2）在“生成”菜单中选择“生成项目”。
结果如图（3）执行项目：选择“调试”菜单中的“开始执行”（4）调试项目:1. 右键点击“项目管理器”窗口中的“源文件”文件夹节点，在弹出的快捷菜单中选择“添加”中的“添加新文件”。
2. 在弹出的“添加新文件”对话框中选择“C 源文件”模板。
3. 在“名称”中输入文件名称“func”。
4. 点击“添加”按钮，添加并自动打开文件func.c，此时的“项目管理器”窗口会如图：（5）. 在 func.c 文件中添加函数：int Func (int n) { n = n + 1;return n; }（6）. 点击源代码编辑器上方的console.c标签，切换到console.c文件。
操作系统课程实验报告
操作系统课程实验报告一、实验目的操作系统是计算机系统中最为关键的软件之一，它负责管理计算机的硬件资源和软件资源，为用户提供一个良好的工作环境。
通过操作系统课程实验，旨在深入理解操作系统的基本原理和功能，提高对操作系统的实际操作能力和问题解决能力。
二、实验环境本次实验使用的操作系统为Windows 10 和Linux（Ubuntu 1804），开发工具包括 Visual Studio Code、gcc 编译器等。
三、实验内容（一）进程管理1、进程创建与终止在 Windows 系统中，使用 C+＋语言创建多个进程，并通过进程句柄控制进程的终止。
在 Linux 系统中，使用 fork(）系统调用创建子进程，并通过 exit(）函数终止进程。
2、进程同步与互斥使用信号量实现进程之间的同步与互斥。
在 Windows 中，利用CreateSemaphore(）和 WaitForSingleObject(）等函数进行操作；在Linux 中，通过 sem_init(）、sem_wait(）和 sem_post(）等函数实现。
（二）内存管理1、内存分配与释放在 Windows 中，使用 HeapAlloc(）和 HeapFree(）函数进行动态内存的分配与释放。
在 Linux 中，使用 malloc(）和 free(）函数完成相同的操作。
2、内存页面置换算法实现了几种常见的内存页面置换算法，如先进先出（FIFO）算法、最近最少使用（LRU）算法等，并比较它们的性能。
（三）文件系统管理1、文件创建与读写在 Windows 和 Linux 系统中，分别使用相应的 API 和系统调用创建文件，并进行读写操作。
2、目录操作实现了目录的创建、删除、遍历等功能。
四、实验步骤（一）进程管理实验1、进程创建与终止（1）在 Windows 系统中，编写 C+＋程序，使用 CreateProcess(）函数创建新进程，并通过 TerminateProcess(）函数终止指定进程。
《操作系统》课程综合性的实验报告
《操作系统》课程综合性的实验报告一、实验目的本次《操作系统》课程的综合性实验旨在通过实际操作和实践，深入理解操作系统的基本原理、功能和运行机制。
具体目标包括熟悉操作系统的进程管理、内存管理、文件系统管理以及设备管理等核心模块，提高对操作系统的整体认知和应用能力。
二、实验环境本次实验在以下环境中进行：操作系统：Windows 10 专业版开发工具：Visual Studio 2019编程语言：C+＋三、实验内容及步骤（一）进程管理实验1、创建多个进程使用 C+＋中的多线程库，创建多个进程，并观察它们的并发执行情况。
通过设置不同的优先级和资源需求，研究进程调度算法对系统性能的影响。
2、进程同步与互斥实现生产者消费者问题，使用信号量、互斥锁等机制来保证进程之间的同步和互斥。
观察在不同并发情况下，数据的正确性和系统的稳定性。
（二）内存管理实验1、内存分配与回收模拟内存分配算法，如首次适应算法、最佳适应算法和最坏适应算法。
通过随机生成内存请求，观察不同算法下内存的利用率和碎片情况。
2、虚拟内存管理研究虚拟内存的工作原理，通过设置页面大小和页表结构，观察页面置换算法（如 FIFO、LRU 等）对内存访问性能的影响。
（三）文件系统管理实验1、文件操作创建、读取、写入和删除文件，了解文件系统的基本操作和数据结构。
2、文件目录管理实现文件目录的创建、遍历和搜索功能，研究目录结构对文件访问效率的影响。
（四）设备管理实验1、设备驱动程序模拟编写简单的设备驱动程序，模拟设备的输入输出操作，如键盘输入和屏幕输出。
2、设备分配与调度研究设备分配算法，如先来先服务和优先级算法，观察设备的使用情况和系统的响应时间。
四、实验结果与分析（一）进程管理实验结果分析1、在创建多个进程的实验中，发现高优先级进程能够更快地获得CPU 资源，系统响应时间更短。
但过度提高某些进程的优先级可能导致其他进程饥饿。
2、对于进程同步与互斥问题，正确使用信号量和互斥锁能够有效地保证数据的一致性和系统的稳定性。
合肥工业大学操作系统课程设计 动态分区分配存储管理java版
课 程 设 计动态分区分配存储管理2010 年 12 月设计题目 学 号 专业班级 学生姓名指导教师合肥工业大学课程设计任务书第一章课程设计概述1.1 设计任务:动态分区分配存储管理1.2 设计要求建立描述内存分配状况的数据结构；建立描述进程的数据结构；使用两种方式产生进程：（a）自动产生，（b）手工输入；在屏幕上显示内存的分配状况、每个进程的执行情况；建立分区的分配与回收算法，支持紧凑算法；时间的流逝可用下面几种方法模拟：（a）按键盘，每按一次可认为过一个时间单位； (b) 响应WM_TIMER；将一批进程的执行情况存入磁盘文件，以后可以读出并重放；支持算法：首次适应算法、循环首次适应算法、最佳适应算法：最坏适应算法。
1.3 设计目的旨在让我们更好的了解动态分区管理方面的知识.第二章原理及算法描述2.1动态分区分配算法原理首次适应算法* 算法概述：分配内存时，从链首开始顺序查找，找到满足的空闲分区则划出空间分配，余下的空闲空间仍保留在空闲链表中* 实现方法：分配时从数组第一个元素开始比较，若符合条件则将该元素减去对应作业的值循环首次适应算法* 算法概述：由首次适应算法演变，只是每次分配改为由上一次找到的空闲分区开始查找* 实现方法：在首次适应算法的基础上增加一个值用于记录找到的空闲分区的位置最佳适应算法* 算法概述：每次为作业分配内存时，总是把能满足要求、又是最小的空闲分区分配给作业* 实现方法：我们决定每次分配先把空闲分区按从小到大的顺序排列，然后将第一个匹配分区分配给作业最坏适应算法* 算法概述：每次为作业分配内存时，总是挑选一个最大的空闲分区分割给作业使用* 实现方法：算法与最佳适应算法几乎相同，仅在排序时把空闲分区表按从大到小的顺序排列，所以未作详细注释回收分区当进程运行完毕释放内存时,系统根据回收区的首址,从空闲区链(表)中找到相应的插入点,此时可能出现以下四种情况之一;1)回收区与插入点的前一个空闲分区F1相邻接,此时应将回收区与插入点的前一分区合并,不必为回收区分配新表项,而只需修改其前一分区F1的大小.2)回收分区与插入点的后一空闲分区F2相邻接,此时也可将两分区合并,形成新的空闲分区,但用回收区的首址作为新空闲区的首址,大小为两者之和.3)回收区同时与插入点的前,后两个分区邻接,此时将三个分区合并,使用F1的表项和F1的首址,取消F2的表项,大小为三者之和.4)回收区既不与F1相邻接,又不与F2邻接.这时应为回收区单独建立一新表项,填写回收区的首址和大小,并根据其首址插入到空闲链中的适当位置.紧凑算法通过移动内存中的作业的位置,以把原来多个分散的小分区拼接成一个大分区的方法.第三章开发环境此程序是本人利用JAVA 语言在一种JCreator 的开发环境中实现的第四章重要算法和设计思路描述4.1 设计首次适应算法首先从内存分区的状态中找到空闲分区,若无空闲分区则不进行后面的运算,直接弹出对话框"内存中无空闲分区".把作业所需空间的大小与按始址大小,与各个空闲分区进行比较,如果某分区大小合适,把该分区一分为二,前部为已经分配出去的分区,后者为剩余的分区,然后对内存情况进行更新,每次分区小于作业，将指示不符合次数的n加一,如果不符合次数为空闲分区数组长度，说明找遍空闲分区都无符合项,最后对作业数组进行更新,把已运行的作业去除.4.2 设计循环首次适应算法同样根据内存分区的状态中找到空闲分区数组,令x指向上次找到空闲分区的下一个空闲分区,比较方法与首次适应算法相比，仅在此改为用x指示空闲分区在数组中的位置,每次查找空闲分区,都是从x后面那个分区开始查询, 如果某分区大小合适,把该分区一分为二,前部为已经分配出去的分区,后者为剩余的分区,然后对内存情况进行更新,每次分区小于作业，将指示不符合次数的n加一,到了数组末尾后再次进行循环回到数组头,一直寻找到上次所分配的位置,转为从首位开始查找后只比较到上一次找到的匹配分区，以保证循环可结束. 如果不符合次数为空闲分区数组长度，说明找遍空闲分区都无符合项,最后对作业数组进行更新,把已运行的作业去除.4.3 设计最佳适应算法和最坏适应算法最佳适应算法的实质就是对内存分区数组进行排序后,利用首次适应算法最坏适应算法的实质也是对内存分区数组排序后,进行首次适应算法,只不过它与最佳适应算法排序的方向刚好相反4.4 设计分区回收算法对内存分区状态进行查找,若回收区与插入点的前一个空闲分区F1相邻接,此时应将回收区与插入点的前一分区合并,不必为回收区分配新表项,而只需修改其前一分区F1的大小.若回收分区与插入点的后一空闲分区F2相邻接,此时也可将两分区合并,形成新的空闲分区,但用回收区的首址作为新空闲区的首址,大小为两者之和.若回收区同时与插入点的前,后两个分区邻接,此时将三个分区合并,使用F1的表项和F1的首址,取消F2的表项,大小为三者之和.若回收区既不与F1相邻接,又不与F2邻接.这时应为回收区单独建立一新表项,填写回收区的首址和大小,并根据其首址插入到空闲链中的适当位置4.5 设计紧凑算法同样对内存分区状态进行查找,若存在空闲分区,对分区数组,把已分配的数组的位置进行移动,使已分配的分区全部相邻,这样得到的最后剩下的一个大分区就是可以分配的分区啦.第五章程序实现---数据结构class memory{private int m1;//分区的序号private int m2;//分区的大小private int m3;//分区的起始地址private int m4;//是否已分配的标志} 这是定义的内存分区的结构class process{private int xuhao;//作业序号private int kongjian;//作业运行所需的空间} 这是定义的作业的结构第六章程序实现---程序清单import java.awt.event.*;import javax.swing.*;import java.awt.*;import java.io.*;import java.util.*;public class algorithm{private JFrame frame;private JTextPane memory;private JTextPane process;private memorydata md;private processdata pd;private int fitIndex=-1;private int select;private JTextField inputField;private JFrame inputFrame;public void go(){frame=new JFrame("动态分区");JPanel mainPanel=new JPanel();JPanel printPanel=new JPanel();printPanel.setLayout(new GridLayout(2, 1));memory=new JTextPane();process=new JTextPane();JScrollPane ScrollerM=new JScrollPane(memory);ScrollerM.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);ScrollerM.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);JScrollPane ScrollerP=new JScrollPane(process);ScrollerP.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);ScrollerP.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);printPanel.add(ScrollerM);printPanel.add(ScrollerP);JMenuBar menuBar=new JMenuBar();JMenu fileMenu=new JMenu("文件");JMenu dataMenu=new JMenu("数据");JMenu FPMenu=new JMenu("分配");JMenu HSMenu=new JMenu("回收");JMenu JCMenu=new JMenu("紧凑");JMenuItem FileItemM=new JMenuItem("输出内存数据");JMenuItem FileItemP=new JMenuItem("输出作业数据");JMenuItem MemoryItem=new JMenuItem("读入内存数据");JMenuItem ProcessItem=new JMenuItem("读入作业数据");JMenuItem randomdataItemM=new JMenuItem("随机内存数据");JMenuItem randomdataItemP=new JMenuItem("随机作业数据");JMenuItem fenpeiItem=new JMenuItem("分配");JMenuItem huishouItem=new JMenuItem("回收");JMenuItem jinchouItem=new JMenuItem("紧凑");FileItemM.addActionListener(new OutputMemoryListener());FileItemP.addActionListener(new OutputProcessListener());MemoryItem.addActionListener(new InputMemoryListener());ProcessItem.addActionListener(new InputProcessListener());randomdataItemM.addActionListener(new randomMemoryListener());randomdataItemP.addActionListener(new randomProcessListener());fenpeiItem.addActionListener(new fenpeiListener());huishouItem.addActionListener(new huishouListener());jinchouItem.addActionListener(new jinchouListener());fileMenu.add(FileItemM);fileMenu.add(FileItemP);dataMenu.add(MemoryItem);dataMenu.add(ProcessItem);dataMenu.add(randomdataItemM);dataMenu.add(randomdataItemP);FPMenu.add(fenpeiItem);HSMenu.add(huishouItem);JCMenu.add(jinchouItem);menuBar.add(fileMenu);menuBar.add(dataMenu);menuBar.add(FPMenu);menuBar.add(HSMenu);menuBar.add(JCMenu);frame.setJMenuBar(menuBar);frame.getContentPane().add(BorderLayout.CENTER,printPanel);frame.setSize(600,500);frame.setVisible(true);}public class randomMemoryListener implements ActionListener{public void actionPerformed(ActionEvent ac){md=new memorydata();print.printM(md.m,memory);}}public class randomProcessListener implements ActionListener{ public void actionPerformed(ActionEvent ac){inputFrame=new JFrame();JPanel inputPanel=new JPanel();JButton sendButton=new JButton("确认");sendButton.addActionListener(new SendButtonListener3());inputField=new JTextField(10);inputPanel.add(inputField);inputPanel.add(sendButton);inputFrame.getContentPane().add(BorderLayout.CENTER,inputPanel);inputFrame.setSize(200,100);inputFrame.setLocationRelativeTo(null);inputFrame.setVisible(true);}}public class OutputMemoryListener implements ActionListener{ public void actionPerformed(ActionEvent ac){JFileChooser fileOpen=new JFileChooser();fileOpen.showOpenDialog(frame);MyFile.outputMemorydata(md,fileOpen.getSelectedFile());}}public class OutputProcessListener implements ActionListener{ public void actionPerformed(ActionEvent ac){JFileChooser fileOpen=new JFileChooser();fileOpen.showOpenDialog(frame);MyFile.outputProcessdata(pd,fileOpen.getSelectedFile());}}public class InputMemoryListener implements ActionListener{ public void actionPerformed(ActionEvent ac){JFileChooser fileOpen=new JFileChooser();fileOpen.showOpenDialog(frame);md=new memorydata(MyFile.inputMemorydata(fileOpen.getSelectedFile()));print.printM(md.m,memory);}}public class InputProcessListener implements ActionListener{public void actionPerformed(ActionEvent ac){JFileChooser fileOpen=new JFileChooser();fileOpen.showOpenDialog(frame);pd=new processdata(MyFile.inputProcessdata(fileOpen.getSelectedFile()));print.printP(pd.p,process);}}public class fenpeiListener implements ActionListener{public void actionPerformed(ActionEvent ac){fenpeiProcess();}}public class huishouListener implements ActionListener{public void actionPerformed(ActionEvent ac){if(!memorydata.huishou(md.m)){JOptionPane.showMessageDialog(frame, "内存中无可回收分区");return;}waitinput();}}public class jinchouListener implements ActionListener{public void actionPerformed(ActionEvent ac){if(!memorydata.kongxian(md.m)){JOptionPane.showMessageDialog(frame, "内存中分区全被分配,无空闲分区");return;}jincou();}}public class SendButtonListener3 implements ActionListener{public void actionPerformed(ActionEvent ev){int processmount=Integer.parseInt(inputField.getText());pd=new processdata(processmount);print.printP(pd.p,process);}}public class SendButtonListener2 implements ActionListener{public void actionPerformed(ActionEvent ev){int selectmemory=Integer.parseInt(inputField.getText());recycle(selectmemory);}}public class SendButtonListener implements ActionListener{public void actionPerformed(ActionEvent ev){int selectProcess=Integer.parseInt(inputField.getText());if(select!=1&&select!=2&&select!=3&&select!=4){JOptionPane.showMessageDialog(inputFrame, "请选择一种分配方法");return;}if(selectProcess>pd.p.length){JOptionPane.showMessageDialog(inputFrame, "输入错误");return;}if(select==1){FirstFit(selectProcess);}else if(select==2){fitIndex=NextFit(selectProcess,fitIndex);}else if(select==3){BestFit(selectProcess);}else if(select==4){WorstFit(selectProcess);}}}public class b1ButtonListener implements ActionListener{public void actionPerformed(ActionEvent ev){select=1;}}public class b2ButtonListener implements ActionListener{ public void actionPerformed(ActionEvent ev){select=2;}}public class b3ButtonListener implements ActionListener{ public void actionPerformed(ActionEvent ev){select=3;}}public class b4ButtonListener implements ActionListener{ public void actionPerformed(ActionEvent ev){select=4;}}private void waitinput(){inputFrame=new JFrame();JPanel inputPanel=new JPanel();JButton sendButton=new JButton("确认");sendButton.addActionListener(new SendButtonListener2());inputField=new JTextField(10);inputPanel.add(inputField);inputPanel.add(sendButton);inputFrame.getContentPane().add(BorderLayout.CENTER,inputPanel);inputFrame.setSize(200,100);inputFrame.setLocationRelativeTo(null);inputFrame.setVisible(true);}private void fenpeiProcess(){inputFrame=new JFrame();JRadioButton b1 = new JRadioButton();JRadioButton b2 = new JRadioButton();JRadioButton b3 = new JRadioButton();JRadioButton b4 = new JRadioButton();ButtonGroup group = new ButtonGroup();JPanel intro = new JPanel();JLabel introJl = new JLabel();intro.add(introJl);introJl.setText(" 分配算法选择 ");inputFrame.add(intro);b1.setText("1、首次适应算法");b2.setText("2、循环首次适应算法");b3.setText("3、最佳适应算法");b4.setText("4、最坏适应算法");b1.addActionListener(new b1ButtonListener());b2.addActionListener(new b2ButtonListener());b3.addActionListener(new b3ButtonListener());b4.addActionListener(new b4ButtonListener());group.add(b1);group.add(b2);group.add(b3);group.add(b4);// p为第二个JPanelJPanel p = new JPanel();// 设置第二个JPanel上的jl1 JLabel初始显示信息JLabel jl1 = new JLabel();jl1.setText("输入待分配的作业序号");// 添加该JLabel到p上p.add(jl1);// 添加该JPanelinputFrame.add(p);// p1为第三个Panel，此JPanel由于要显示5个算法的单选键，所以设置为5行的GridLayout布局JPanel p1 = new JPanel();p1.setLayout(new GridLayout(4, 1));p1.add(b1);p1.add(b2);p1.add(b3);p1.add(b4);inputFrame.add(p1);JPanel inputPanel=new JPanel();inputField=new JTextField(5);inputPanel.add(inputField);JButton sendButton=new JButton("确认");sendButton.addActionListener(new SendButtonListener());inputPanel.add(sendButton);inputFrame.add(inputPanel);inputFrame.setLayout(new FlowLayout());// 设置窗口大小，inputFrame.setSize(400, 220);// 大小不可更改inputFrame.setLocation(300, 400);// 显示inputFrame.setVisible(true);// 设置窗口右上角的关闭按钮事件为结束程序inputFrame.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);}/*** 首次适应算法* 算法概述：分配内存时，从链首开始顺序查找，找到满足的空闲分区则划出空间分配，余下的空闲空间仍保留在空闲链表中* 实现方法：分配时从数组第一个元素开始比较，若符合条件则将该元素减去对应作业的值**/private void FirstFit(int selectProcess){print.printM(md.m,memory);//显示当前内存分区状况memory[] free=memorydata.Free(md.m);//对当前内存分区获取空闲分区的信息print.printF(free,memory);//显示内存空闲分区的状况print.insert("首次适应算法",memory);int xuhao=selectProcess-1;if (free.length == 0){// 若无空闲分区则不进行后面的运算JOptionPane.showMessageDialog(frame, "内存中无空闲分区");}else{int n=0;//指示分区与作业不符合的次数for(int j=0;j<free.length;j++){//与各个空闲分区进行比较print.insert("进程号"+pd.p[xuhao].getxuhao()+" 所需分区大小为["+pd.p[xuhao].getkongjian()+"] 与分区号为"+free[j].getm1()+"的空闲分区 ["+free[j].getm2()+"] 比较",memory);if(pd.p[xuhao].getkongjian()<free[j].getm2()){//分区大于作业print.insert("符合，分配",memory);memory[] nb=new memory[md.m.length+1];int ni=free[j].getm1();if(free[j].getm1()==1){//如果该空闲分区是内存表头//把该分区一分为二,前部为已经分配出去的分区,后者为剩余的分区nb[0]=new memory(1,pd.p[xuhao].getkongjian(),0,1);nb[1]=newmemory(2,free[j].getm2()-pd.p[xuhao].getkongjian(),pd.p[xuhao].getkongjian(),0);//把nb构造成经过分配后的内存分区数组for(int k=2;k<nb.length;k++)nb[k]=newmemory(nb[k-1].getm1()+1,md.m[k-1].getm2(),nb[k-1].getm2()+nb[k-1].getm3(),md.m[k-1].getm4());md.m=nb;print.printM(md.m,memory);free= memorydata.Free(md.m);print.printF(free,memory);}else{//如果该空闲分区不是内存表头for(int k=0;k<ni;k++)nb[k]=newmemory(md.m[k].getm1(),md.m[k].getm2(),md.m[k].getm3(),md.m[k].getm4());//把该分区一分为二,前部为已经分配出去的分区,后者为剩余的分区nb[ni-1].setm2(pd.p[0].getkongjian());nb[ni-1].setm4(1);//设置标识此分区已分配nb[ni]=newmemory(nb[ni-1].getm1()+1,free[j].getm2()-pd.p[xuhao].getkongjian(),nb[ni-1].getm2()+nb[ni-1].get m3(),0);for(int k=ni+1;k<nb.length;k++){nb[k]=newmemory(nb[k-1].getm1()+1,md.m[k-1].getm2(),nb[k-1].getm2()+nb[k-1].getm3(),md.m[k-1].getm4());}md.m=nb;print.printM(md.m,memory);free = memorydata.Free(md.m);print.printF(free,memory);}break;}else{if(pd.p[xuhao].getkongjian()==free[j].getm2()){//分区等于作业print.insert(" 符合，分配",memory);md.m[free[j].getm1()-1].setm4(1);//把此分区标志位已分配print.printM(md.m,memory);free= memorydata.Free(md.m);print.printF(free,memory);break;}else{//分区小于作业，将指示不符合次数的n加一n++;}}if(n==free.length){//如果不符合次数为空闲分区数组长度，说明找遍空闲分区都无符合项JOptionPane.showMessageDialog(frame, "无符合分区");//print.insert(" 无符合分区",memory);return;}}//对作业数组进行更新,把已运行的作业去除processdata temp=new processdata(pd.p.length-1);for(int i=0;i<xuhao;i++)temp.p[i].setkongjian(pd.p[i].getkongjian());for(int i=xuhao;i<temp.p.length;i++){int te=pd.p[i+1].getkongjian();temp.p[i].setkongjian(te);}pd.p=temp.p;print.printP(pd.p,process);}}/*** 循环首次适应算法* 算法概述：由首次适应算法演变，只是每次分配改为由上一次找到的空闲分区开始查找* 实现方法：在首次适应算法的基础上增加一个值用于记录找到的空闲分区的位置**///此函数返回记录找到的空闲分区的位置private int NextFit(int input,int fitIndex){print.printM(md.m,memory);memory[] free=memorydata.Free(md.m);//构造空闲分区print.printF(free,memory);print.insert("循环首次适应算法",memory);int xuhao=input-1;if(free.length==0){// 若无空闲分区则不进行后面的运算JOptionPane.showMessageDialog(frame, "内存中无空闲分区");//print.insert("内存中无空闲区",memory);return fitIndex;}else{int n = 0;//指示分区与作业不符合的次数print.insert(" - - - - - - - - - - - - - - - - - - - - - - - - -",memory);int x = fitIndex + 1;// 令x指向上次找到空闲分区的下一个空闲分区// 比较方法与首次适应算法相比，仅在此改为用x指示空闲分区在数组中的位置while (x <md.m.length){if (md.m[x].getm4() != 1){print.insert(" 进程号"+pd.p[xuhao].getxuhao()+" 所需分区["+pd.p[xuhao].getkongjian()+"] 与分区号为"+md.m[x].getm1()+"的空闲分区 ["+md.m[x].getm2()+"] 比较，",memory);if (pd.p[xuhao].getkongjian()<md.m[x].getm2()){// 假如作业小于空闲分区，则可分配print.insert("符合，分配",memory);memory[] nb =new memory[md.m.length + 1];for (int k = 0; k < x; k++){nb[k] =md.m[k];}// 数组对应元素减去作业大小，即表示分配后的大小int size = md.m[x].getm2()-pd.p[xuhao].getkongjian();nb[x] = md.m[x];nb[x].setm2(pd.p[xuhao].getkongjian());nb[x].setm4(1); //标志此分区为已分配nb[x + 1]=new memory(nb[x].getm1() + 1,size,nb[x].getm2()+ nb[x].getm3(), 0);//创建分配后余下的分区for(int k = x + 2; k < nb.length; k++){nb[k] = md.m[k - 1];nb[k].setm1(nb[k].getm1()+1);}md.m=nb;fitIndex = x;//更新此次找到的空闲分区的位置print.printM(md.m,memory);free=memorydata.Free(md.m);print.printF(free,memory);// 得到分配，结束此作业比较循环break;}else{if(pd.p[xuhao].getkongjian()==md.m[x].getm2()){//分区等于作业print.insert(" 符合，分配",memory);md.m[md.m[x].getm1()-1].setm4(1);//标志此分区为已分配print.printM(md.m,memory);free= memorydata.Free(md.m);print.printF(free,memory);fitIndex = x;//更新此次找到的空闲分区的位置break;}else{n++;// 每不符一次把n加1print.insert("不符，往下找",memory);}}}x++;// 利用x++将元素指向下一位}//到了数组末尾后再次进行循环回到数组头if (x >= md.m.length){x = 0;while (x <= fitIndex) //一直寻找到上次所分配的位置{if (md.m[x].getm4()!= 1){// 转为从首位开始查找后只比较到上一次找到的匹配分区，以保证循环可结束print.insert("进程号"+pd.p[xuhao].getxuhao()+" 所需分区["+pd.p[xuhao].getkongjian()+"] 与分区号为"+md.m[x].getm1()+"的空闲分区 ["+md.m[x].getm2()+"] 比较，",memory);if (pd.p[xuhao].getkongjian()<md.m[x].getm2()){// 假如作业小于空闲分区，则可分配print.insert("符合，分配",memory);memory[] nb =new memory[md.m.length + 1];for (int k = 0; k < x; k++){nb[k] =md.m[k];}// 数组对应元素减去作业大小，即表示分配后的大小int size = md.m[x].getm2()-pd.p[xuhao].getkongjian();nb[x] =md.m[x];nb[x].setm2(pd.p[xuhao].getkongjian());nb[x].setm4(1);nb[x + 1] = new memory(nb[x].getm1() + 1, size,nb[x].getm2()+ nb[x].getm3(), 0);for (int k = x + 2; k < nb.length; k++){nb[k] =md.m[k - 1];nb[k].setm1(nb[k].getm1()+1);}md.m=nb;fitIndex = x;print.printM(md.m,memory);free = memorydata.Free(md.m);print.printM(free,memory); // 得到分配，结束此作业比较循环break;}else{if(pd.p[xuhao].getkongjian()==md.m[x].getm2()){//分区等于作业print.insert(" 符合，分配",memory);md.m[md.m[x].getm1()-1].setm4(1);print.printM(md.m,memory);free = memorydata.Free(md.m);print.printM(free,memory);fitIndex = x;break;}else{n++;// 每不符一次把n加1print.insert("不符，往下找",memory);}}}x++; // 利用x++将元素指向下一位}}if (n == free.length){// 假如n等于空闲数组的长度，则说明找遍空闲分区都无符合项JOptionPane.showMessageDialog(frame, "未找到符合的空闲分区");//print.insert("",memory);//print.insert(" 未找到符合的空闲分区",memory);return fitIndex;}else{//对作业数组进行更新processdata temp=new processdata(pd.p.length-1);for(int i=0;i<xuhao;i++)temp.p[i].setkongjian(pd.p[i].getkongjian());for(int i=xuhao;i<temp.p.length;i++){int te=pd.p[i+1].getkongjian();temp.p[i].setkongjian(te);}pd.p=temp.p;print.printP(pd.p,process);System.out.println();return fitIndex;}}}/** 最佳适应算法* 算法概述：每次为作业分配内存时，总是把能满足要求、又是最小的空闲分区分配给作业* 实现方法：我们决定每次分配先把空闲分区按从小到大的顺序排列，然后将第一个匹配分区分配给作业 **///最佳适应算法的实质就是对内存分区数组进行排序后,利用首次适应算法private void BestFit(int input){print.printP(pd.p,process);print.printM(md.m,memory);memory[] free=memorydata.Free(md.m);memorydata.up(free);//对内存数组进行排序print.printF(free,memory);//后面的比较过程与首次适应算法一样print.insert("最佳适应算法",memory);int xuhao=input-1;if (free.length == 0){// 若无空闲分区则不进行后面的运算JOptionPane.showMessageDialog(frame, "内存中无空闲分区");//print.insert("内存中无空闲分区",memory);}else{int n=0;for(int j=0;j<free.length;j++){//与各个空闲分区进行比较print.insert("进程号"+pd.p[xuhao].getxuhao()+" 所需分区大小为["+pd.p[xuhao].getkongjian()+"] 与分区号为"+free[j].getm1()+"的空闲分区 ["+free[j].getm2()+"] 比较",memory);if(pd.p[xuhao].getkongjian()<free[j].getm2()){//分区大于作业print.insert("符合，分配",memory);memory[] nb=new memory[md.m.length+1];int ni=free[j].getm1();if(free[j].getm1()==1){//如果该空闲分区是内存表头nb[0]=new memory(1,pd.p[xuhao].getkongjian(),0,1);nb[1]=newmemory(2,free[j].getm2()-pd.p[xuhao].getkongjian(),pd.p[xuhao].getkongjian(),0);for(int k=2;k<nb.length;k++)nb[k]=newmemory(nb[k-1].getm1()+1,md.m[k-1].getm2(),nb[k-1].getm2()+nb[k-1].getm3(),md.m[k-1].getm4());md.m=nb;print.printM(md.m,memory);free= memorydata.Free(md.m);memorydata.up(free);print.printF(free,memory);}else{//如果该空闲分区不是内存表头for(int k=0;k<ni;k++)nb[k]=newmemory(md.m[k].getm1(),md.m[k].getm2(),md.m[k].getm3(),md.m[k].getm4());nb[ni-1].setm2(pd.p[0].getkongjian());nb[ni-1].setm4(1);nb[ni]=newmemory(nb[ni-1].getm1()+1,free[j].getm2()-pd.p[xuhao].getkongjian(),nb[ni-1].getm2()+nb[ni-1].get m3(),0);for(int k=ni+1;k<nb.length;k++){nb[k]=newmemory(nb[k-1].getm1()+1,md.m[k-1].getm2(),nb[k-1].getm2()+nb[k-1].getm3(),md.m[k-1].getm4());}md.m=nb;print.printM(md.m,memory);free = memorydata.Free(md.m);memorydata.up(free);print.printF(free,memory);}break;}else{if(pd.p[xuhao].getkongjian()==free[j].getm2()){//分区等于作业System.out.println(" 符合，分配");md.m[free[j].getm1()-1].setm4(1);print.printM(md.m,memory);free = memorydata.Free(md.m);memorydata.up(free);print.printF(free,memory);break;}else{//分区小于作业，将指示不符合次数的n加一n++;}}if(n==free.length){//如果不符合次数为空闲分区数组长度，说明找遍空闲分区都无符合项JOptionPane.showMessageDialog(frame, "无符合分区");//print.insert(" 无符合分区",memory);return;}}processdata temp=new processdata(pd.p.length-1);for(int i=0;i<xuhao;i++)temp.p[i].setkongjian(pd.p[i].getkongjian());for(int i=xuhao;i<temp.p.length;i++){int te=pd.p[i+1].getkongjian();temp.p[i].setkongjian(te);}pd.p=temp.p;print.printP(pd.p,process);}}/** 最坏适应算法* 算法概述：每次为作业分配内存时，总是挑选一个最大的空闲分区分割给作业使用* 实现方法：算法与最佳适应算法几乎相同，仅在排序时把空闲分区表按从大到小的顺序排列，所以未作详细注释**///最坏适应算法的实质也是对内存分区数组排序后,进行首次适应算法,只不过它与最佳适应算法排序的方向刚好相反private void WorstFit(int input){print.printP(pd.p,process);print.printM(md.m,memory);memory[] free=memorydata.Free(md.m);memorydata.down(free);//对内存数组进行排序print.printF(free,memory);//后面的比较过程与首次适应算法一样print.insert("最坏适应算法",memory);int xuhao=input-1;if (free.length == 0){// 若无空闲分区则不进行后面的运算JOptionPane.showMessageDialog(frame, "内存中无空闲分区");//print.insert("内存中无空闲分区",memory);}else{int n=0;for(int j=0;j<free.length;j++){//与各个空闲分区进行比较print.insert("进程号"+pd.p[xuhao].getxuhao()+" 所需分区大小为["+pd.p[xuhao].getkongjian()+"] 与分区号为"+free[j].getm1()+"的空闲分区 ["+free[j].getm2()+"] 比较",memory);if(pd.p[xuhao].getkongjian()<free[j].getm2()){//分区大于作业print.insert("符合，分配",memory);memory[] nb=new memory[md.m.length+1];int ni=free[j].getm1();if(free[j].getm1()==1){//如果该空闲分区是内存表头nb[0]=new memory(1,pd.p[xuhao].getkongjian(),0,1);nb[1]=newmemory(2,free[j].getm2()-pd.p[xuhao].getkongjian(),pd.p[xuhao].getkongjian(),0);for(int k=2;k<nb.length;k++)nb[k]=newmemory(nb[k-1].getm1()+1,md.m[k-1].getm2(),nb[k-1].getm2()+nb[k-1].getm3(),md.m[k-1].getm4());md.m=nb;print.printM(md.m,memory);free= memorydata.Free(md.m);memorydata.down(free);print.printF(free,memory);}else{//如果该空闲分区不是内存表头for(int k=0;k<ni;k++)nb[k]=newmemory(md.m[k].getm1(),md.m[k].getm2(),md.m[k].getm3(),md.m[k].getm4());nb[ni-1].setm2(pd.p[0].getkongjian());nb[ni-1].setm4(1);nb[ni]=newmemory(nb[ni-1].getm1()+1,free[j].getm2()-pd.p[xuhao].getkongjian(),nb[ni-1].getm2()+nb[ni-1].get m3(),0);for(int k=ni+1;k<nb.length;k++){nb[k]=newmemory(nb[k-1].getm1()+1,md.m[k-1].getm2(),nb[k-1].getm2()+nb[k-1].getm3(),md.m[k-1].getm4());}md.m=nb;print.printM(md.m,memory);free = memorydata.Free(md.m);memorydata.down(free);print.printF(free,memory);}break;}else{if(pd.p[xuhao].getkongjian()==free[j].getm2()){//分区等于作业System.out.println(" 符合，分配");md.m[free[j].getm1()-1].setm4(1);print.printM(md.m,memory);free = memorydata.Free(md.m);memorydata.down(free);print.printF(free,memory);break;}else{//分区小于作业，将指示不符合次数的n加一n++;}}if(n==free.length){//如果不符合次数为空闲分区数组长度，说明找遍空闲分区都无符合项JOptionPane.showMessageDialog(frame, "无符合分区");//print.insert(" 无符合分区",memory);return;}}processdata temp=new processdata(pd.p.length-1);for(int i=0;i<xuhao;i++)temp.p[i].setkongjian(pd.p[i].getkongjian());for(int i=xuhao;i<temp.p.length;i++){int te=pd.p[i+1].getkongjian();temp.p[i].setkongjian(te);}pd.p=temp.p;print.printP(pd.p,process);}}//回收已分配的分区private void recycle(int a){memory[] nm;if(md.m[a-1].getm4()==0){JOptionPane.showMessageDialog(frame, "该分区为空闲");//print.insert("该分区为空闲",memory);return;}if (a == 1){// 假如是内存表头if (md.m[a].getm4() == 0){// 假如第二块是空闲分区，则与第二块合并，起址为该回收块起址，其它各项仅修改序号nm =new memory[md.m.length-1];nm[a - 1] = md.m[a - 1];nm[a - 1].setm4(0);nm[a - 1].setm2(nm[a - 1].getm2()+md.m[1].getm2());for (int i = 1; i < nm.length; i++){nm[i] = md.m[i + 1];nm[i].setm1(nm[i].getm1()-1);}}else{// 假如第二块不是空闲分区，则单独建立一个空闲分区md.m[0].setm4(0);nm = md.m;}}else{if (a == md.m.length){// 假如是内存表末if (md.m[a - 2].getm4()== 0){// 假如倒数第二块是空闲分区，则与倒数第二块合并，起址为该回收块起址，其它各项仅修改序号nm =new memory[md.m.length - 1];nm[a - 2] = md.m[a - 2];nm[a - 2].setm4(0);nm[a - 2].setm2(nm[a - 2].getm2()+md.m[a - 1].getm2());for (int i = 0; i < nm.length - 1; i++){nm[i] = md.m[i];}}else{// 假如倒数第二块不是空闲分区，则单独建立一个空闲分区md.m[a - 1].setm4(0);nm =md.m;}}else{// 假如不是第一块也不是最后一块，则有四种情况if (md.m[a - 2].getm4() == 0 && md.m[a].getm4() == 0){// 夹在两块空闲分区中间// 建立少两个单位的新数组，存储到该回收区的前两位nm = new memory[md.m.length - 2];for (int i = 0; i < a - 2; i++){nm[i] = md.m[i];}// 将回收区前一位的大小改为这三个分区的和，然后将后面的元素前移两位，序号也相应减去2nm[a - 2] =md.m[a - 2];nm[a - 2].setm2(nm[a - 2].getm2()+md.m[a - 1].getm2() + md.m[a].getm2());for (int i = a - 1; i < nm.length; i++){nm[i] =md.m[i + 2];nm[i].setm1(nm[i].getm1()-2);}}else{if (md.m[a - 2].getm4() == 0){// 前一块是空闲分区// 建立少一个单位的新数组用于存储，将回收区的大小加至前一块空闲分区，后面的元素依次前移一位，序号减一nm = new memory[md.m.length - 1];for (int i = 0; i < a - 2; i++){nm[i] = md.m[i];}nm[a - 2] = md.m[a - 2];nm[a - 2].setm2(nm[a - 2].getm2()+md.m[a - 1].getm2());for (int i = a - 1; i < nm.length; i++){nm[i] = md.m[i + 1];nm[i].setm1(nm[i].getm1()-1);}}else{if (md.m[a].getm4() == 0){// 后一块是空闲分区nm = new memory[md.m.length - 1];// 前面元素不变，将后面的空闲分区大小加至该分区，然后把后面的元素前移一位，序号减一for (int i = 0; i < a - 1; i++){nm[i] = md.m[i];}nm[a - 1] = md.m[a - 1];nm[a - 1].setm4(0);nm[a - 1].setm2(nm[a - 1].getm2()+md.m[a].getm2());for ( int i = a; i < nm.length; i++){nm[i] =md.m[i + 1];nm[i].setm1(nm[i].getm1()-1);}}else{// 前后都是已分配的分区，直接修改分配状态md.m[a - 1].setm4(0);nm = md.m;}}}}}md.m=nm;// 将代表内存现在状态的nm数组返回print.printM(md.m,memory);}//对内存实行紧凑算法private void jincou(){memory[] temp=new memory[md.m.length];memory[] result;int index=0,value=0;//分别把内存中已经被分配的分区移动位置,使他们相邻for(int i=0;i<md.m.length;i++){if(md.m[i].getm4()==1){temp[index++]=new memory(index,md.m[i].getm2(),value,1);value+=md.m[i].getm2();}}if(value!=512){temp[index++]=new memory(index,512-value,value,0);//把最后剩下的内存空间建立一个完整的空闲分区}result=new memory[index];。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
一.设计题目
第9题：进程死锁的检测：绘制资源分配图
要求：
1)建立资源分配图的数据结构描述；
2)建立绘制资源分配图的历程，包括结点和有向边；
3)可以删除、添加节点或有向边。
4)可以鼠标在串口的任意位置指点，确定结点或者有向边的位置；
5)可以拖动现有结点的位置，使之相关的结点移动
6)可以存入文件和从文件中读取。
二.设计原理及算法描述
UNIX命令:
ls [选项]
列出文件信息(默认为当前目录)
ls无参显示一个目录中的文件和子目录
ls -l每行仅显示一个目录或名称
ls --help 显示此帮助信息并离开
mkdir目录
若目录不存在则创建目录
mkdir --help显示此帮助信息并离开
rmdir目录
若目录没有数据则删除目录
rmdir --help显示此帮助信息并离开
cp来源文件目的文件
将来源文件复制到目的文件
cp --help显示此帮助信息并离开
cat文件
或：cat 文件1 >> 文件2
显示文件内容或连接两个文件，并将结果输出到显示屏上
cat文件将文件的内容输出到显示屏上
cat 文件1 >> 文件2将文件1连接到文件2的结尾，并输出到显示屏上
cat --help 显示此帮助信息并离开
more文件
使文件能逐行(回车键)或逐页(空格键)显示并显示当前文件所占总文件的百分比
more --help显示此帮助信息并离开
mv文件1 文件2
或：mv 文件目录重命名或移动文件
mv 文件1 文件2将文件1名字改为文件2的名字
mv 文件目录将指定文件移动到指定目录下
mv --help显示此帮助信息并离开
sort文件
将文本文件内容加以排序
sort --help显示此帮助信息并离开
按照每个命令的功能编写一个实现函数。
通过c++字符串操作从输入流获得指令以及参数，通过对指令以及参数的判别调用对应指令的函数，实现对windows内文件的各项操作。
三.开发环境
硬件环境：
个人PC机
软件环境：
Microsoft Windows XP
Microsoft Visual C++ 6.0
四.重要算法和设计思路描述
命令以及参数的获取：由于命令加参数最多能有四部分，所以申请4个字符串数组。
并且将首地址都初始化为NULL，在后面的函数中用作判断输入参数的个数。
根据输入流中的空格来分割命令和参数
以及参数和参数。
每检测到一个空格，即将前面的输入字符加上字符串结束符一起存入申请到的字符串数组中。
命令以及参数的判断：strcmp。
参数个数的判断：观察后三个字符串数组首地址是否为NULL。
利用以下一些API函数实现unix命令要求实现的功能，对windows 里的文件进行操作。
BOOL WINAPI SetCurrentDirectory( __in LPCTSTR lpPathName); 切换当前进程的当前工作目录。
HANDLE FindFirstFile( LPCTSTR lpFileName, // file name LPWIN32_FIND_DATA lpFindFileData // data buffer ); 该函数到一个文件夹(包括子文件夹)去搜索指定文件如果要使用附加属性去搜索文件的话可以使用FindFirstFileEx函数
DWORD GetCurrentDirectory(
DWORD nBufferLength, // size of directory buffer
LPTSTR lpBuffer // directory buffer
); 获取当前进程的当前目录
BOOL CreateDirectory(LPCTSTR lpPathName,
LPSECURITY_ATTRIBUTES lpSecurityAttributes ); 创建一个新目录
HANDLE CreateFile(
LPCTSTR lpFileName, //指向文件名的指针
DWORD dwDesiredAccess, //访问模式（写/读）
DWORD dwShareMode, //共享模式
LPSECURITY_ATTRIBUTES lpSecurityAttributes, //指向安全属性的指针
DWORD dwCreationDisposition, //如何创建
DWORD dwFlagsAndAttributes, //文件属性
HANDLE hTemplateFile //用于复制文件句柄
); 这是一个全功能的例程，可打开和创建文件、管道、邮槽、通信服务、设备以及控制台缓冲区
五.程序实现——数据结构
doc.h中用#define 宏定义了各命令的帮助文档。
function.h中用API函数和一些简单的字符串操作实现了每个命令要求的功能。
cmd.cpp中定义了获取命令及参数的方法，用if…else…结构对命令及参数进行判断并调用对应的函数。
六.程序实现——程序清单
见程序包
七.课程设计总结
经过一个星期的课程设计，经历的困难一语难尽。
整个课程设计期间我们失落过，也曾一度热情高涨。
从开始时满富盛激情到最后汗水背后的复杂心情，点点滴滴无不令我们回味无长。
生活就是这样，汗水预示着结果也见证着收获。
劳动是人类生存生活永恒不变的话题。
通过实习，我才真正领略到“艰苦奋斗”这一词的真正含义。
我想说，设计确实有些辛苦，但苦中也有乐，在如今浮躁的生活中，很少有机会能静下心来做一个设计，但我们可以，一个团队的任务，一起的工作可以让我们有说有笑，相互帮助，配合默契。
在一次次的试验中，我们收获的不仅是程序设计的技能更加是耐心和经验，还有做课程设计的心态。
一行代码的错误直接影响着最后的结果，这就让我们每一个语句都编写的仔细。
最让人苦恼的是完全按设计原理的编程，执行结果却依然不对，这时候，我们需要分析错误的原因，逐步排查。
最终验收成功的时候我们由衷的高兴。
当然，这与老师的指导和示范十分不开的，正是有了老师耐心的指导和对于错误原因分析的帮助，才有了我们的对操作系统的接口的新认识。
对我而言，知识上的收获重要，精神上的丰收更加可喜。
挫折是一份财富，经历是一份拥有。
这次实习必将成为我人生旅途上一个非常美好的回忆！
再次感谢老师的教学与指导，老师您辛苦了。
八.参考文献
[1].汤子瀛，哲凤屏，汤晓丹.计算机操作系统[M].西安:西安电子科技大学出版社，2001
[2].龙晋元.UNIX操作系统教程[M].西安:西北电讯工程学院出版社，1995
[3].王刚.LINUX命令、编辑器与Shell编程[M].北京:清华大学出版社，2012
[4].罗宇，褚瑞.操作系统课程设计[M].北京:机械工业出版社，2005。