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

操作系统实验报告java操作系统实验报告实验名称：java操作系统一、实验目的本次实验的目的是通过使用Java编程语言，实现一个简单的操作系统，包括进程管理、内存管理和文件系统管理。

二、实验环境操作系统：Windows 10开发工具：Eclipse IDE编程语言：Java三、实验过程及结果1、进程管理1.1 进程的创建编写一个Process类，模拟进程的创建过程，包括进程ID、状态等属性，并实现创建进程的方法。

1.2 进程的调度设计一个Scheduler类，实现进程的调度算法，如FCFS（先来先服务）、SJF（短作业优先）、RR（时间片轮转）等。

1.3 进程间通信实现进程间的通信机制，如共享内存、管道等。

2、内存管理2.1 内存分配算法设计一个MemoryAllocator类，实现内存分配的算法，如首次适应、最佳适应、最坏适应等。

2.2 内存回收实现一个MemoryReclmer类，用于回收已经释放的内存空间，并将其标记为可再分配的状态。

3、文件系统管理3.1 文件的创建与删除设计一个类，实现文件的创建和删除功能，包括文件名、大小等属性。

3.2 文件的读取与写入实现一个类和一个类，分别用于文件的读取和写入操作。

3.3 文件权限管理设计一个AccessControl类，用于控制文件的访问权限，包括读、写和执行等操作。

四、实验结果分析根据实验过程的描述，我们成功实现了一个简单的操作系统，包括进程管理、内存管理和文件系统管理。

在进程管理方面，我们实现了进程的创建、调度和通信机制，能够有效管理多个进程的执行。

在内存管理方面，我们实现了不同的内存分配算法，能够根据实际情况分配和回收内存空间。

在文件系统管理方面，我们实现了文件的创建、删除、读取和写入操作，并能够灵活控制文件的访问权限。

五、附件无六、法律名词及注释1、版权：根据著作权法，著作权人享有其作品的署名权、发表权、修改权和保护权等权利。

2、许可证：指授权他人使用某个著作权作品的合法许可证。

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

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

二、实验环境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 资源给各个进程，以提高系统的整体性能和资源利用率。

通过本次实验，我们旨在深入理解进程调度的原理和算法，掌握进程状态的转换，观察不同调度策略对系统性能的影响，并通过实际编程实现来提高我们的编程能力和对操作系统概念的理解。

二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 C+＋，开发工具为 Visual Studio 2019。

三、实验原理1、进程状态进程在其生命周期中会经历不同的状态，包括就绪态、运行态和阻塞态。

就绪态表示进程已经准备好执行，只等待 CPU 分配；运行态表示进程正在 CPU 上执行；阻塞态表示进程由于等待某个事件（如 I/O操作完成）而暂时无法执行。

2、调度算法常见的进程调度算法有先来先服务（FCFS）、短作业优先（SJF）、时间片轮转（RR）等。

先来先服务算法按照进程到达的先后顺序进行调度。

短作业优先算法优先调度执行时间短的进程。

时间片轮转算法将 CPU 时间划分成固定大小的时间片，每个进程轮流获得一个时间片执行。

四、实验内容1、设计并实现一个简单的进程调度模拟器定义进程结构体，包含进程 ID、到达时间、执行时间、剩余时间等信息。

实现进程的创建、插入、删除等操作。

实现不同的调度算法。

2、对不同调度算法进行性能测试生成一组具有不同到达时间和执行时间的进程。

分别采用先来先服务、短作业优先和时间片轮转算法进行调度。

记录每个算法下的平均周转时间、平均等待时间等性能指标。

五、实验步骤1、进程结构体的定义｀｀｀c+＋struct Process ｛int pid;int arrivalTime;int executionTime;int remainingTime;int finishTime;int waitingTime;int turnaroundTime;｝；｀｀｀2、进程创建函数｀｀｀c+＋void createProcess(Process processes, int& numProcesses, int pid, int arrivalTime, int executionTime) ｛processesnumProcessespid ＝ pid;processesnumProcessesarrivalTime ＝ arrivalTime;processesnumProcessesexecutionTime ＝ executionTime;processesnumProcessesremainingTime ＝ executionTime;numProcesses+＋；｝｀｀｀3、先来先服务调度算法实现｀｀｀c+＋void fcfsScheduling(Process processes, int numProcesses) ｛int currentTime ＝ 0;for （int i ＝ 0; i ＜ numProcesses; i+＋）｛if （currentTime ＜ processesiarrivalTime) ｛currentTime ＝ processesiarrivalTime;｝processesistartTime ＝ currentTime;currentTime ＋＝ processesiexecutionTime;processesifinishTime ＝ currentTime;processesiwaitingTime ＝ processesistartTime processesiarrivalTime;processesiturnaroundTime ＝ processesifinishTime processesiarrivalTime;｝｝｀｀｀4、短作业优先调度算法实现｀｀｀c+＋void sjfScheduling(Process processes, int numProcesses) ｛int currentTime ＝ 0;int minExecutionTime, selectedProcess;bool found;while （true) ｛found ＝ false;minExecutionTime ＝ INT_MAX;selectedProcess ＝－1;for （int i ＝ 0; i ＜ numProcesses; i+＋）｛if （processesiarrivalTime ＜＝ currentTime ＆＆processesiremainingTime ＜ minExecutionTime ＆＆processesiremainingTime ＞ 0) ｛found ＝ true;minExecutionTime ＝ processesiremainingTime;selectedProcess ＝ i;｝｝if （！found) ｛break;｝processesselectedProcessstartTime ＝ currentTime;currentTime ＋＝ processesselectedProcessremainingTime;processesselectedProcessfinishTime ＝ currentTime;processesselectedProcesswaitingTime ＝processesselectedProcessstartTime processesselectedProcessarrivalTime;processesselectedProcessturnaroundTime ＝processesselectedProcessfinishTime processesselectedProcessarrivalTime;processesselectedProcessremainingTime ＝ 0;｝｝｀｀｀5、时间片轮转调度算法实现｀｀｀c+＋void rrScheduling(Process processes, int numProcesses, int timeSlice) ｛int currentTime ＝ 0;Queue<int> readyQueue;for （int i ＝ 0; i ＜ numProcesses; i+＋）｛readyQueueenqueue(i)；｝while （！readyQueueisEmpty(））｛int currentProcess ＝ readyQueuedequeue(）；if （processescurrentProcessarrivalTime ＞ currentTime) ｛currentTime ＝ processescurrentProcessarrivalTime;｝if （processescurrentProcessremainingTime ＜＝ timeSlice) ｛currentTime ＋＝ processescurrentProcessremainingTime;processescurrentProcessfinishTime ＝ currentTime;processescurrentProcesswaitingTime ＝processescurrentProcessstartTime processescurrentProcessarrivalTime;processescurrentProcessturnaroundTime ＝processescurrentProcessfinishTime processescurrentProcessarrivalTime;processescurrentProcessremainingTime ＝ 0;｝ else ｛currentTime ＋＝ timeSlice;processescurrentProcessremainingTime ＝ timeSlice;readyQueueenqueue(currentProcess)；｝｝｝｀｀｀6、性能指标计算函数｀｀｀c+＋void calculatePerformanceMetrics(Process processes, int numProcesses, double& averageWaitingTime, double& averageTurnaroundTime) ｛double totalWaitingTime ＝ 0, totalTurnaroundTime ＝ 0;for （int i ＝ 0; i ＜ numProcesses; i+＋）｛totalWaitingTime ＋＝ processesiwaitingTime;totalTurnaroundTime ＋＝ processesiturnaroundTime;｝averageWaitingTime ＝ totalWaitingTime ／ numProcesses; averageTurnaroundTime ＝ totalTurnaroundTime ／ numProcesses;｝｀｀｀7、主函数｀｀｀c+＋int main(）｛Process processes100;int numProcesses ＝ 0;／／创建进程createProcess(processes, numProcesses, 1, 0, 5)；createProcess(processes, numProcesses, 2, 1, 3)；createProcess(processes, numProcesses, 3, 2, 4)；createProcess(processes, numProcesses, 4, 3, 2)；／／先来先服务调度fcfsScheduling(processes, numProcesses)；double fcfsAverageWaitingTime, fcfsAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, fcfsAverageWaitingTime, fcfsAverageTurnaroundTime)；cout ＜＜＂先来先服务调度的平均等待时间：＂＜＜fcfsAverageWaitingTime ＜＜ endl;cout ＜＜＂先来先服务调度的平均周转时间：＂＜＜fcfsAverageTurnaroundTime ＜＜ endl;／／短作业优先调度sjfScheduling(processes, numProcesses)；double sjfAverageWaitingTime, sjfAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, sjfAverageWaitingTime, sjfAverageTurnaroundTime)；cout ＜＜＂短作业优先调度的平均等待时间：＂＜＜sjfAverageWaitingTime ＜＜ endl;cout ＜＜＂短作业优先调度的平均周转时间：＂＜＜sjfAverageTurnaroundTime ＜＜ endl;／／时间片轮转调度（时间片为 2）rrScheduling(processes, numProcesses, 2)；double rrAverageWaitingTime, rrAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, rrAverageWaitingTime, rrAverageTurnaroundTime)；cout ＜＜＂时间片轮转调度（时间片为 2）的平均等待时间：＂＜＜ rrAverageWaitingTime ＜＜ endl;cout ＜＜＂时间片轮转调度（时间片为 2）的平均周转时间：＂＜＜ rrAverageTurnaroundTime ＜＜ endl;return 0;｝｀｀｀六、实验结果与分析1、先来先服务调度平均等待时间：40平均周转时间：85分析：先来先服务调度算法简单直观，但对于短作业可能会造成较长的等待时间，导致平均等待时间和平均周转时间较长。

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

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

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

一、进程调度的概念进程调度是操作系统中的一个重要组成部分，它负责决定哪个进程可以使用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操作系统之上。

源代码：第一个类：divDTOpublic class divDTO{private int divBase;private int length;private int divFlag;public divDTO(int divBase,int length,int divFlag) { this.divBase = divBase;this.divFlag = divFlag;this.length = length;}public divDTO(){}public void setDivBase(int base){this.divBase = base;}public int getDivBase(){return this.divBase;}public void setLength(int length){this.length = length;}public int getLength() {return this.length;}public void setDivFlag(int flag){this.divFlag = flag;}public int getDivFalg(){return this.divFlag;2.第二个类：PcbDTOpublic class PcbDTO{static final int Running = 1;static final int Ready = 2;static final int Waiting = 3;private String processName;private int runTime;private int prority;private int processState;private int base;private int limit;private int pcbFlag;public PcbDTO(String name, int time,int pro,int base,int limit) {this.processName = name;this.runTime = time;this.prority = pro;this.processState = 0;this.limit = limit;this.base = base;}public PcbDTO(){this.pcbFlag = 0;}public void setProcessName(String name){this.processName = name;}public String getProcessName(){return processName;}public void setRunTime(int time){this.runTime = time;}public int getRunTime(){return this.runTime;public void setPrority(int prority) {this.prority = prority;}public int getPrority() {return this.prority;}public void setProcessState(int state) {this.processState = state;}public String getProcessState(){String s = new String(); if(this.processState == 1) {s = "running";}else if(this.processState == 2){s = "ready";}else if(this.processState == 3){s = "waiting";} return s;} public int getBase() {return this.base;} public void setBase(int base) {this.base = base;} public void setLimit(int limit){this.limit = limit;}public int getLimit(){return this.limit;}第三个类：主类import javax.swing.*;import java.util.*;import java.awt.*;import java.awt.event.*;import javax.swing.event.*;public class MainFrame {private JList readyList;private JList waitingList;private JList jobList;private JButton susButton;private JButton relaxButton;private JButton startButton;private JButton newButton;private JLabel nameLabel;private JLabel prorityLabel;private JLabel timeLabel;private JLabel jobLabel;private JLabel readyLabel;private JLabel waitingLabel;private JLabel runningLabel;private JLabel spaceLabel;private JLabel divLabel;private JLabel allocLabel;private JTable readyTable;private JTable runningTable;private JTable divTable;private JTable allocTable;private JTextField nameText;private JTextField timeText;private JTextField spaceText;private JComboBox prorityCom;private JPanel newPanel;private JPanel waitingPanel;private JPanel readyPanel;Vector jobVectorName;Vector jobDtoVector;Vector waitingVectorName;Vector waitingDtoVector;PcbDTO []readyDtoArray;PcbDTO []newDtoArray;divDTO []divDtoArray;PcbDTO []newSort;Object[][] readydata;Object[][] runningdata;Object[][] divdata;Object[][] allocdata;int first;int end;int point;PcbDTO a ;public MainFrame(){a = new PcbDTO();first = 0;end = 0;point = 0;JFrame jf = new JFrameC进程调度-ws");Container c = jf.getContentPane();c.setLayout(null);//c.setBackground(Color.pink);newPanel = new JPanel();newPanel.setLayout(null);waitingPanel = new JPanel();waitingPanel.setLayout(null);//waitingPanel.setBackground(Color.pink);readyPanel = new JPanel();readyPanel.setLayout(null);susButton = new JButton(" 挂起");relaxButton = new JButton(" 释放");startButton = new JButton(" 开始");newButton = new JButton(" 新建进程");nameLabel = new JLabel("进程名"); prorityLabel = new JLabel(" 优先级"); timeLabel = new JLabel("运行时间");jobLabel = new JLabel("后备队列")； readyLabel =new JLabel("就绪队歹U "); waitingLabel = newJLabel("等待队歹U "); runningLabel = new JLabel("运行进程"); spaceLabel = new JLabel.需要空间");divLabel = new JLabel("未分分区表"); allocLabel = new JLabel("内存分配表");nameText = new JTextField();timeText = new JTextField();spaceText = new JTextField(); prorityCom = new JComboBox(); prorityCom.setToolTipText(" 优先级");readyDtoArray = new PcbDTO[6]; newSort = new PcbDTO[6];for(int i = 0; i< 6;i++) {newSort[i] = new PcbDTO();}newDtoArray = new PcbDTO[100];jobDtoVector = new Vector(); jobVectorName = new Vector(); waitingDtoVector = new Vector(); waitingVectorName = new Vector(); divDtoArray = new divDTO[20];for(int i = 0; i < 20; i++) {divDtoArray[i] = new divDTO();divDtoArray[i].setDivFlag(0);}divDtoArray[0].setDivFlag(1);divDtoArray[0].setDivBase(20);divDtoArray[0].setLength(180); readydata = new Object[6][4]; runningdata = new Object[2][3]; divdata = new Object[20][3]; allocdata = new Object[20][3];String []col1 = {" 进程","时间","优先级","状态"};String []col2 = {" 进程","时间","优先级"}; String []col3 = {" 起址","长度","状态"};String []col4 = {"起址","长度","占用进程"}; readyTable = new JTable(readydata,col1);//readyTable.setEnabled(false);runningTable = new JTable(runningdata,col2); runningTable.setRowHeight(22);runningTable.setEnabled(false);allocTable = new JTable(allocdata,col4); allocTable.setEnabled(false);divTable = new JTable(divdata,col3);divTable.setEnabled(false);divTable.setValueAt(String.valueOf(20),0,0); divTable.setValueAt(String.valueOf(180),0,1); divTable.setValueAt(String.valueOf(1),0,2); JScrollPane runningSP = new JScrollPane(); JScrollPane readySP2 = new JScrollPane(); JScrollPane divSP = new JScrollPane();JScrollPane allocSP = new JScrollPane(); runningSP.getViewport().add(runningTable);readySP2.getViewport().add(readyTable);divSP.getViewport().add(divTable);allocSP.getViewport().add(allocTable);//int []prorityArray = new int[10];for(int i = 0;i < 10;i++){ prorityCom.addItem(i);//prorityArray[i] = i;}jobList = new JList();waitingList = new JList();JScrollPane readySP = new JScrollPane(readyList); JScrollPane jobSP = new JScrollPane(jobList); JScrollPane waitingSP = new JScrollPane(waitingList);newPanel.setSize(450,100);newPanel.setLocation(0,0);nameLabel.setSize(80,20);nameLabel.setLocation(10,5);nameText.setSize(100,25);nameText.setLocation(10,30);prorityLabel.setSize(80,20);prorityLabel.setLocation(120,5);prorityCom.setSize(100,25);prorityCom.setLocation(120,30);timeLabel.setSize(80,20);timeLabel.setLocation(230,5);timeText.setSize(100,25);timeText.setLocation(230,30);spaceLabel.setSize(80,20);spaceLabel.setLocation(340,5);spaceText.setSize(100,25);spaceText.setLocation(340,30);newButton.setSize(100,20);newButton.setLocation(320,70);waitingPanel.setSize(190,410);waitingPanel.setLocation(0,100);jobLabel.setSize(100,20);jobLabel.setLocation(10,2);jobSP.setSize(180,105); jobSP.setLocation(10,25); waitingLabel.setSize(100,20); waitingLabel.setLocation(10,129); waitingSP.setSize(180,105); waitingSP.setLocation(10,150); divLabel.setSize(100,20); divLabel.setLocation(10,253); divSP.setSize(180,113);divSP.setLocation(10,273); relaxButton.setSize(80,20); relaxButton.setLocation(110,388);readyPanel.setSize(260,410); readyPanel.setLocation(190,100);readyLabel.setSize(100,22); readyLabel.setLocation(10,2); allocLabel.setSize(100,20); allocLabel.setLocation(10,232); startButton.setSize(80,20); startButton.setLocation(177,388);susButton.setSize(80,20);susButton.setLocation(95,388); readySP2.setSize(250,117);readySP2.setLocation(10,25); runningLabel.setLocation(10,142);runningLabel.setSize(100,20);runningSP.setSize(250,65);runningSP.setLocation(10,167); allocSP.setSize(250,130);allocSP.setLocation(10,255);c.add(newPanel);newPanel.add(nameLabel); newPanel.add(nameText);newPanel.add(prorityLabel); newPanel.add(prorityCom);newPanel.add(timeText); newPanel.add(timeLabel);newPanel.add(newButton); newPanel.add(spaceLabel);newPanel.add(spaceText);c.add(waitingPanel);waitingPanel.add(jobLabel); waitingPanel.add(jobSP);waitingPanel.add(waitingLabel); waitingPanel.add(waitingSP);waitingPanel.add(divLabel); waitingPanel.add(divSP);waitingPanel.add(relaxButton);c.add(readyPanel);readyPanel.add(readyLabel); readyPanel.add(allocLabel);readyPanel.add(runningLabel); readyPanel.add(startButton);readyPanel.add(susButton); readyPanel.add(allocSP);readyPanel.add(runningSP);readyPanel.add(readySP2);jf.setSize(470,550);jf.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);jf.setLocationRelativeTo(null);jf.setVisible(true);startButton.addActionListener(new MyActionListener());newButton.addActionListener(new MyActionListener());susButton.addActionListener(new MyActionListener());relaxButton.addActionListener(new MyActionListener());}public void sus(){try{Thread.sleep(1000);}catch(Exception ex){}}class MyActionListener implements ActionListener{public void actionPerformed(ActionEvent e){int count = 0;PcbDTO test = new PcbDTO();JButton jb = (JButton)e.getSource();int max = -1;if(jb == startButton) {//while(true)//{int runAllocFlag = -1;if((String)runningTable.getValueAt(0,0)==null||(String)runningTable.getValueAt(0,0)=="") {try{Thread.sleep(0);}catch(Exception ex)}//System.out.println(" 到3");for(int j = first;j != end; ){if(!readyDtoArray[j].getProcessState().equals("waiting")) {max = j;break;}j = (j+1)%6;} for(int j = first;j%6 != end; ) {if(!readyDtoArray[j].getProcessState().equals("waiting")) {if(readyDtoArray[j].getPrority() readyDtoArray[max].getPrority()){max = j;}}j = (j+1)%6;}if(max>=0){a = readyDtoArray[max];readyDtoArray[max] = readyDtoArray[first];readyDtoArray[first] = a;readyTable.setValueAt(readyDtoArray[max].getProcessName(),max,0);readyTable.setValueAt(readyDtoArray[max].getRunTime(),max,1);readyTable.setValueAt(readyDtoArray[max].getPrority(),max,2);readyTable.setValueAt(readyDtoArray[max].getProcessState(),max,3);readyTable.setValueAt("",first,0);readyTable.setValueAt("",first,1);readyTable.setValueAt("",first,2);readyTable.setValueAt("",first,3);runningTable.setValueAt(a.getProcessName(),0,0);runningTable.setValueAt(a.getRunTime(),0,1);runningTable.setValueAt(a.getPrority(),0,2);readyDtoArray[first].setRunTime(readyDtoArray[first].getRunTime()-1);if(0 != readyDtoArray[first].getPrority()) {readyDtoArray[first].setPrority(readyDtoArray[first].getPrority()-1); }first = (first+1)%6;} else{ System.out.println("cpu 等待中....... ");}} else{/*try{Thread.sleep(2000);}catch(InterruptedException e1){System.out.println(e1);}*///System.out.println(" 到1");runningTable.setValueAt("",0,0);runningTable.setValueAt("",0,1);runningTable.setValueAt("",0,2);// 如果运行时间为0 那么撤销进程, 否那么将进程重新添加到就绪队列中if( a.getRunTime()<=0){ // 收回内存空间for(int i = 0;i < point; i++){if(newSort[i].getBase()>=a.getBase()) newSort[i] =newSort[i+1];}}point--;// 设置内存分配表的内容for(int i = 0; i < point;i++) {allocTable.setValueAt(String.valueOf(newSort[i].getBase()),i,0);allocTable.setValueAt(String.valueOf(newSort[i].getLimit()),i,1);allocTable.setValueAt(newSort[i].getProcessName(),i,2);}allocTable.setValueAt("",point,0);allocTable.setValueAt("",point,1);allocTable.setValueAt("",point,2);// 把收回的内存参加到记录未分分区的数组int memoryEnd = 0;int location = 0;int up = -1;//int down = -1;for(int i = 0;i<20;i++){if(divDtoArray[i].getDivFalg() == 1){memoryEnddivDtoArray[i].getDivBase()+divDtoArray[i].getLength();if(memoryEnd == a.getBase()){up = i;}if(divDtoArray[i].getDivBase()(a.getBase()+a.getLimit())){ down = i;}}}if(up >= 0&&down >= 0){divDtoArray[up].setLength((divDtoArray[up].getLength()+a.getLimit()+divDtoArray[down].ge tLength()));divDtoArray[down].setDivFlag(0);for(int i = (down+1); i < 20;i++){if(divDtoArray[i].getDivFalg() == 1){divDtoArray[i-1].setDivBase(divDtoArray[i].getDivBase());divDtoArray[i-1].setDivFlag(1);divDtoArray[i-1].setLength(divDtoArray[i].getLength());divDtoArray[i].setDivFlag(0);} else{divTable.setValueAt("",i-1,0);divTable.setValueAt("",i-1,1);divTable.setValueAt("",i-1,2); break;}}}else if(up >= 0&&down < 0){divDtoArray[up].setLength((divDtoArray[up].getLength()+a.getLimit()));}else if(up < 0&&down >= 0){divDtoArray[down].setLength((divDtoArray[down].getLength()+a.getLimit()));divDtoArray[down].setDivBase(a.getBase());}else if(up < 0&&down < 0){for(int i = 0; i < 20; i++){if(divDtoArray[i].getDivBase()>a.getBase()||divDtoArray[i].getDivFalg()==0){location = i; break;}}for(int i = 20; i >location;i--)if(divDtoArray[i-1].getDivFalg()==1) {divDtoArray[i].setDivBase(divDtoArray[i-1].getDivBase());divDtoArray[i].setDivFlag(1);divDtoArray[i].setLength(divDtoArray[i-1].getLength());}}divDtoArray[location].setDivBase(a.getBase());divDtoArray[location].setDivFlag(1);divDtoArray[location].setLength(a.getLimit());}// 设置未分分区表的内容for(int i = 0; i < 20;i++) {if(divDtoArray[i].getDivFalg()==1) {divTable.setValueAt(String.valueOf(divDtoArray[i].getDivBase()),i,0);divTable.setValueAt(String.valueOf(divDtoArray[i].getLength()),i,1);divTable.setValueAt(String.valueOf(divDtoArray[i].getDivFalg()),i,2);}} if(!jobDtoVector.isEmpty()){int runLength = 0;PcbDTO jobToReady = (PcbDTO)jobDtoVector.elementAt(0);for(int i = 0; i < 20; i++) {if(divDtoArray[i].getDivFalg() == 1){if(divDtoArray[i].getLength()>=jobToReady.getLimit()){runAllocFlag = i; break;}if(runAllocFlag >= 0) {jobDtoVector.removeElementAt(0);jobVectorName.remove(jobVectorName.indexOf(jobToReady.getProcessName()));jobList.setListData(jobVectorName);jobToReady.setProcessState(PcbDTO.Ready);jobToReady.setBase(divDtoArray[runAllocFlag].getDivBase());runLength = divDtoArray[runAllocFlag].getLength()- jobToReady.getLimit();if(runLength == 0){int i = runAllocFlag;divDtoArray[i].setDivFlag(0);for(; i < 19;i++) {if(divDtoArray[i+1].getDivFalg() == 1){divDtoArray[i] = divDtoArray[i+1];divDtoArray[i+1].setDivFlag(0);}divTable.setValueAt(String.valueOf(divDtoArray[i].getDivBase()),i,0);divTable.setValueAt(String.valueOf(divDtoArray[i].getLength()),i,1);divTable.setValueAt(String.valueOf(divDtoArray[i].getDivFalg()),i,2);}divTable.setValueAt(String.valueOf(divDtoArray[i].getDivFalg()),i,2);}else if(runLength > 0){int c2 = divDtoArray[runAllocFlag].getDivBase()+ jobToReady.getLimit();divDtoArray[runAllocFlag].setDivBase(c2);divDtoArray[runAllocFlag].setLength(runLength);divTable.setValueAt(String.valueOf(c2),runAllocFlag,0);divTable.setValueAt(String.valueOf(runLength),runAllocFlag,1);divTable.setValueAt(String.valueOf(divDtoArray[runAllocFlag].getDivFalg()),runAllocFlag,2);}readyDtoArray[end] = jobToReady;readyTable.setValueAt(jobToReady.getProcessName(),end,0);readyTable.setValueAt(jobToReady.getRunTime(),end,1);readyTable.setValueAt(jobToReady.getPrority(),end,2);readyTable.setValueAt(jobToReady.getProcessState(),end,3);end = (end+1)%6;int runi = 0;〃用于记录当前新生成的PcbDTO对象应该插入到newSort 中的位置for(; runi < point; runi++){if(jobToReady.getBase() < newSort[runi].getBase()){break;}}// 如果不是插入到数组末尾, 那么把比它大的都向后挪一位并设置JTable中的显示for(int i = point; i > runi; i--){newSort[i] = newSort[i-1];allocTable.setValueAt(String.valueOf(newSort[i].getBase()),i,0);allocTable.setValueAt(String.valueOf(newSort[i].getLimit()),i,1);allocTable.setValueAt(newSort[i].getProcessName(),i,2);}// 插入新生成的对象newSort[runi] = jobToReady;allocTable.setValueAt(String.valueOf(jobToReady.getBase()),runi,0);allocTable.setValueAt(String.valueOf(jobToReady.getLimit()),runi,1);allocTable.setValueAt(jobToReady.getProcessName(),runi,2); point++;}}}else{readyDtoArray[end] = a;readyTable.setValueAt(a.getProcessName(),end,0);readyTable.setValueAt(a.getRunTime(),end,1);readyTable.setValueAt(a.getPrority(),end,2);readyTable.setValueAt(a.getProcessState(),end,3); end =(end+1)%6;}}//}}else if(jb == newButton){int newAllocFlag = -1;int newLength = 0;if(nameText.getText().trim().length() == 0){JOptionPane.showMessageDialog(null," 进程名不能为空！");}else if(timeText.getText().trim().length() == 0){JOptionPane.showMessageDialog(null," 运行时间不能为空");}else if(spaceText.getText().trim().length() == 0){JOptionPane.showMessageDialog(null," 空间不能为空");}else{test.setRunTime(Integer.parseInt(timeText.getText()));test.setLimit(Integer.parseInt(spaceText.getText()));String s = prorityCom.getSelectedItem().toString();test.setPrority(Integer.parseInt(s));test.setProcessName(nameText.getText().trim());newDtoArray[count] = test;jobDtoVector.add(newDtoArray[count]);jobVectorName.add(newDtoArray[count].getProcessName());jobList.setListData(jobVectorName);count++;nameText.setText("");timeText.setText("");spaceText.setText("");PcbDTO b = (PcbDTO)jobDtoVector.elementAt(0);for(int i = 0; i < 20; i++){if(divDtoArray[i].getDivFalg() == 1){if(divDtoArray[i].getLength() >= b.getLimit()) {newAllocFlag = i; break;}// 在就绪队列未满且内存有足够空间时将后备队列jobDtoVetor 中的对象添加到就绪队列中if((end + 2)%6 != first&&newAllocFlag >= 0) {jobDtoVector.removeElementAt(0);b.setProcessState(PcbDTO.Ready);b.setBase(divDtoArray[newAllocFlag].getDivBase());newLength = divDtoArray[newAllocFlag].getLength()- b.getLimit();if(newLength == 0){int i = newAllocFlag;divDtoArray[i].setDivFlag(0);for(; i < 19;i++){if(divDtoArray[i+1].getDivFalg() == 1) {divDtoArray[i] = divDtoArray[i+1];divDtoArray[i+1].setDivFlag(0);divTable.setValueAt(String.valueOf(divDtoArray[i].getDivBase()),i,0);divTable.setValueAt(String.valueOf(divDtoArray[i].getLength()),i,1);divTable.setValueAt(String.valueOf(divDtoArray[i].getDivFalg()),i,2); }divTable.setValueAt(String.valueOf(divDtoArray[i].getDivFalg()),i,2);}else if(newLength > 0){int c1 = divDtoArray[newAllocFlag].getDivBase()+ b.getLimit();divDtoArray[newAllocFlag].setDivBase(c1);divDtoArray[newAllocFlag].setLength(newLength);divTable.setValueAt(String.valueOf(c1),newAllocFlag,0);divTable.setValueAt(String.valueOf(newLength),newAllocFlag,1);divTable.setValueAt(String.valueOf(divDtoArray[newAllocFlag].getDivFalg()),newAllocFlag,2);}readyDtoArray[end] = b;jobVectorName.remove(jobVectorName.indexOf(b.getProcessName()));readyTable.setValueAt(b.getProcessName(),end,0);readyTable.setValueAt(b.getRunTime(),end,1);readyTable.setValueAt(b.getPrority(),end,2);readyTable.setValueAt("ready",end,3);end =(end+1)%6;int newi = 0;//用于记录当前新生成的PcbDTO对象应该插入到newSort 中的位置for(; newi < point; newi++){if(b.getBase() < newSort[newi].getBase()) {break;}}// 如果不是插入到数组末尾, 那么把比它大的都向后挪一位并设置JTable中的显示for(int i = point; i > newi; i--){newSort[i] = newSort[i-1];allocTable.setValueAt(String.valueOf(newSort[i].getBase()),i,0);allocTable.setValueAt(String.valueOf(newSort[i].getLimit()),i,1);allocTable.setValueAt(newSort[i].getProcessName(),i,2);}// 插入新生成的对象newSort[newi] = b;allocTable.setValueAt(String.valueOf(b.getBase()),newi,0);allocTable.setValueAt(String.valueOf(b.getLimit()),newi,1);allocTable.setValueAt(b.getProcessName(),newi,2); point++;}}}else if(jb == susButton){if(readyDtoArray[readyTable.getSelectedRow()] != null){if(!readyDtoArray[readyTable.getSelectedRow()].getProcessState().equals("waiting")){readyDtoArray[readyTable.getSelectedRow()].setProcessState(PcbDTO.Waiting);readyTable.setValueAt("waiting",readyTable.getSelectedRow(),3); waitingDtoVector.add(readyDtoArray[readyTable.getSelectedRow()]);waitingVectorName.add(readyDtoArray[readyTable.getSelectedRow()].getProcessName());waitingList.setListData(waitingVectorName);}else{ System.out.println(" 已挂起");}}else{JOptionPane.showMessageDialog(null," 请选择要挂起的进程");//System.out.println(" 请选择要挂起的进程");else if(jb == relaxButton) {String s = (String)waitingList.getSelectedValue();if(s != null){waitingVectorName.remove(s);PcbDTO p = new PcbDTO();for(int i = 0; i < waitingDtoVector.size(); i++) {p = (PcbDTO)waitingDtoVector.elementAt(i);if(s.equals(p.getProcessName())){p.setProcessState(PcbDTO.Ready);waitingDtoVector.remove(p);break;}}for(int i = 0;i < 6;i++){if(s.equals(readyDtoArray[i].getProcessName())){readyTable.setValueAt("ready",i,3);break;}}waitingList.setListData(waitingVectorName);}else{JOptionPane.showMessageDialog(null," 请选择要解挂的进程");//System.out.println(" 没有选择的进程");}}}public static void main(String args[])new MainFrame();}}相关截图如下:运行后开始界面输入进程后界面建立后挂起挂起后各内存分配解挂 @请选撵要解挂的进程| ja,I L」操作异常时的提示 天It 避酉 内森外而慎。

操作系统实验(进程调度+存储管理+磁盘调度++银行家算法+文件系统设计实验一 进程调度一、 实验目的多道程序设计中，经常是假设干个进程同时处于就绪状态，必须依照某种策略来决定那个进程优先占有处理机。

因而引起进程调度。

本实验模拟在单处理机情形下的处理机调度问题，加深对进程调度的明白得。

二、 实验要求1． 设计进程调度算法，进程数不定2． 包含几种调度算法，并加以实现3． 输出进程的调度过程——进程的状态、链表等。

三、 参考例1．题目——优先权法、轮转法简化假设1） 进程为运算型的〔无I/O 〕2） 进程状态：ready 、running 、finish3） 进程需要的CPU 时刻以时刻片为单位确定2．算法描述1） 优先权法——动态优先权当前运行进程用完时刻片后，其优先权减去一个常数。

2） 轮转法四、 实验流程图 开始 键盘输入进程数n ，和调度方法的选择 优先权法？ 轮转法产生n 个进程，对每个进程产生一个PCB ，并用随机数产生进程的优先权及进程所需的CPU 时刻按优先权大小，把n 个进程拉成一个就绪队列撤销进程就绪队列为空？终止 N YY注意：1．产生的各种随机数的取值范畴加以限制，如所需的CPU 时刻限制在1~20之间。

2．进程数n 不要太大通常取4~8个3．使用动态数据结构4．独立编程5．至少三种调度算法6．假设有可能请在图形方式下，将PCB 的调度用图形成动画显示。

五．实验过程：〔1〕输入：进程流文件〔1.txt 〕，其中储备的是一系列要执行的进程， 每个作业包括四个数据项： 进程名 进程状态(1就绪 2等待 3运行) 所需时刻 优先数(0级最高)进程0 1 50 2进程1 2 10 4进程2 1 15 0进程3 3 28 5进程4 2 19 1进程5 3 8 7输出: 进程执行流等待时刻，平均等待时刻本程序包括:FIFO 算法，优先数调度算法，时刻片轮转调度算法产生n需的时刻片数，已占用CPU 的时刻片数置为0按进程产生的先后次序拉成就绪队列链=0？ 撤销该进程就绪队列为空吗？ =轮转时刻片数？NY YY 终止 N〔2〕程序代码#include<stdio.h>#include<string.h>#include<iostream.h>const int block_time=10; //定义时刻片的长度为10秒const int MAXPCB=100; //定义最大进程数//定义进程结构体typedef struct node{char name[20];int status;int time;int privilege;int finished;int wait_time; }pcb;pcb pcbs[MAXPCB];int quantity;//初始化函数void initial(){int i;for(i=0;i<MAXPCB;i++){strcpy(pcbs[i].name,"");pcbs[i].status=0;pcbs[i].time=0;pcbs[i].privilege=0;pcbs[i].finished=0;pcbs[i].wait_time=0;}quantity=0;}//读数据函数int readData(){FILE *fp;char fname[20];int i;cout<<"请输入进程流文件名:";cin>>fname;if((fp=fopen(fname,"r"))==NULL){cout<<"错误,文件打不开,请检查文件名"<<endl;}else{while(!feof(fp)){fscanf(fp,"%s %d %d %d",pcbs[quantity].name,&pcbs[quantity].status,&pcbs[quantity].time,&pcbs[quantity].privilege);quantity++;} //输出所读入的数据cout<<"输出所读入的数据"<<endl;cout<<"进程名进程状态所需时刻优先数"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" "<<pcbs[i].status<<" "<<pcbs[i].time<<" "<<pcbs[i].privilege<<endl;}return(1);}return(0);}//重置数据,以供另一个算法使用void init(){int i;for(i=0;i<MAXPCB;i++){pcbs[i].finished=0; pcbs[i].wait_time=0;}}//先进先出算法void FIFO(){int i,j; int total;//输出FIFO算法执行流cout<<endl<<"*****************************************************"<<endl;cout<<"FIFO算法执行流:"<<endl; cout<<"进程名等待时刻"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" "<<pcbs[i].wait_time<<endl;for(j=i+1;j<quantity;j++){ pcbs[j].wait_time+=pcbs[i].time; }}total=0;for(i=0;i<quantity;i++){ total+=pcbs[i].wait_time; }cout<<"总等待时刻:"<<total<<" 平均等待时刻:"<<total/quantity<<endl;}//优先数调度算法void privilege(){int i,j,p;int passed_time=0;int total;int queue[MAXPCB];int current_privilege=1000;for(i=0;i<quantity;i++){current_privilege=1000;for(j=0;j<quantity;j++){if((pcbs[j].finished==0)&&(pcbs[j].privilege<current_privilege)){ p=j;current_privilege=pcbs[j].privilege;}}queue[i]=p;pcbs[p].finished=1;pcbs[p].wait_time+=passed_time;passed_time+=pcbs[p].time;}//输出优先数调度执行流cout<<endl<<"***********************************************************"<<endl;cout<<"优先数调度执行流:"<<endl;cout<<"进程名等待时刻"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[queue[i]].name<<" "<<pcbs[queue[i]].wait_time<<endl;}total=0;for(i=0;i<quantity;i++){ total+=pcbs[i].wait_time; }cout<<"总等待时刻:"<<total<<" 平均等待时刻:"<<total/quantity<<endl;}//时刻片轮转调度算法void timer(){int i,j,number,flag=1;int passed_time=0;int max_time=0;int round=0;int queue[1000];int total=0;while(flag==1){flag=0;number=0;for(i=0;i<quantity;i++){if(pcbs[i].finished==0){ number++; j=i; }}if(number==1){ queue[total]=j; total++; pcbs[j].finished=1; }if(number>1){for(i=0;i<quantity;i++){if(pcbs[i].finished==0){ flag=1;queue[total]=i;total++;if(pcbs[i].time<=block_time*(round+1)){pcbs[i].finished=1;}}}}round++;}if(queue[total-1]==queue[total-2]){ total--; }cout<<endl<<"*******************************************************"<<endl;cout<<"时刻片轮转调度执行流:"<<endl;for(i=0;i<total;i++){cout<<pcbs[queue[i]].name<<" ";cout<<endl;}}//显示void version(){cout<<" /********************* 进程调度********************/";cout<<endl<<endl; }//主函数void main(){int flag;version();initial();flag=readData();if(flag==1){ FIFO();init();privilege();init();timer();}}〔3〕运行结果：输入进程流文件名1.txt即可得出以下输出结果：实验二银行家算法一、实验目的死锁会引起运算机工作僵死，因此操作系统中必须防止。

华中师范大学计算机科学系《操作系统》实验报告实验题目：进程调度学生姓名：日期：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}【实验小结】本次试验的题目——进程管理。