操作系统实验--进程调度和内存管理---java语言版本

一、实验目的通过本次实验，加深对进程调度原理和算法的理解，掌握进程调度程序的设计与实现方法。

实验要求我们使用高级编程语言编写一个简单的进程调度程序，实现不同调度算法的模拟，并通过实验验证算法的性能。

二、实验环境1. 操作系统：Windows 102. 编程语言：Java3. 开发工具：IntelliJ IDEA三、实验内容本次实验主要实现以下调度算法：1. 先来先服务（FCFS）2. 最短作业优先（SJF）3. 时间片轮转（RR）四、实验步骤1. 定义进程类（Process）：```javapublic class Process {private String processName; // 进程名称private int arrivalTime; // 到达时间private int burstTime; // 运行时间private int waitingTime; // 等待时间private int turnaroundTime; // 周转时间// 构造函数public Process(String processName, int arrivalTime, int burstTime) {this.processName = processName;this.arrivalTime = arrivalTime;this.burstTime = burstTime;}// 省略getter和setter方法}```2. 定义调度器类（Scheduler）：```javapublic class Scheduler {private List<Process> processes; // 进程列表private int currentTime; // 当前时间// 构造函数public Scheduler(List<Process> processes) {this.processes = processes;this.currentTime = 0;}// FCFS调度算法public void fcfs() {for (Process process : processes) {process.setWaitingTime(currentTime -process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime -process.getArrivalTime());}}// SJF调度算法public void sjf() {processes.sort((p1, p2) -> p1.getBurstTime() -p2.getBurstTime());for (Process process : processes) {process.setWaitingTime(currentTime -process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime -process.getArrivalTime());}}// RR调度算法public void rr(int quantum) {List<Process> sortedProcesses = new ArrayList<>(processes);sortedProcesses.sort((p1, p2) -> p1.getArrivalTime() -p2.getArrivalTime());int timeSlice = quantum;for (Process process : sortedProcesses) {if (process.getBurstTime() > timeSlice) {process.setWaitingTime(currentTime - process.getArrivalTime());currentTime += timeSlice;process.setTurnaroundTime(currentTime - process.getArrivalTime());process.setBurstTime(process.getBurstTime() - timeSlice);} else {process.setWaitingTime(currentTime - process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime - process.getArrivalTime());process.setBurstTime(0);}}}}```3. 测试调度程序：```javapublic class Main {public static void main(String[] args) {List<Process> processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P3", 4, 2));processes.add(new Process("P4", 6, 4));Scheduler scheduler = new Scheduler(processes); System.out.println("FCFS调度结果：");scheduler.fcfs();for (Process process : processes) {System.out.println(process);}processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P2", 1, 3));processes.add(new Process("P3", 4, 2));processes.add(new Process("P4", 6, 4));System.out.println("SJF调度结果：");scheduler.sjf();for (Process process : processes) {System.out.println(process);}processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P2", 1, 3));processes.add(new Process("P3", 4, 2));System.out.println("RR调度结果（时间片为2）：");scheduler.rr(2);for (Process process : processes) {System.out.println(process);}}}```五、实验结果与分析通过实验，我们可以观察到以下结果：1. FCFS调度算法简单，但可能导致长作业等待时间过长。

操作系统实验报告进程调度操作系统实验报告：进程调度引言操作系统是计算机系统中最核心的软件之一，它负责管理和调度计算机的资源，提供良好的用户体验。

在操作系统中，进程调度是其中一个重要的功能，它决定了进程的执行顺序和时间片分配，对于提高计算机系统的效率和响应能力至关重要。

本篇实验报告将重点介绍进程调度的相关概念、算法和实验结果。

一、进程调度的概念进程调度是操作系统中的一个重要组成部分，它负责决定哪个进程可以使用CPU，并为其分配执行时间。

进程调度的目标是提高系统的吞吐量、响应时间和公平性。

在多道程序设计环境下，进程调度需要考虑多个进程之间的竞争和协作，以实现资源的合理利用。

二、进程调度算法1. 先来先服务调度（FCFS）先来先服务调度算法是最简单的进程调度算法之一，它按照进程到达的顺序进行调度，即先到达的进程先执行。

这种算法的优点是公平性高，缺点是无法适应长作业和短作业混合的情况，容易产生"饥饿"现象。

2. 最短作业优先调度（SJF）最短作业优先调度算法是根据进程的执行时间来进行调度的，即执行时间最短的进程先执行。

这种算法的优点是能够最大程度地减少平均等待时间，缺点是无法适应实时系统和长作业的情况。

3. 时间片轮转调度（RR）时间片轮转调度算法是一种抢占式调度算法，它将CPU的执行时间划分为固定大小的时间片，并按照轮转的方式分配给各个进程。

当一个进程的时间片用完后，它将被挂起，等待下一次调度。

这种算法的优点是能够保证每个进程都能够获得一定的执行时间，缺点是无法适应长作业和短作业混合的情况。

4. 优先级调度（Priority Scheduling）优先级调度算法是根据进程的优先级来进行调度的，优先级高的进程先执行。

这种算法的优点是能够根据进程的重要性和紧急程度进行灵活调度，缺点是可能会导致低优先级的进程长时间等待。

三、实验结果与分析在实验中，我们使用了不同的进程调度算法，并对其进行了性能测试。

计算机操作系统课程设计实验报告题目名称进程调度模拟系统院系班级完成时间2013.1.8 指导老师本次实验成绩组长联系电话邮件地址组长（姓名、学号）主要任务需求分析，模块设计与代码编写，组织任务分配，PPT制作，实验报告审定,材料汇总等成员（姓名、学号）主要任务代码的编写实验报告的编写、材料查找等题目进程调度：模拟FCFS和SJF进程调度过程实验介绍原理现在的处理机任务量大，多个进程会不同时先后到达，并且各个进程的工作时间也不一定相同，为了使各个进程间不发生冲突，有条不紊的先后运行，并以最短的时间占用处理机，面对这种发展状况，有必要使用进程调度算法来提高处理机的工作效率。

去选择合适的一种进程调度算法达到理想的效果，可以做到信息的规范管理、科学统计和快速运作，从而减少时间上的浪费。

用Java语句设计实现登陆界面，直观显示各种算法和调度结果，直观地显示运行结果，设计进程调度算法实现用不同算法（先来先服务，短作业优先，高响应比优先调度算法，时间片轮转算法）进行进程调度，算出最短周转时间，实现高效率调度算法。

参考资料[1] 黄祥喜，计算机操作系统实验教程。

广州：中山大学出版社，1994.[2] 汤子瀛，《计算机操作系统(修订版)》西安电子科技大学出版社[3] Andrew S.Tanenbaum，现代操作系统，机械工业出版社。

[4] (美)Bruce Eckel. Java编程思想. 陈昊鹏译. 北京：机械工业出版社，2007[5] 王路群.Java高级程序设计.北京：中国水利水电出版社，2006[6] 孙卫琴. 精通Struts：基于MVC的Java Web设计与开发.北京：电子工业出版社，2004.08实验环境（软件和硬件）：（1）硬件要求EGA或VGA卡彩显或单显(640×350以上),单机内存2M以上,硬盘40M 以上。

客户端计算机采用586以上机型，客户端应用程序可以稳定的运行在Windows07 xp操作系统之上。

《操作系统》上机实验报告实验算法主体内容及#include<stdio.h>#include<dos.h>#include<stdlib.h>#include<conio.h>#include<iostream.h>#define P_NUM 5 // 共有5 个进程#define P_TIME 50 //作为优先数计算时所用的值enum state{ready,execute,block, finish};//进程的状态，使用枚举struct pcb{char name[4]; // 进程名称int priority; //进程优先级int cputime; //已经占有cpu运行的时间int needtime; //还需要运行的时间int count; //在时间片轮转法中使用的int round; //在时间片轮转法中使用的state process; //进程的状态pcb *next; //指向下一个进程的pcb};pcb *get_process() //通过输入各进程的值来建立pcb队列，并返回其首元素的指针{pcb *q;pcb *t;pcb *p;int i=0;coutvv"请输入进程名与时间"<<endl;while(i<P_NUM){q=(struct pcb *)malloc(sizeof(pcb));cin>>q->name; cin>>q->needtime; q->cputime=O;q->priority=P_TIME-q->needtime;q->round=0; q->count=0;q->process=ready;q->next=NULL;if (i==0){p=q;t=q;}else{ t->next=q; t=q; } i++;}return p;}void display(pcb *p) //显示本轮运行后的进程各状态情况{coutvv" 进程各状态情况"vvendl;coutvv"名称"vv" "vv"进入时间"vv" "vv"还需时间"vv" "vv"优先级"vv" "vv"状态"vvendl;while(p){coutvvp->name;coutvv" ";coutvvp->cputime;coutvv" ";coutvvp->needtime;coutvv" ";cout<vp_>priority;coutvv"";switch(p->process) //对枚举类型的输出方法{case ready:cout< <"就绪"<<endl;break;case execute:cout< <"执行"<<endl;break;case block:cout<<"阻塞"<<endl;break;case finish:cout<<"完成"<<endl;break;} p=p->next;}}int process_finish(pcb *q) //判断所有的进程是否运行结束{ -int b=1;while(q&&b){b=b&&q->needtime==O; q=q_>next;} return b;}void cpuexe(pcb *q) //优先级调度算法的一次执行{pcb *t;t=q;int i=0;while(q){if (q->process!=finish){q_>process=ready;if(q->needtime==0) q->process=finish;} if(i<q->priority) if(q->process!=finish){ t=q;i=q->priority;} q=q->next;}t->needtime-=1;t_>priority_=3; if(t->needtime==0)t->process=finish; t->cputime+=1;}void priority_cal() //优先级调度算法{pcb *p;P=get_process();〃取得进程队列int cpu=0;while(!process_finish(p)) //若进程并未全部结束，则还需要执行{cpu++;coutvv"运行次数："vvcpuwendl; cpuexe(p);//一次cpu的执行display(p);//显示本次执行结果}}pcb * get_process_round()Jpcb *q;pcb *t;pcb *p;int i=0;coutvv"请输入进程名与时间"《endl;while (i<P_NUM){q=(struct pcb *)malloc(sizeof(pcb));cin>>q->name;cin>>q->needtime; q->cputime=O;q->round=0;q->count=0;q_>process=ready; q->next=NULL; if(i==0){p=q;t=q;}else{} i++; } return p;} t->next=q; t=q；void cpu_round(pcb *q){-q->count++;q->cputime+=2;q->needtime-=2;if(q->needtime<0)q->needtime=0;q->round++;q->process=execute;}pcb *get_next(pcb *k,pcb *head){ -pcb *t;t=k; do{t=t->next;}while (t && t->process==finish);if(t==NULL){} return t; t=head;while (t->next!=k && t->process==finish) {t=t->next;}void set_state(pcb *p){-while(p){if (p->needtime==O){p->process=finish;}if (p->process==execute){p_>process=ready;} p=p_>next;}}void display_round(pcb *p){ -cout«" 进程各状态情况"vvendl;coutvv"名称"vv" "vv"进入时间"vv" "vv"还需时间"vv" "vv"时间片"vv"" vv"次数"vv""vv"状态"vvendl;while(p){coutvvp->name;coutvv" ";coutvvp->cputime;coutvv" ";coutvvp->needtime;coutvv" ";coutvvp->round;coutvv"";coutvvp->count;coutvv"";switch(p->process){case ready:coutv v"就绪"vvendl;break;case execute:coutvv'执行"vvendl;break;case finish:coutvv"完成"vvendl;break;}p=p->next;}}void round_cal(){pcb *p;pcb *r;p=get_process();int cpu=0;r=p;while(!process_finish(p)){cpu+=2;cpu_round(r);r=get_next(r,p);coutvv"运行次数"vvcpuvvendl;display_round(p);set_state(p);} }-void display_menu(){ -coutvv"进程调度算法操作:"vvendl;coutvv"1 优先数"vvendl;coutvv"2 时间片轮转"vvendl;coutvv"3 退出"vvendl;}void main(){display_menu();int k;printf("请选择:");scanf("%d",&k);switch(k){case 1:priority_cal();break;case 2:round_cal();break;case 3:break;}} ----------------------------------------------------------------------------------------------------------测试数据:¥间出择1A.时退选r 5642 3込簷运行结果:1优先数S却曰石石<奪--a S 亠 亡疋出尢尤扫 亡、 ^a ^T B a 抄各时 各时 进还进还称进入时|可0 3 0I! IS 运行次数 “称进入时间II态成養成成忧完就完完完&0 94 2R p f c 32 3 4 3 % 扰冋运行次数心 泊称进入吋冋R5 R 5 C4 卜2佳行次数陰态成成成成成状§_f c s ^H Z B6 4 28尸尤32 3 4结果截图与分析2、时间片轮转10 0名称进入时问64 42 运行次数t k 称进入吋间A称进入时间竇鶴躺翻聶s _^->4p 者者者奁廿者_J-^□者者HiH8 数 謝还轎時 0 00 0 0次数0 口2 1 21 2 3 3216 6 42 2 1 20 Q 0D F次数3 E34 4 1 1 e s 02 0 0态成成态成衣成成些兀执完lla兀。

《计算机操作系统》课程实验报告题目实验一进程调度学院: 计算机学院专业: 计算机科学与技术姓名班级学号2015年10月21日实验一进程调度1.实验目的：通过对进程调度算法的模拟，进一步理解进程的基本概念，加深对进程运行状态和进程调度过程、调度算法的理解。

2.实验内容：用C语言实现对N个进程采用某种进程调度算法先来先服务调度、短作业优先调度的调度。

3.设计实现：要求给出设计源码，设计源码要有详细注释，#include <stdio.h>#include<iostream>using namespace std;struct program{char name; /*进程名*/int atime; /*到达时间*/int stime; /*服务时间*/int ftime; /*完成时间*/int rtime; /*周转时间*/float qrtime; /*带权周转时间*/};void xianshi(struct program a[],int n){int i,j;struct program t;/*将进程按时间排序*/printf("根据到达时间重新排序：\n");printf("*****进程*************到达时间***************服务时间*****\n");for(j=0;j<n-1;j++)for(i=0;i<n-1-j;i++)if(a[i].atime>a[i+1].atime){t.atime=a[i].atime;a[i].atime=a[i+1].atime;a[i+1].atime=t.atime;=a[i].name;a[i].name=a[i+1].name;a[i+1].name=;t.stime=a[i].stime;a[i].stime=a[i+1].stime;a[i+1].stime=t.stime;}for(i=0;i<n;i++)printf(" %c %d %d |\n",a[i].name,a[i].atime,a[i].stime);printf("----------------------------------------------------\n"); }void fcfs(struct program a[],int n){int i;int time=0;for(i=0;i<n;i++){time=time+a[i].stime;a[i].ftime=a[0].atime+time;a[i].rtime=a[i].ftime-a[i].atime;a[i].qrtime=(float)a[i].rtime/a[i].stime;}printf("\nFCFS算法：\n");printf("*****进程****到达时间****完成时间******周转时间*******带权周转时间*****\n");for(i=0;i<n;i++){printf(" %c %d %.2d %.2d %.2f |\n",a[i].name,a[i].atime,a[i].ftime,a[i].rtime,a[i].qrtime);}printf("-----------------------------------------------------------------------\n");}void main(){int i,m;struct program pro[4];/*创建进程 */printf(" ******先来先服务算法****** \n");printf("请输入进程的数目：\n");scanf("%d",&m);i=m;for(i=0;i<m;i++){printf("请输入进程%d的进程名，到达时间，服务时间\n",i+1);cin>>pro[i].name>>pro[i].atime>>pro[i].stime;}xianshi(pro,m);fcfs(pro,m);getchar();}#include <stdio.h>#include<iostream>using namespace std;struct program{char name; /*进程名*/float atime; /*到达时间*/float stime; /*服务时间*/float ftime; /*完成时间*/float rtime; /*周转时间*/float qrtime; /*带权周转时间*/};void xianshi(struct program a[],int n){int i,j;struct program t;/*将进程按时间排序*/printf("重新排序：\n");printf("*****进程*************到达时间***************服务时间*****\n");for(j=0;j<n-1;j++)for(i=1;i<n-1-j;i++)if(a[i].stime>a[i+1].stime){t.atime=a[i].atime;a[i].atime=a[i+1].atime;a[i+1].atime=t.atime;=a[i].name;a[i].name=a[i+1].name;a[i+1].name=;t.stime=a[i].stime;a[i].stime=a[i+1].stime;a[i+1].stime=t.stime;}for(i=0;i<n;i++)printf(" %c %f %f |\n",a[i].name,a[i].atime,a[i].stime);printf("----------------------------------------------------\n"); }void SJF(struct program a[],int n){int i;a[0].ftime=a[0].atime+a[0].stime;a[0].rtime=a[0].ftime-a[0].atime;a[0].qrtime=a[0].rtime/a[0].stime;for(i=1;i<n;i++){a[i].ftime=a[i-1].ftime+a[i].stime;a[i].rtime=a[i].ftime-a[i].atime;a[i].qrtime=a[i].rtime/a[i].stime;}printf("\nSJF算法：\n");printf("*****进程****到达时间****完成时间******周转时间*******带权周转时间*****\n");for(i=0;i<n;i++){printf(" %c %.2f %.2f %.2f %.2f |\n",a[i].name,a[i].atime,a[i].ftime,a[i].rtime,a[i].qrtime);}printf("-----------------------------------------------------------------------\n");}void main(){int i,m;struct program pro[4];/*创建进程 */printf(" ******短作业优先算法****** \n");printf("请输入进程的数目：\n");scanf("%d",&m);i=m;for(i=0;i<m;i++){printf("请输入进程%d的进程名，到达时间，服务时间\n",i+1);cin>>pro[i].name>>pro[i].atime>>pro[i].stime;}xianshi(pro,m);SJF(pro,m); getchar(); }4.实验结果5.实验过程中出现的问题及解决办法先来先服务调度算法就是根据进程达到的时间为依据，哪一个进程先来那么该进程就会先执行；最短进程优先调度算法则是以每个进程执行所需时间长短为依据，某一个进程执行所需花的时间要短些那么该进程就先执行。

华中师范大学计算机科学系《操作系统》实验报告实验题目：进程调度学生姓名：日期：2011-12-9实验2进程调度【实验目的】（1）通过编写程序实现进程或作业先来先服务、高优先权、按时间片轮转调度算法，使学生进一步掌握进程调度的概念和算法，加深对处理机分配的理解。

（2）了解Windows2000/XP中进程（线程）的调度机制。

（3）学习使用Windows2000/XP中进程（线程）调度算法，掌握相应的与调度有关的Win32 API函数。

【实验内容】在Windows XP、Windows 2000等操作系统下，使用的VC、VB、java或C等编程语言，利用相应的WIN32 API函数，编写程序实现进程或作业先来先服务、高优先权、按时间片轮转调度算法。

【实验步骤、过程】（含原理图、流程图、关键代码，或实验过程中的记录、数据等）1、进程调度算法：采用多级反馈队列调度算法。

其基本思想是：当一个新进程进入内在后，首先将它放入第一个队列的末尾，按FCFS原则排队等待高度。

当轮到该进程执行时，如能在该时间片内完成，便可准备撤离系统；如果它在一个时间片结束时尚为完成，调度程序便将该进程转入第二队列的末尾，再同样地按FCFS原则等待调度执行，以此类推。

2、实验步骤:（1）按先来先服务算法将进程排成就绪队列。

（2）检查所有队列是否为空，若空则退出，否则将队首进程调入执行。

3、流程图：是4、代码：#include<iostream>#include<string>using namespace std;class Process{public:string ProcessName; // 进程名字int Time; // 进程需要时间int leval; // 进程优先级int LeftTime; // 进程运行一段时间后还需要的时间};//////////////////////////////////////////////////////////////////////////////////////////////////void Copy ( Process proc1, Process proc2); // 把proc2赋值给proc1void Sort( Process pr[], int size) ; // 此排序后按优先级从大到小排列void sort1(Process pr[], int size) ; // 此排序后按需要的cpu时间从小到大排列void Fcfs( Process pr[], int num, int Timepice); // 先来先服务算法void TimeTurn( Process process[], int num, int Timepice); // 时间片轮转算法void Priority( Process process[], int num, int Timepice); // 优先级算法//////////////////////////////////////////////////////////////////////////////////////////////////void main(){int TimePice;int num;cout<<" *********创建进程*********\n"<<endl;cout<<" 输入进程个数:";cin>>num;const int Size =30;Process process[Size] ;for( int i=0; i< num; i++){string name;int CpuTime;int Leval;cout<<"\n 输入第"<< i+1<<" 个进程的名字、运行时间和优先级:"<<endl;cin>> name;cin>> CpuTime>> Leval;process[i].ProcessName =name;process[i].Time =CpuTime;process[i].leval =Leval;cout<<endl;}int a;cout<<endl;cout<<" *******输入此进程时间片大小:******: ";cin>>TimePice;cout<<"\n *******选择调度算法：*************\n"<<endl;cout<<"**************************************************************"<<endl; cout<<"* 1: FCFS 2: 时间片轮换3: 优先级调度4: 最短作业优先*"<<endl; cout<<"**************************************************************"<<endl; cin>> a;for ( int k=0;k<num;k++)process[k].LeftTime=process[k].Time ;//对进程剩余时间初始化cout<<" // 说明: 在本程序所列进程信息中，优先级一项是指进程运行后的优先级!! "; cout<<endl; cout<<endl;if(a==1)Fcfs(process,num,TimePice);else if(a==2)TimeTurn( process, num, TimePice);else if(a==3){Sort( process, num);Priority( process , num, TimePice);}else // 最短作业算法，先按时间从小到到排序，再调用Fcfs算法即可{sort1(process,num);Fcfs(process,num,TimePice);}}void Copy ( Process proc1, Process proc2){proc1.leval =proc2.leval ;proc1.ProcessName =proc2.ProcessName ;proc1.Time =proc2.Time ;}void Sort( Process pr[], int size) //以进程优先级高低排序{for( int i=1;i<size;i++){Process temp;temp = pr[i];int j=i;while(j>0 && temp.leval<pr[j-1].leval){pr[j] = pr[j-1];j--;}pr[j] = temp;}for( int d=size-1;d>size/2;d--){Process temp;temp=pr [d];pr [d] = pr [size-d-1];pr [size-d-1]=temp;}}void sort1 ( Process pr[], int size) // 以进程时间从低到高排序{// 直接插入排序for( int i=1;i<size;i++){Process temp;temp = pr[i];int j=i;while(j>0 && temp.Time < pr[j-1].Time ){pr[j] = pr[j-1];j--;}pr[j] = temp;}}//// 先来先服务算法的实现void Fcfs( Process process[], int num, int Timepice){while(true){if(num==0){cout<<" 所有进程都已经执行完毕!\n"<<endl;exit(1);}if(process[0].LeftTime<=0){process[0].LeftTime=0;cout<<" 进程"<<process[0].ProcessName<< " 已经执行完毕!\n"<<endl;for (int i=0;i<num;i++)process[i]=process[i+1];num--;}else if(process[num-1].LeftTime<=0){process[num-1].LeftTime=0;cout<<" 进程"<<process[num-1].ProcessName<< " 已经执行完毕!\n"<<endl;num--;}else{cout<<endl;process[0].LeftTime=process[0].LeftTime- Timepice;if(process[0].LeftTime<=0)process[0].LeftTime=0;process[0].leval =process[0].leval-1;cout<<"进程名字"<<"共需占用CPU时间"<<" 还需要占用时间"<<" 优先级"<<" 状态"<<endl;cout<<" "<<process[0].ProcessName <<" "<<process[0].Time <<" ";cout<<process[0].LeftTime <<" "<<process[0].leval<<" 运行"<<endl;for(int s=1;s<num;s++){if(process[s].LeftTime<=0)process[s].LeftTime=0;cout<<"进程名字"<<"共需占用CPU时间"<<" 还需要占用时间"<<" 优先级"<<" 状态"<<endl;cout<<" "<<process[s].ProcessName <<" "<<process[s].Time <<" ";cout<<process[s].LeftTime <<" "<<process[s].leval<<" 等待"<<endl; ;}}cout<<endl;system(" pause");cout<<endl;}}/// 时间片轮转调度算法实现void TimeTurn( Process process[], int num, int Timepice){while(true){if(num==0){cout<<" 所有进程都已经执行完毕!\n"<<endl;exit(1);}if(process[0].LeftTime<=0){process[0].LeftTime=0;cout<<" 进程"<<process[0].ProcessName<< " 已经执行完毕!\n"<<endl;for (int i=0;i<num;i++)process[i]=process[i+1];num--;}if( process[num-1].LeftTime <=0 ){process[num-1].LeftTime=0;cout<<" 进程" << process[num-1].ProcessName <<" 已经执行完毕! \n"<<endl;num--;}else if(process[0].LeftTime > 0){cout<<endl; //输出正在运行的进程process[0].LeftTime=process[0].LeftTime- Timepice;if(process[0].LeftTime<0)process[0].LeftTime=0;process[0].leval =process[0].leval-1;cout<<"进程名字"<<"共需占用CPU时间"<<" 还需要占用时间"<<" 优先级"<<" 状态"<<endl;cout<<" "<<process[0].ProcessName <<" "<<process[0].Time <<" ";cout<<process[0].LeftTime <<" "<<process[0].leval<<" 运行"<<endl;for(int s=1;s<num;s++){if(process[s].LeftTime<0)process[s].LeftTime=0;cout<<"进程名字"<<"共需占用CPU时间"<<" 还需要占用时间"<<" 优先级"<<" 状态"<<endl;cout<<" "<<process[s].ProcessName <<" "<<process[s].Time <<" ";cout<<process[s].LeftTime <<" "<<process[s].leval;if(s==1)cout<<" 就绪"<<endl;elsecout<<" 等待"<<endl;}Process temp;temp = process[0];for( int j=0;j<num;j++)process[j] = process[j+1];process[num-1] = temp;}elsesystem(" pause");cout<<endl;system(" pause");cout<<endl;}}/// 优先级调度算法的实现void Priority( Process process[], int num, int Timepice){while( true){if(num==0){cout<< "所有进程都已经执行完毕!\n"<<endl;exit(1);}if(process[0].LeftTime<=0){process[0].LeftTime=0;cout<<" 进程" << process[0].ProcessName <<" 已经执行完毕! \n"<<endl;for( int m=0;m<num;m++)process[m] = process[m+1]; //一个进程执行完毕后从数组中删除num--; // 此时进程数目减少一个}if( num!=1 && process[num-1].LeftTime <=0 ){process[num-1].LeftTime=0;cout<<" 进程" << process[num-1].ProcessName <<" 已经执行完毕! \n"<<endl;num--;}if(process[0].LeftTime > 0){cout<<endl; //输出正在运行的进程process[0].LeftTime=process[0].LeftTime- Timepice;if(process[0].LeftTime<0)process[0].LeftTime=0;process[0].leval =process[0].leval-1;cout<<"进程名字"<<"共需占用CPU时间"<<" 还需要占用时间"<<" 优先级"<<" 状态"<<endl;cout<<" "<<process[0].ProcessName <<" "<<process[0].Time <<" ";cout<<process[0].LeftTime <<" "<<process[0].leval<<" 运行"<<endl;// 输出其他进程for(int s=1;s<num;s++){if(process[s].LeftTime<0)process[s].LeftTime=0;cout<<"进程名字"<<"共需占用CPU时间"<<" 还需要占用时间"<<" 优先级"<<" 状态"<<endl;cout<<" "<<process[s].ProcessName <<" "<<process[s].Time <<" ";cout<<process[s].LeftTime <<" "<<process[s].leval ;if(s==1)cout<<" 就绪"<<endl;elsecout<<" 等待"<<endl;}} // elseSort(process, num);cout<<endl;system(" pause");cout<<endl;} // while}【实验小结】本次试验的题目——进程管理。

操作系统实验报告java实验报告：操作系统实验一、实验目的本次实验旨在通过使用Java语言编写一个简单的操作系统，加深对操作系统原理的理解，掌握操作系统底层的相关知识。

二、实验环境1.Java编程环境：JDK 82.开发工具：Eclipse IDE3.操作系统：Windows 10三、实验内容1.实验背景介绍在本章节中，我们将介绍操作系统的基本概念、功能以及其在计算机系统中的作用。

2.实验设计与实现本章节将详细描述操作系统实现的设计思路和具体的实现过程，包括创建进程、调度算法、内存管理、文件系统等。

2.1 创建进程在本节中，我们将介绍如何使用Java语言创建一个进程，并实现进程的并发执行。

2.2 调度算法本节将讨论操作系统中的调度算法，例如先来先服务、短作业优先、时间片轮转等，并给出具体的实现代码。

2.3 内存管理在本节中，我们将介绍操作系统的内存管理机制，包括分区分配、动态存储分配等，并给出相关的实现方法。

2.4 文件系统本节将详细介绍操作系统中的文件系统的设计和实现，包括文件的存储、目录管理、文件访问控制等。

四、实验结果与分析1.实验结果展示在本章节中，我们将展示实验的运行结果，并对实验结果进行详细的分析和解释。

2.实验评估与讨论本节将对实验结果进行评估和讨论，包括对实验系统性能的评估以及可能存在的问题和改进方向的讨论。

五、实验总结本次实验通过使用Java语言编写一个简单的操作系统，使我们更深入地了解了操作系统的原理和实现，掌握了操作系统底层的相关知识。

六、附件本文档涉及的附件包括实验代码和相关实验结果的截图。

附件一：源代码文件（OS.java）附件二：实验结果截图（result.png）七、法律名词及注释1.操作系统：操作系统是一种控制和管理计算机硬件与软件资源的程序。

2.进程：进程是计算机中正在运行的一个程序实例，它具有独立的内存空间和系统资源。

3.调度算法：调度算法是操作系统中用于决定进程执行顺序的一种算法，目的是合理利用系统资源，提高系统性能。

操作系统实验第一期项目开发实现实验名称EXP.1 CPU SchedulingExp.2 Allocation & Reclaim实验内容一，选择一个调度算法，实现处理机调度；二，处理机调度过程中，主存储器空间的分配和回收；实验目的一,多道系统中，当就绪进程数大于处理机数时，须按照某种策略决定哪些进程优先占用处理机。

本实验模拟实现处理机调度，以加深了解处理机调度的工作；二，帮助了解在不同的存储管理方式下，应怎样实现主存空间的分配和回收；实验题目一，（1）设计一个按照优先权调度算法实现处理机调度的程序；（2）设计按时间片轮转实现处理机调度的程序；二，在可变分区管理方式下，采用最先适应算法实现主存空间的分配和回收；实验要求一，（a），PCB内容：进程名/PID；要求运行时间（单位时间）；优先权；状态；PCB 指针；——(因课程内容原因，这个指针在设计中没用)1，可随机输入若干进程，并按优先权排序；2，从就绪队列首选进程运行：优先权-1/ 要求运行时间-1；要求运行时间=0时，撤销该进程；3，重新排序，进行下一轮调度；（b），最好采用图形界面；（c）,可随时增加进程；（d），规定道数，设置后备队列和挂起状态。

若内存中进程数少于规定道数，可自动从后备队列调度一作业进入。

被挂起进程如=入挂起队列，设置解挂功能用于将指定挂起进程解挂入就绪队列；（e），每次调度后，显示各进程状态；二，（a），自行假设主存空间大小，预设操作系统所占大小并构造未分分区表；表目内容：起址、长度、状态（未分/空表目）（b），结合实验一，PCB增加为：｛PID，要求运行时间，优先权，状态，所需内存大小，主存起始位置，PCB指针（失效）｝；（C）采用最先适应算法分配主存空间；（D），进程完成后，回收主存，并与相邻空闲分区合并；实验过程及分析1，初步设计：2，详细设计：（a），操作系统知识回顾：（1）作业进入内存中，由CPU分配产生PCB属性，并通过PCB记录进程状态，实验即以PCB代表进程模拟调度过程；（2）在多道系统中，多道系统中，当就绪进程数大于处理机数时，须按照某种策略决定哪些进程优先占用处理机，本实验采用优先级；（3），进程调度时，规定若就绪队列进程数少于6个，则自动从后备队列调入一个作业；（4），系统会将占有较多资源、预期结果不符合要求的进程自动挂起，并回收所占资源，而本实验设置为手动挂起；（5），在适宜条件下，系统会将挂起的进程自动解挂，而且只解挂到就绪队列；本实验为简化操作，设置为手动解挂，若解挂条件合适（即CPU各种资源可用），则解挂到就绪队列，并分配内存；若解挂条件不适宜，则解挂至后备队列，但不分配内存（实际上这是不对的，因为作业进入内存，由CPU标记PCB后，不能撤销PCB再返回内存，除非该进程执行结束，但本程序为体现解挂的意思，还是错误地设计为可以解挂到后备队列，读者需注意，这个功能可以在代码中注销，另外也希望有高手可以改进）；（b），实验程序设计：（1），本实验采用java语言编程，并实现GUI界面显示；（2），为体现java语言面对对象程序设计的特点，实验设计为ProcessPCB、MemoryItem类封装PCB和所分配的内存各自的属性与方法；用ProcessRecords、MemoryRecords类封装数组方法；用SingleCPUScheduling实现GUI界面显示；（3），ProcessPCB类中，定义PCB的进程名、要求运行时间、优先级、状态、主存起始位置、所需内存大小这6个属性，并定义各属性的get和set方法，定义equals 方法用于对比类的属性，定义toString方法得到类属性的字符串，定义run方法封装优先权-1/ 要求运行时间-1的过程；MemoryItem类中，定义可分分区表每一可分记录的主存起始位置、内存大小及其get和set方法，定义toString方法得到可在界面显示的字符串；（4），ProcessRecords封装PCB数组的添加元素addItem和删除元素removeItem方法，并构造函数getItem通过参数ProcessPCB和String查找数组元素，定义getNumberOfItems取数组大小，定义getItemsPriorities方法取所有数组元素的toString 方法用于界面显示，定义iterator方法取得数组的迭代器；（5），MemoryRecords用同样的设计思想封装以MemoryItem为数组元素的各属性和方法；（6）SingleCPUScheduling类继承JFrame类，实现界面化显示；与上面相对应，实例化ProcessRecords（3次）和MemoryRecords（1次）作为私有变量，分别作为后备队列、就绪队列、挂起队列和内存可分分区表；在界面设计中，设计后备队列、挂起队列（附带解挂umount按钮）、就绪队列（附带挂起suspend按钮）可分分区表列表显示框，设置PCB添加框，附带添加至后备队列（addToBackup）、添加至就绪队列（addToReady）按钮，以及CPU当前执行状态显示框、系统日志显示框，和开始调度（systemStart）按钮，优先级和时间片单选按钮，以及时间片显示标签和文本编辑框；（7）界面设计详解；后备队列显示框用于显示已添加至后备队列的ProcessRecords 属性信息，其中主存起始位置默认为-1，表示未分配；挂起队列显示框用于显示从就绪队列挂起的PCB，其中属性“主存起始位置”（MemoryBase）将由非负数变为-1，表示挂起后收回内存；就绪队列显示框中显示就绪队列属性，其中“主存起始位置”均为非负，表示一分配内存；PCB信息添加框分列PCB6个属性显示标签和可编辑文本框，和添加按钮，用于添加PCB；系统日志显示框附属时间片显示标签和可编辑文本编辑框，可由用户决定时间片大小；对于实验一，界面如下：以上由SingleCPUScheduling001.java（另需ProcessPCB.java和PCBRdecords.java）（8）附属功能添加完善；最重要的是为程序添加线程，是程序能以停顿一段时间的频率自动运行；后备队列、挂起队列添加total显示标签和不可编辑文本显示框，用于显示各自数组中元素数目，挂起队列附属删除（remove）按钮，可删除挂起队列中的元素；后备、挂起、就绪队列均添加监听器，用于响应用户单击操作，可以在PCB信息添加框显示用户单击的那一条PCB的信息；PCB信息添加框附属reset按钮，用于一键清空信息框中信息，方便输入；系统日志面板附属系统暂停（systemPause）和系统重置（systemReset）按钮，分别用于暂停运行（方便用户观察当前运行结果）和重置系统（方便用户重复使用程序，免去关闭后重启本程序的麻烦）；最终界面如图：实验结果报告级分析1，程序完成了实验所有的基本要求；2，本程序还存在一些技术上的问题，使得程序不能尽善尽美；如，PCB信息添加框没有“随机置入就绪队列”功能，添加PCB信息仍显得繁琐；就绪队列的挂起功能在程序自动运行时，存在反应异常（反应延迟或直接无反映）；可分分区表只显示了当前可分的内存，没有显示已分的PCB及其对应内存使用情况，且没有利用图形和丰富的颜色来更好的展示；时间片设计还需要改进，使用效率不高；系统重置功能存在响应延迟的问题；另外，界面不够美观；还需要不断改进；实验感想通过这次实验，我对操作系统的进程调度和内存分配管理有了更加深入的了解，对操作系统内部的工作原理有了进一步的认识；通过编程，也巩固了我的程序设计和代码编写的能力，实验过程中遇到的各种问题以及解决问题的过程与方法，都是我获益匪浅；同时，程序的不完善，也将促使我在课程之后，继续学习、理解课程内容，并尽一切努力不断完善程序，做到尽善尽美；程序代码完整版（初学java，菜鸟级别，当然是将所学的全部照办照抄，实为臃肿，可为初学者引以为戒，注意代码质量！）这里谨贴出十分臃肿的代码，仅供初学者交流经验，重在开发的思想，了解开发的流程，而01版（精简版）代码在后面；ProcessPCB.javapackage src;publicclass ProcessPCB {// backupBAK 后备 ready 就绪 suspend 挂起 memory内存private String PID;privateint RequiredTime;// private String Priority;privateint Priority;private String Status;privateint MwmoryBase = 0000;privateint MemoryLimit;// private String PCBPointer;public ProcessPCB(String initpID, int initRTime, int initpriority,String status, int initBase, int initLimit) {this.PID = initpID;this.RequiredTime = initRTime;this.Priority = initpriority;this.Status = status;this.MwmoryBase = initBase;this.MemoryLimit = initLimit;public String getPID() {if(this.PID == null)return " ";elsereturnthis.PID;}publicvoid setPID(String pid) {if(pid == null)this.PID = " ";elsethis.PID = pid;}publicint getRequiredTime() {returnthis.RequiredTime;}publicvoid setRequiredTime(int time) { this.RequiredTime = time;}publicint getPriority() {returnthis.Priority;}publicvoid setPriority(int priority) { this.Priority = priority;}public String getStatus() {if(this.Status == null)return" ";elsereturnthis.Status;}publicvoid setStatues(String statues) { if(statues == null)this.Status = " ";this.Status = statues;}publicint getMemoryBase() {returnthis.MwmoryBase;}publicvoid setMemoryBase(int base) {this.MwmoryBase = base;}publicint getMemoryLimit() {returnthis.MemoryLimit;}publicvoid setMemoryLimit(int limit) {this.MemoryLimit = limit;}publicboolean equals(ProcessPCB pcb) {if(pcb.getPID() == this.getPID()) {returntrue;}elsereturnfalse;}public String toString() {returnthis.getPID() + "_"+ this.getRequiredTime() + "_"+ this.getPriority() + "_"+ this.getStatus() + "_" + this.getMemoryBase() + "_" +this.getMemoryLimit() + "\n";}publicvoid run() {this.RequiredTime = this.RequiredTime-1;this.Priority = this.Priority-1;}}MemoryItem.javapackage src;publicclass MemoryItem {privateint memoryBase=0;privateint memoryLimit=0;privateint availableStatus=0;public MemoryItem(int initMemoryBase, int initMemoryLimit) { this.memoryBase = initMemoryBase;this.memoryLimit = initMemoryLimit;}publicint getMemoryBase() {returnthis.memoryBase;}publicvoid setMemoryBase(int base) {this.memoryBase = base;}publicint getMemoryLimit() {returnthis.memoryLimit;}publicvoid setMemoryLimit(int limit) {this.memoryLimit = limit;}publicint getStatus() {returnthis.availableStatus;}publicvoid setStatus(int status) {this.memoryBase = status;}public String toString() {returnthis.getMemoryBase() + "_" + this.getMemoryLimit() + "\n"; }}PCBRecords.javapackage src;import java.util.ArrayList;import java.util.Iterator;public class PCBRecords implements Iterable<ProcessPCB> {private ArrayList<ProcessPCB> PCBItems;public ArrayList<ProcessPCB> getPCBItems() {return this.PCBItems;}public PCBRecords() {this.PCBItems = new ArrayList<ProcessPCB>();}public void addItem(ProcessPCB PcbItem) {this.PCBItems.add(PcbItem);}public void removeItem(ProcessPCB PCbItem) {this.PCBItems.remove(PCbItem);}public ProcessPCB getItem(ProcessPCB processPCB) {for (ProcessPCB pCbItem : this.PCBItems) {if (pCbItem.equals(processPCB)) {return pCbItem;}}return null;}public ProcessPCB getItem(String pid) {for (ProcessPCB pcBItem : this.PCBItems) {if (pcBItem.getPID().equals(pid)) {return pcBItem;}}return null;}public int getNumberOfItems() {return this.PCBItems.size();}public String[] getItemsProperties() {String itemsProperties[] = new String[getNumberOfItems()];int i = 0;for(Iterator iterator1 = PCBItems.iterator(); iterator1.hasNext();){ProcessPCB stu_Item = (ProcessPCB)iterator1.next();itemsProperties[i++] = stu_Item.toString();}return itemsProperties;}public Iterator<ProcessPCB> iterator() {return this.PCBItems.iterator();}}MemoryRecords.javapackage src;import java.util.ArrayList;import java.util.Iterator;public class MemoryRecords implements Iterable<MemoryItem> {private ArrayList<MemoryItem> memoryItems;public Iterator<MemoryItem> iterator() {// TODO Auto-generated method stubreturn this.memoryItems.iterator();}public ArrayList<MemoryItem> getMemoryItems() {return this.memoryItems;}public MemoryRecords() {this.memoryItems = new ArrayList<MemoryItem>();}public void addItem(MemoryItem newMemoryItem) {this.memoryItems.add(newMemoryItem);}public void removeItem(MemoryItem momoryItem) {this.memoryItems.remove(momoryItem);}public MemoryItem getMomoryItem(MemoryItem item) {for(MemoryItem mItem : this.memoryItems) {if(mItem.equals(item)) {return mItem;}}return null;}public MemoryItem getMemoryItem(int base) {for(MemoryItem mItem : this.memoryItems) {if(mItem.getMemoryBase() == base) {return mItem;}}return null;}public int getNumberOfItems() {return this.memoryItems.size();}public String[] getItemsProperties() {String itemsProperties[] = new String[getNumberOfItems()];int i=0;for(Iterator iterator1 = this.memoryItems.iterator(); iterator1.hasNext(); ) { MemoryItem mmItem = (MemoryItem) iterator1.next();itemsProperties[i++] = mmItem.toString();//}//System.out.println(itemsProperties + "\n");if(itemsProperties == null) {itemsProperties[0] = " ";}return itemsProperties;}}SingleCPUSchedulingGUI001.Javaimport java.util.*;import java.awt.*;import java.awt.event.*;import javax.swing.*;import javax.swing.event.*;import src.SingleCPUSchedulingGUI001.AddToBAKListener;import src.SingleCPUSchedulingGUI001.AddToReadyListener;import src.SingleCPUSchedulingGUI001.RemoveListener;import src.SingleCPUSchedulingGUI001.ResetListener;import src.SingleCPUSchedulingGUI001.ResetSystemListener;import src.SingleCPUSchedulingGUI001.StartSystemListener;import src.SingleCPUSchedulingGUI001.SuspendListener;import src.SingleCPUSchedulingGUI001.SystemPauseListener;import src.SingleCPUSchedulingGUI001.UmountListener;import src.SingleCPUSchedulingGUI001.priotiryListener;import src.SingleCPUSchedulingGUI001.timeslicListener;import java.io.*;import java.text.*;public class SingleCPUSchedulingGUI001 extends JFrame {private int systemStatues; //注意static 属性/*define 0--system prepare status--system reset and re-prepare 1--system start 2--system pause 3--system stop*//* Standar error stream */static private PrintWriter stdErr = new PrintWriter(System.err, true);static private int WIDTH = 600, HEIGHT = 700; // the size of the Frame 主面板/* 各列表对应的面板规格*//* 对应各名词释义backupBAK 后备ready 就绪suspend 挂起memory内存*/ static private int BackupBAK_CELL_SIZE = 250, BackupBAK_LIST_ROWS = 10; //后备队列static private int Suspend_CELL_SIZE = 250, Suspend_LIST_ROWS = 10; //挂起队列static private int Ready_CELL_SIZE = 200, Ready_LIST_ROWS = 6; //就绪队列static private int CPU_ROWS = 10, CPU_COLS = 22; //CPU面板static private int STATUS_ROWS = 8, STATUS_COLS = 30; //系统状态面板private int timeslice = 1; //设置时间片大小private int systemStatus=0; //设置系统状态0——系统预备状态，等待开始，1——系统运行状态，2——系统暂停状态static private int TOTAL__TEXTFIELD_SIZE = 10; // Size total text field 记录各队列元素个数private JList backupList, suspendList, readyList; //各队列相对应的数组列表// 进程添加框中的"添加至后备队列"，"添加至就绪队列"，"重置"Buttonprivate JButton addToBAKButton, addToReadyButton, resetButton;//就绪队列框中的"挂起"，挂起队列框中的"解挂"，"删除"Buttonprivate JButton suspendButton, umountButton, removeButton;//Status面板中的"启动系统"，"重置系统"Buttonprivate JButton startButton, pauseButton, resetSyatemButton;//优先级和时间片单选钮及时间片显示框private JRadioButton priorityJRB, timesliceJRB;private JLabel timesliceSizeLabel;private JTextField timesliceJtf;//后备面板、进程添加面板、挂起面板、内存面板private JPanel backupBAKPanel, PCBItemPanel, suspendedPanel;//后备队列、挂起队列元素总数标签private JLabel backupTotalLabel, suspendTotalLabel;//进程信息标签进程编号PID,所需运行时间requiredTime,优先级priority,当前状态statues,内存中的基址base,所需内存大小limitprivate JLabel PIDLabel, requiredTimeLabel, priorityLabel, statuesLabel;//后备队列、挂起队列元素总数文本框（不可编辑）private JTextField backupTotalTextField, suspendTotalTextField;//进程信息文本框PID(可编辑),requiredTime(可编辑),priority(可编辑),status(不可编辑),base(不可编辑),limit(可编辑)private JTextField PIDTextField, requiredTimeTextField, priorityTextField, statusTextField;//CPU状态显示文本域(不可编辑)，status信息文本域(用于现实程序每一步的操作和影响，不可编辑)private JTextArea CPUTextArea, statuesTextArea;//后备队列PCB数组,就绪、挂起，——内存（可分分区表）PCBRecords backupPCB, readyPCB, suspendedPCB;public static void main(String[] args) throws IOException {// TODO Auto-generated method stubnew SingleCPUSchedulingGUI001().initFrame();}public void initFrame() {backupList = new JList();backupList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);backupList.setVisibleRowCount(BackupBAK_LIST_ROWS);backupList.setFixedCellWidth(BackupBAK_CELL_SIZE);suspendList = new JList();suspendList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);suspendList.setVisibleRowCount(Suspend_LIST_ROWS);suspendList.setFixedCellWidth(Suspend_CELL_SIZE);readyList = new JList();readyList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);readyList.setVisibleRowCount(Ready_LIST_ROWS);readyList.setFixedCellWidth(Ready_CELL_SIZE);suspendButton = new JButton("Suspend");addToBAKButton = new JButton("AddToBAK");addToReadyButton = new JButton("AddToReady");resetButton = new JButton("Reset");umountButton = new JButton("Umount");removeButton = new JButton("Remove");startButton = new JButton("StartSchuliding");pauseButton = new JButton("Pause");resetSyatemButton = new JButton("ResetSystem");priorityJRB = new JRadioButton("Priority", true);timesliceJRB = new JRadioButton("Timeslice");backupTotalLabel = new JLabel("Total:");backupTotalTextField = new JTextField("0", TOTAL__TEXTFIELD_SIZE);backupTotalTextField.setEditable(false);suspendTotalLabel = new JLabel("Total:");suspendTotalTextField = new JTextField("0", TOTAL__TEXTFIELD_SIZE);suspendTotalTextField.setEditable(false);timesliceSizeLabel = new JLabel("Timeslice");timesliceJtf = new JTextField("3", 5);timesliceJtf.setEditable(true);CPUTextArea = new JTextArea(CPU_ROWS, CPU_COLS);CPUTextArea.setEditable(false);statuesTextArea = new JTextArea(STATUS_ROWS, STATUS_COLS);statuesTextArea.setEditable(false);/* north panel*/// JPanel northPanel = new JPanel(new BorderLayout());JPanel northPanel = new JPanel(new GridLayout(1, 3));// JPanel north = new JPanel(new BorderLayout());// ProcessPCB item information PanelPCBItemPanel = new JPanel(new BorderLayout());PCBItemPanel.setBorder(BorderFactory.createTitledBorder("PCBItem Information"));JPanel PCBItemButtonJPanel = new JPanel(new GridLayout(3, 1));PCBItemButtonJPanel.add(addToBAKButton);PCBItemButtonJPanel.add(addToReadyButton);PCBItemButtonJPanel.add(resetButton);PCBItemPanel.add(this.initPCBItemPanel(), BorderLayout.CENTER);PCBItemPanel.add(PCBItemButtonJPanel, BorderLayout.SOUTH);//backupBAKList PanelbackupBAKPanel = new JPanel(new BorderLayout());backupBAKPanel.setBorder(BorderFactory.createTitledBorder("BackupList"));JPanel backupTotalPAnel = new JPanel();backupTotalPAnel.add(backupTotalLabel);backupTotalPAnel.add(backupTotalTextField);backupBAKPanel.add (new JScrollPane(backupList,JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED), BorderLayout.CENTER);backupBAKPanel.add(backupTotalPAnel, BorderLayout.SOUTH);// north.add(backupBAKPanel, BorderLayout.WEST);// north.add(PCBItemPanel, BorderLayout.CENTER);// SuspendList PanelsuspendedPanel = new JPanel(new BorderLayout());suspendedPanel.setBorder(BorderFactory.createTitledBorder("SuspendList"));JPanel suspendedTotalPAnel = new JPanel();suspendedTotalPAnel.add(suspendTotalLabel);suspendedTotalPAnel.add(suspendTotalTextField);JPanel suspendComponentPanel = new JPanel(new GridLayout(1, 2));suspendComponentPanel.add(umountButton);suspendComponentPanel.add(removeButton);suspendedPanel.add (suspendedTotalPAnel, BorderLayout.NORTH);suspendedPanel.add (new JScrollPane(suspendList,JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED), BorderLayout.CENTER);suspendedPanel.add(suspendComponentPanel, BorderLayout.SOUTH);// northPanel.add(north, BorderLayout.CENTER);// northPanel.add(suspendedPanel, BorderLayout.EAST);northPanel.add(backupBAKPanel);northPanel.add(PCBItemPanel);northPanel.add(suspendedPanel);/* center Panel*/JPanel centrelPanel = new JPanel(new BorderLayout());// JPanel centrelPanel = new JPanel(new GridLayout(1, 3));// readyList panelJPanel readyListPanel = new JPanel(new BorderLayout());readyListPanel.setBorder(BorderFactory.createTitledBorder("ReadyList"));readyListPanel.add (new JScrollPane(readyList,JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED));//, BorderLayout.CENTERreadyListPanel.add (suspendButton, BorderLayout.SOUTH);// CPU panelJPanel CPUPanel = new JPanel();CPUPanel.setBorder(BorderFactory.createTitledBorder("CPU"));CPUPanel.add (new JScrollPane(CPUTextArea,JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED));centrelPanel.add(readyListPanel, BorderLayout.WEST);centrelPanel.add(CPUPanel, BorderLayout.CENTER);/*statues panel*/JPanel southPanel = new JPanel(new BorderLayout());JPanel statuesPanel = new JPanel();statuesPanel.setBorder(BorderFactory.createTitledBorder("Statues"));statuesPanel.add (new JScrollPane(statuesTextArea,JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED)); //, BorderLayout.CENTER //statuesPanel.setSize(400, 100);//statuesPanel.setPreferredSize(new Dimension(400, 10));JPanel systemContralButtonPanel = new JPanel(new GridLayout(6, 1));systemContralButtonPanel.setBorder(BorderFactory.createTitledBorder("systemContral"));ButtonGroup group = new ButtonGroup();group.add(priorityJRB);group.add(timesliceJRB);JPanel porityPanel = new JPanel(new GridLayout(1, 2));porityPanel.add(timesliceSizeLabel);porityPanel.add(timesliceJtf);systemContralButtonPanel.add(priorityJRB);systemContralButtonPanel.add(timesliceJRB);systemContralButtonPanel.add(porityPanel);systemContralButtonPanel.add(startButton);systemContralButtonPanel.add(pauseButton);systemContralButtonPanel.add(resetSyatemButton);southPanel.add(statuesPanel, BorderLayout.CENTER);southPanel.add(systemContralButtonPanel, BorderLayout.EAST); // arrange panels in windowsetLayout(new BorderLayout());add(northPanel, BorderLayout.NORTH);add(centrelPanel, BorderLayout.CENTER);add(southPanel, BorderLayout.SOUTH); //statuesPanel// start listening for list and buttons eventsaddToBAKButton.addActionListener(new AddToBAKListener());addToReadyButton.addActionListener(new AddToReadyListener());resetButton.addActionListener(new ResetListener());suspendButton.addActionListener(new SuspendListener());umountButton.addActionListener(new UmountListener());removeButton.addActionListener(new RemoveListener());startButton.addActionListener(new StartSystemListener());pauseButton.addActionListener(new SystemPauseListener());resetSyatemButton.addActionListener(new ResetSystemListener());priorityJRB.addActionListener(new priotiryListener());timesliceJRB.addActionListener(new timeslicListener());backupPCB = new PCBRecords();readyPCB = new PCBRecords();suspendedPCB = new PCBRecords();backupList.setListData(backupPCB.getItemsProperties());readyList.setListData(readyPCB.getItemsProperties());suspendList.setListData(suspendedPCB.getItemsProperties());this.setTitle("CPUSchudling");this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);this.setSize(WIDTH, HEIGHT);this.setResizable(true);this.setVisible(true);this.setLocation(200, 10);}public JPanel initPCBItemPanel() {JPanel iniPCBItemJPanel = new JPanel(new BorderLayout());JPanel iniNamePanel = new JPanel(new GridLayout(4, 1));JPanel iniValuePanel = new JPanel(new GridLayout(4, 1));PIDLabel = new JLabel("PID:");requiredTimeLabel = new JLabel("RequiredTime:");priorityLabel = new JLabel("Priority:");statuesLabel = new JLabel("Statues:");iniNamePanel.add(PIDLabel);iniNamePanel.add(requiredTimeLabel);iniNamePanel.add(priorityLabel);iniNamePanel.add(statuesLabel);PIDTextField = new JTextField("", 10);PIDTextField.setEditable(true);requiredTimeTextField = new JTextField("", 10);requiredTimeTextField.setEditable(true);priorityTextField = new JTextField("", 10);priorityTextField.setEditable(true);statusTextField = new JTextField("", 10);statusTextField.setEditable(false);iniValuePanel.add(PIDTextField);iniValuePanel.add(requiredTimeTextField);iniValuePanel.add(priorityTextField);iniValuePanel.add(statusTextField);iniPCBItemJPanel.add(iniNamePanel, BorderLayout.WEST);iniPCBItemJPanel.add(iniValuePanel, BorderLayout.CENTER);return iniPCBItemJPanel;}public int readInteger(String s) {int num = -1;try {num = Integer.parseInt(s);} catch(NumberFormatException numberformatexception) {statuesTextArea.append("Please input a positive integer!\n");num = -999;}return num;}public void addToBackupList(String newID, int s1, int s2, String s) {ProcessPCB item = backupPCB.getItem(newID);if(item != null) {statuesTextArea.append("The PCB " + newID + " has existed in Backup List!\n"+ "you need to modify the PID of the selected PCB!\n");while(item != null) {newID = s + newID;item = backupPCB.getItem(newID);}}ProcessPCB newPCB = new ProcessPCB(newID, s1, s2, "Waiting");backupPCB.addItem(newPCB);backupList.setListData(backupPCB.getItemsProperties());backupTotalTextField.setText(Integer.toString(backupPCB.getNumberOfItems())); }public void addToReadyList(String nowID, int s1, int s2, String s) {ProcessPCB item = readyPCB.getItem(nowID);if(item != null) {statuesTextArea.append("The PCB " + nowID + " has existed in Ready List!\n"+ "you need to modify the PID of the selected PCB!\n");while(item != null) {nowID = s + nowID;item = backupPCB.getItem(nowID);}}ProcessPCB newPCB = new ProcessPCB(nowID, s1, s2, "Ready");readyPCB.addItem(newPCB);sortReadyPCB();readyList.setListData(readyPCB.getItemsProperties());}class AddToBAKListener implements ActionListener {public void actionPerformed(ActionEvent event) {String newID = PIDTextField.getText();String newTime = requiredTimeTextField.getText();String newPriority = priorityTextField.getText();int s1 = 0, s2 = 0, tag1=-1, tag2=-1;if(newTime != null){s1 = readInteger(newTime);if(s1 > 0.0) tag1 = 1;else statuesTextArea.append("The neededTime must be a positive integer.\n");}if(newPriority != null){s2 = readInteger(newPriority);if(s1 != -999) tag2 = 1;else statuesTextArea.append("The priority must be an integer.\n");}if(tag1 ==1 && tag2 == 1 ) {if(newID == null) {statuesTextArea.append("The value of ID mustn't be null!\n");} else {addToBackupList(newID, s1, s2, "B");statuesTextArea.append("The PCB record item has been added to BackupList!\n");reset();}}}}class AddToReadyListener implements ActionListener {public void actionPerformed(ActionEvent event) {String nowID = PIDTextField.getText();String time = requiredTimeTextField.getText();String priority = priorityTextField.getText();int s1 = 0, s2 = 0;int tag1 = -1, tag2 = -1;if(time != null){s1 = readInteger(time);if(s1 > 0.0) tag1=1;else statuesTextArea.append("The neededTime must be a positive integer.\n");}if(priority != null){s2 = readInteger(priority);if(s2 != -999) tag2=1;else statuesTextArea.append("The priority must be an integer.\n");}if(tag1 ==1 && tag2 == 1) {if(nowID == null) {statuesTextArea.append("The value of ID mustn't be null!\n");} else {if(readyPCB.getNumberOfItems() < 6) {addToReadyList(nowID, s1, s2, "R");statuesTextArea.append("The student record item has been added to ReadyList!\n");} else {statuesTextArea.append("The ReadyList was full! The new ProcessPCB will be added to BackupList!\n");addToBackupList(nowID, s1, s2, "b");statuesTextArea.append("The student record item has been added to BackupList!\n");}reset();}}}}public void reset() {PIDTextField.setText("");requiredTimeTextField.setText("");priorityTextField.setText("");statusTextField.setText("");}/*** This inner class processes <code>resetButton</code> events.*/class ResetListener implements ActionListener {public void actionPerformed(ActionEvent event) {reset();}}/*** This inner class processes <code>suspendButton</code> events.*///注：在挂起时，不会触发进程调度，而是在点击"startSyatemJButton"时才会出发进程调度class SuspendListener implements ActionListener {/*** Removes an order item from the current order.** @param event the event object.*/public void actionPerformed(ActionEvent event) {String selectedReadyItem = null;String pid = "";if(readyPCB.getNumberOfItems() == 0){statuesTextArea.append("The readyList is empty!\n");} else {selectedReadyItem = (String) readyList.getSelectedValue();if(selectedReadyItem == null) {statuesTextArea.append("Please select an item from the ready list!\n");} else{StringTokenizer stringtokenizer = new StringTokenizer(selectedReadyItem, "_");pid = stringtokenizer.nextToken();ProcessPCB selectedItem = readyPCB.getItem(pid);if(selectedItem == null) {statuesTextArea.append("No student recorditem of Num " + pid + " is founded!\n");} else {ProcessPCB boolTtem = suspendedPCB.getItem(pid);if(boolTtem != null) {statuesTextArea.append("The PCB " + pid + " has existed in Suspend List!\n"+ "you need to modify the PID of the selected PCB!\n");while(boolTtem != null) {pid = "X" + pid;boolTtem = suspendedPCB.getItem(pid);}}ProcessPCB newPcb = new ProcessPCB(pid, selectedItem.getRequiredTime(),selectedItem.getPriority(),"Suspended");suspendedPCB.addItem(newPcb);readyPCB.removeItem(selectedItem);sortReadyPCB(); //注意考虑一下suspendList.setListData(suspendedPCB.getItemsProperties());readyList.setListData(readyPCB.getItemsProperties());statuesTextArea.append("The product has been suspended!\n"); suspendTotalTextField.setText(Integer.toString(suspendedPCB.getNumberOfItems()));}}}}}public void sortReadyPCB() {PCBRecords currentReadyPCB = new PCBRecords();int num = readyPCB.getNumberOfItems();if(num > 0) {for(int i=num; i>=1; i--) {Iterator readyIterator = readyPCB.iterator();ProcessPCB currentItem = (ProcessPCB) readyIterator.next();for( ; readyIterator.hasNext(); ) {ProcessPCB nowItem = (ProcessPCB) readyIterator.next();if(currentItem.getPriority() < nowItem.getPriority()) {currentItem = null;currentItem = nowItem;}}currentReadyPCB.addItem(currentItem);readyPCB.removeItem(currentItem);}readyPCB = null;readyPCB = currentReadyPCB;}}/*** This inner class processes <code>umountButton</code> events.。

操作系统实验报告java操作系统实验报告一、实验目的本次实验旨在通过编写Java程序来实现一个简单的操作系统模拟，以加深对操作系统的理解。

二、实验环境- 操作系统：Windows 10- Java开发环境：Eclipse- 编程语言：Java三、实验内容⒈实现进程管理⑴进程创建⑵进程调度⑶进程同步⑷进程通信⒉实现内存管理⑴内存分配⑵内存回收⑶页面置换算法⒊文件系统管理⑴文件的创建与删除⑵文件的读写操作⑶文件权限控制四、实验步骤及代码实现⒈进程管理实现步骤⑴定义进程类⑵实现进程创建方法⑶实现进程调度方法⑷实现进程同步方法⑸实现进程通信方法⒉内存管理实现步骤⑴定义内存管理类⑵实现内存分配方法⑶实现内存回收方法⑷实现页面置换算法⒊文件系统管理实现步骤⑴定义文件类⑵实现文件的创建与删除方法⑶实现文件的读写操作方法⑷实现文件权限控制方法五、实验结果与分析在完成以上步骤后，我们成功实现了一个简单的操作系统模拟。

通过模拟进程管理、内存管理和文件系统管理等功能，可以更好地理解操作系统的工作原理和机制。

六、实验附件本实验报告附带Java程序源代码和运行结果截图，请参见附件。

七、法律名词及注释⒈操作系统：指一类管理计算机硬件和软件资源、控制程序运行的系统软件。

⒉进程：操作系统中的基本执行单位，每个进程拥有独立的地质空间和系统资源。

⒊进程调度：操作系统根据一定的策略和算法决定哪个进程在给定时刻执行。

⒋进程同步：多个进程之间的协调工作，保证数据的一致性和并发执行正确性。

⒌进程通信：进程之间通过某种方式交换信息和数据。

⒍内存分配：为进程分配内存空间，使其能够运行。

⒎内存回收：在进程终止或需要更多内存时，将内存空间释放。

⒏页面置换算法：在内存不足时，选择合适的页面进行置换以获取更多空闲内存。

⒐文件系统：操作系统管理文件和目录的组织和存储方式。

⒑文件的创建与删除：操作系统创建或删除文件，为文件分配或回收存储空间。

1⒈文件的读写操作：操作系统对文件进行读取或写入数据的操作。