操作系统实验进程调度和内存管理java语言版本
- 格式：docx
- 大小：15.15 KB
- 文档页数：56
下载文档原格式
合集下载
操作系统实验报告进程管理
操作系统实验报告进程管理操作系统实验报告：进程管理引言操作系统是计算机系统中的核心软件，负责管理计算机的硬件资源和提供用户与计算机之间的接口。
进程管理是操作系统的重要功能之一，它负责对计算机中运行的各个进程进行管理和调度，以保证系统的高效运行。
本实验报告将介绍进程管理的基本概念、原理和实验结果。
一、进程管理的基本概念1. 进程与线程进程是计算机中正在运行的程序的实例，它拥有独立的内存空间和执行环境。
线程是进程中的一个执行单元，多个线程可以共享同一个进程的资源。
进程和线程是操作系统中最基本的执行单位。
2. 进程状态进程在运行过程中会经历不同的状态，常见的进程状态包括就绪、运行和阻塞。
就绪状态表示进程已经准备好执行，但还没有得到处理器的分配；运行状态表示进程正在执行；阻塞状态表示进程由于某些原因无法继续执行，需要等待某些事件的发生。
3. 进程调度进程调度是操作系统中的一个重要任务，它决定了哪个进程应该获得处理器的使用权。
常见的调度算法包括先来先服务（FCFS）、最短作业优先（SJF）和时间片轮转等。
二、进程管理的原理1. 进程控制块（PCB）PCB是操作系统中用于管理进程的数据结构，它包含了进程的各种属性和状态信息，如进程标识符、程序计数器、寄存器值等。
通过PCB，操作系统可以对进程进行管理和控制。
2. 进程创建与撤销进程的创建是指操作系统根据用户的请求创建一个新的进程。
进程的撤销是指操作系统根据某种条件或用户的请求终止一个正在运行的进程。
进程的创建和撤销是操作系统中的基本操作之一。
3. 进程同步与通信多个进程之间可能需要进行同步和通信，以实现数据共享和协作。
常见的进程同步与通信机制包括互斥锁、信号量和管道等。
三、实验结果与分析在本次实验中，我们使用了一个简单的进程管理模拟程序，模拟了进程的创建、撤销和调度过程。
通过该程序，我们可以观察到不同调度算法对系统性能的影响。
实验结果显示，先来先服务（FCFS）调度算法在一些情况下可能导致长作业等待时间过长，影响系统的响应速度。
计算机操作系统进程调度实验报告
计算机操作系统进程调度实验报告实验报告：计算机操作系统进程调度1.实验背景与目的计算机操作系统是一种负责管理和协调计算机硬件和软件资源的系统。
进程调度作为操作系统的重要功能之一，主要负责决定哪些进程可以运行、何时运行以及运行多长时间等问题。
本实验旨在通过实践学习进程调度的原理和实现细节，加深对操作系统的理解。
2.实验原理与步骤（1）实验原理：进程调度的目标是充分利用计算机资源，提高系统的吞吐率和响应时间。
常用的调度算法有先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）等。
在本实验中，我们将实现时间片轮转调度算法，并对比不同算法的性能差异。
（2）实验步骤：1）设计进程数据结构：创建进程控制块（PCB）结构体，包含进程的标识符、到达时间、服务时间、剩余时间、等待时间等信息。
2）生成进程：根据指定的进程个数和服务时间范围，生成随机的进程并初始化进程控制块。
3）时间片轮转调度算法：根据时间片大小，按照轮转调度的方式进行进程调度。
4）性能评估：通过记录进程的等待时间和周转时间，比较不同调度算法的性能差异。
3.实验结果与分析通过实验我们生成了10个进程，并使用时间片大小为2进行轮转调度。
下表列出了各个进程的信息及调度结果。
进程到达时间服务时间剩余时间等待时间周转时间P108068P214004P3291310P4350115P542032P6570147P763063P8761714P981071P1093104从实验结果可以看出，时间片轮转调度算法相对公平地分配了CPU给各个进程，减少了等待时间和周转时间。
但是，对于长时间服务的进程，可能出现饥饿问题，即一些耗时较长的进程无法得到充分的CPU时间。
与时间片轮转算法相比，先来先服务（FCFS）算法对于短作业具有更好的响应时间，但可能导致长作业等待时间过长。
最短作业优先（SJF）算法能够最大化短作业的优先级，提高整体性能。
4.实验总结与体会本次实验通过实践了解了进程调度的原理与实现细节，加深了对操作系统的理解。
操作系统实验报告进程调度
操作系统实验报告进程调度操作系统实验报告：进程调度引言在计算机科学领域中，操作系统是一个重要的概念，它负责管理和协调计算机系统中的各种资源，包括处理器、内存、输入/输出设备等。
其中，进程调度是操作系统中一个非常重要的组成部分，它负责决定哪个进程在何时获得处理器的使用权，以及如何有效地利用处理器资源。
实验目的本次实验的目的是通过对进程调度算法的实验，深入理解不同的进程调度算法对系统性能的影响，并掌握进程调度算法的实现方法。
实验环境本次实验使用了一台配备了Linux操作系统的计算机作为实验平台。
在该计算机上，我们使用了C语言编写了一些简单的进程调度算法，并通过模拟不同的进程调度场景进行了实验。
实验内容1. 先来先服务调度算法（FCFS）先来先服务调度算法是一种简单的进程调度算法，它按照进程到达的顺序进行调度。
在本次实验中，我们编写了一个简单的FCFS调度算法，并通过模拟多个进程同时到达的情况，观察其对系统性能的影响。
2. 短作业优先调度算法（SJF）短作业优先调度算法是一种根据进程执行时间长度进行调度的算法。
在本次实验中，我们编写了一个简单的SJF调度算法，并通过模拟不同长度的进程，观察其对系统性能的影响。
3. 时间片轮转调度算法（RR）时间片轮转调度算法是一种按照时间片大小进行调度的算法。
在本次实验中，我们编写了一个简单的RR调度算法，并通过模拟不同时间片大小的情况，观察其对系统性能的影响。
实验结果通过实验，我们发现不同的进程调度算法对系统性能有着不同的影响。
在FCFS 算法下，长作业会导致短作业等待时间过长；在SJF算法下，长作业会导致短作业饥饿现象；而RR算法则能够较好地平衡不同进程的执行。
因此，在实际应用中，需要根据具体情况选择合适的进程调度算法。
结论本次实验通过对进程调度算法的实验，深入理解了不同的进程调度算法对系统性能的影响，并掌握了进程调度算法的实现方法。
同时，也加深了对操作系统的理解，为今后的学习和研究打下了良好的基础。
操作系统实验报告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，并为其分配执行时间。
进程调度的目标是提高系统的吞吐量、响应时间和公平性。
在多道程序设计环境下，进程调度需要考虑多个进程之间的竞争和协作，以实现资源的合理利用。
二、进程调度算法1. 先来先服务调度（FCFS）先来先服务调度算法是最简单的进程调度算法之一，它按照进程到达的顺序进行调度，即先到达的进程先执行。
这种算法的优点是公平性高，缺点是无法适应长作业和短作业混合的情况，容易产生"饥饿"现象。
2. 最短作业优先调度（SJF）最短作业优先调度算法是根据进程的执行时间来进行调度的，即执行时间最短的进程先执行。
这种算法的优点是能够最大程度地减少平均等待时间，缺点是无法适应实时系统和长作业的情况。
3. 时间片轮转调度（RR）时间片轮转调度算法是一种抢占式调度算法，它将CPU的执行时间划分为固定大小的时间片，并按照轮转的方式分配给各个进程。
当一个进程的时间片用完后，它将被挂起，等待下一次调度。
这种算法的优点是能够保证每个进程都能够获得一定的执行时间，缺点是无法适应长作业和短作业混合的情况。
4. 优先级调度（Priority Scheduling）优先级调度算法是根据进程的优先级来进行调度的，优先级高的进程先执行。
这种算法的优点是能够根据进程的重要性和紧急程度进行灵活调度，缺点是可能会导致低优先级的进程长时间等待。
三、实验结果与分析在实验中，我们使用了不同的进程调度算法，并对其进行了性能测试。
操作系统进程调度实验
操作系统进程调度实验操作系统进程调度是操作系统中非常重要的一个功能，它决定了多个进程的执行顺序和调度策略。
进程调度的好坏直接影响着系统的性能和资源利用率。
本实验旨在通过实现一个简单的进程调度模拟，了解不同的调度算法，探讨其优劣和适用场景。
一、实验目的和原理本实验的目标是实现进程调度模拟，并探究不同调度算法的性能和适用场景。
通过实验，我们可以了解以下内容：1.进程调度算法的基本原理和实现方式；2.比较不同调度算法的优劣和特点；3.了解不同调度算法在不同场景下的应用。
二、实验环境和工具本实验使用C语言进行实现，可以选择任何一种编程环境和工具，例如Dev-C++、Visual Studio等。
三、实验过程及方法1.实现一个进程控制块（PCB）的数据结构，用来保存进程的相关信息，包括进程ID、进程状态、优先级等。
2.实现一个进程队列，用来保存就绪队列中的进程。
可以使用数组或链表等数据结构实现。
3. 实现不同调度算法的函数，包括先来先服务（FCFS）、最短作业优先（SJF）、优先级调度（Priority Scheduling）和时间片轮转（Round Robin）等。
4.根据实际需求生成一批进程，设置其信息，并根据不同算法进行调度。
5.对比不同算法的运行结果和性能，分析其优劣。
四、实验结果和分析通过实验，我们可以得到每个算法的平均等待时间、平均周转时间和吞吐量等性能指标。
根据这些指标，我们可以对不同算法进行评价和分析。
1.先来先服务（FCFS）算法FCFS算法是最简单的调度算法，按照进程到达的顺序进行调度。
它的主要优点是实现简单、公平性好。
然而，FCFS算法有明显的缺点，会导致长作业等待时间过长，产生"饥饿"现象。
2.最短作业优先（SJF）算法SJF算法是按照进程的执行时间长短进行调度的算法。
它能够最大限度地减少平均等待时间和周转时间，但是需要提前知道所有进程的执行时间，这在实际中是很难做到的。
操作系统实验 进程调度和内存管理 java语言版本
divTable=newJTable(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);
{
returnthis.limit;
}
}
第三个类：主类
importjavax.swing.*;
importjava.util.*;
importjava.awt.*;
publicclassMainFrame
{
privateJListreadyList;
privateJListwaitingList;
privateJListjobList;
readyPanel=newJPanel();
readyPanel.setLayout(null);
susButton=newJButton("挂起");
relaxButton=newJButton("释放");
startButton=newJButton("开始");
newButton=newJButton("新建进程");
divDtoArray[0].setLength(180);
readydata=newObject[6][4];
runningdata=newObject[2][3];
divdata=newObject[20][3];
allocdata=newObject[20][3];
divTable.setEnabled(false);
divTable.setValueAt(String.valueOf(20),0,0);
divTable.setValueAt(String.valueOf(180),0,1);
divTable.setValueAt(String.valueOf(1),0,2);
{
returnthis.limit;
}
}
第三个类：主类
importjavax.swing.*;
importjava.util.*;
importjava.awt.*;
publicclassMainFrame
{
privateJListreadyList;
privateJListwaitingList;
privateJListjobList;
readyPanel=newJPanel();
readyPanel.setLayout(null);
susButton=newJButton("挂起");
relaxButton=newJButton("释放");
startButton=newJButton("开始");
newButton=newJButton("新建进程");
divDtoArray[0].setLength(180);
readydata=newObject[6][4];
runningdata=newObject[2][3];
divdata=newObject[20][3];
allocdata=newObject[20][3];
操作系统实验一进程调度
操作系统实验一进程调度在计算机科学中，操作系统是管理计算机硬件与软件资源的程序，是计算机系统的内核与基石。
而进程调度作为操作系统的核心功能之一，对于系统的性能和资源利用率起着至关重要的作用。
本次操作系统实验一，我们将深入探讨进程调度的原理和实现。
进程，简单来说，是正在运行的程序的实例。
在多道程序环境下，多个进程可能同时竞争计算机系统的资源，如 CPU、内存、I/O 设备等。
进程调度的任务就是从就绪队列中选择一个合适的进程，并将 CPU 分配给它，以实现资源的合理分配和系统的高效运行。
常见的进程调度算法有先来先服务（FCFS）、短作业优先（SJF）、时间片轮转（RR）、优先级调度等。
先来先服务算法按照进程到达就绪队列的先后顺序进行调度，这种算法简单直观，但可能导致短作业等待时间过长，从而影响系统的整体性能。
短作业优先算法则优先调度运行时间短的进程，能够有效降低平均等待时间，但可能对长作业不利，容易造成“饥饿”现象。
时间片轮转算法将 CPU 时间划分成固定大小的时间片，每个进程轮流获得一个时间片的 CPU 使用权。
这种算法能够保证每个进程都能得到及时响应，但时间片的大小选择需要权衡系统的开销和响应时间。
优先级调度算法为每个进程赋予一个优先级，优先级高的进程优先获得 CPU 资源。
然而，确定合理的优先级以及避免低优先级进程“饥饿”是该算法需要解决的问题。
在实验中，我们通过模拟实现这些调度算法，来深入理解它们的工作原理和性能特点。
以时间片轮转算法为例，我们首先需要创建一个就绪队列来存放等待调度的进程。
每个进程包含进程 ID、所需运行时间、已运行时间等信息。
在调度过程中，从就绪队列头部取出一个进程，判断其剩余运行时间是否小于等于时间片。
如果是，则该进程运行完毕，从队列中删除；否则，将其已运行时间增加时间片大小，剩余运行时间减少时间片大小，然后将其移到队列尾部，等待下一轮调度。
通过对不同调度算法的模拟实验，我们可以观察到它们在不同场景下的表现。
操作系统进程调度实验报告
操作系统进程调度实验报告操作系统进程调度实验报告引言：操作系统是计算机系统中的核心软件之一，负责管理计算机的硬件资源并提供用户与计算机硬件之间的接口。
进程调度作为操作系统的重要功能之一，负责决定哪个进程可以获得处理器的使用权，以及进程如何在处理器上运行。
本实验旨在通过设计和实现一个简单的进程调度算法，加深对操作系统进程调度原理的理解。
一、实验目的本实验的主要目的是通过编写代码模拟操作系统的进程调度过程，掌握进程调度算法的实现方法，深入理解不同调度算法的特点和适用场景。
二、实验环境本实验使用C语言进行编程实现，可在Linux或Windows系统下进行。
三、实验内容1. 进程调度算法的选择在本实验中，我们选择了最简单的先来先服务（FCFS）调度算法作为实现对象。
FCFS算法按照进程到达的先后顺序进行调度，即先到先服务。
这种调度算法的优点是简单易实现，但缺点是无法适应不同进程的执行时间差异，可能导致长作业效应。
2. 进程调度的数据结构在实现进程调度算法时，我们需要定义进程的数据结构。
一个进程通常包含进程ID、到达时间、执行时间等信息。
我们可以使用结构体来表示一个进程，例如：```struct Process {int pid; // 进程IDint arrival_time; // 到达时间int burst_time; // 执行时间};```3. 进程调度算法的实现在FCFS调度算法中，我们需要按照进程到达的先后顺序进行调度。
具体实现时，可以使用一个队列来保存待调度的进程，并按照到达时间的先后顺序将进程入队。
然后，按照队列中的顺序依次执行进程，直到所有进程执行完毕。
4. 实验结果分析通过实现FCFS调度算法，我们可以观察到进程调度的过程和结果。
可以通过输出每个进程的执行顺序、等待时间和周转时间等指标来分析调度算法的效果。
通过比较不同调度算法的指标，可以得出不同算法的优缺点。
四、实验步骤1. 定义进程的数据结构，包括进程ID、到达时间和执行时间等信息。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
源代码：第一个类：divDTOpublicclassdivDTO{privateintdivBase;privateintlength;privateintdivFlag;publicdivDTO(intdivBase,intlength,intdivFlag) {this.divBase=divBase;this.divFlag=divFlag;this.length=length;}publicdivDTO(){}{this.divBase=base;}publicintgetDivBase(){returnthis.divBase;}publicvoidsetLength(intlength) {this.length=length;}publicintgetLength(){returnthis.length;}{this.divFlag=flag;}publicintgetDivFalg(){returnthis.divFlag;}}2.第二个类：PcbDTO publicclassPcbDTO{staticfinalintRunning=1;staticfinalintReady=2;staticfinalintWaiting=3;privateStringprocessName;privateintrunTime;privateintprority;privateintprocessState;privateintbase;privateintlimit;privateintpcbFlag;publicPcbDTO(Stringname,inttime,intpro,intbase,intlimit) {this.processName=name;this.runTime=time;this.prority=pro;this.processState=0;this.limit=limit;this.base=base;}publicPcbDTO(){this.pcbFlag=0;} publicvoidsetProcessName(Stringname) {this.processName=name;}publicStringgetProcessName(){returnprocessName;}publicvoidsetRunTime(inttime){this.runTime=time;}publicintgetRunTime(){returnthis.runTime;}publicvoidsetPrority(intprority){this.prority=prority;}publicintgetPrority(){returnthis.prority;}publicvoidsetProcessState(intstate) {this.processState=state;}publicStringgetProcessState(){Strings=newString();if(this.processState==1){s="running";}elseif(this.processState==2){s="ready";}elseif(this.processState==3){s="waiting";}returns;}publicintgetBase(){returnthis.base;}publicvoidsetBase(intbase){this.base=base;}publicvoidsetLimit(intlimit){this.limit=limit;}publicintgetLimit(){returnthis.limit;}}第三个类：主类importjavax.swing.*; importjava.util.*; importjava.awt.*; publicclassMainFrame{privateJListreadyList;privateJListwaitingList;privateJListjobList;privateJButtonsusButton;privateJButtonrelaxButton;privateJButtonstartButton;privateJButtonnewButton;privateJLabelnameLabel;privateJLabelprorityLabel;privateJLabeltimeLabel;privateJLabeljobLabel;privateJLabelreadyLabel; privateJLabelwaitingLabel; privateJLabelrunningLabel; privateJLabelspaceLabel; privateJLabeldivLabel; privateJLabelallocLabel; privateJTablereadyTable; privateJTablerunningTable; privateJTabledivTable; privateJTableallocTable; privateJTextFieldnameText; privateJTextFieldtimeText; privateJTextFieldspaceText; privateJComboBoxprorityCom; privateJPanelnewPanel; privateJPanelwaitingPanel;privateJPanelreadyPanel; VectorjobVectorName; VectorjobDtoVector; VectorwaitingVectorName; VectorwaitingDtoVector; PcbDTO[]readyDtoArray; PcbDTO[]newDtoArray; divDTO[]divDtoArray; PcbDTO[]newSort;Object[][]readydata; Object[][]runningdata; Object[][]divdata; Object[][]allocdata; intfirst;intend;intpoint;PcbDTOa;publicMainFrame(){a=newPcbDTO();first=0;end=0;point=0;JFramejf=newJFrame("进程调度-ws");Containerc=jf.getContentPane();c.setLayout(null);//c.setBackground(Color.pink);newPanel=newJPanel();newPanel.setLayout(null);waitingPanel=newJPanel();waitingPanel.setLayout(null);//waitingPanel.setBackground(Color.pink);readyPanel=newJPanel(); readyPanel.setLayout(null); susButton=newJButton("挂起"); relaxButton=newJButton("释放"); startButton=newJButton("开始"); newButton=newJButton("新建进程"); nameLabel=newJLabel("进程名"); prorityLabel=newJLabel("优先级"); timeLabel=newJLabel("运行时间"); jobLabel=newJLabel("后备队列"); readyLabel=newJLabel("就绪队列"); waitingLabel=newJLabel("等待队列"); runningLabel=newJLabel("运行进程"); spaceLabel=newJLabel("需要空间"); divLabel=newJLabel("未分分区表"); allocLabel=newJLabel("内存分配表");nameText=newJTextField();timeText=newJTextField();spaceText=newJTextField(); prorityCom=newJComboBox(); prorityCom.setToolTipText("优先级"); readyDtoArray=newPcbDTO[6];newSort=newPcbDTO[6];for(inti=0;i<6;i++){newSort[i]=newPcbDTO();}newDtoArray=newPcbDTO[100]; jobDtoVector=newVector(); jobVectorName=newVector(); waitingDtoVector=newVector(); waitingVectorName=newVector();divDtoArray=newdivDTO[20];for(inti=0;i<20;i++){divDtoArray[i]=newdivDTO();divDtoArray[i].setDivFlag(0);}divDtoArray[0].setDivFlag(1);divDtoArray[0].setDivBase(20);divDtoArray[0].setLength(180);readydata=newObject[6][4];runningdata=newObject[2][3];divdata=newObject[20][3];allocdata=newObject[20][3];String[]col1={"进程","时间","优先级","状态"}; String[]col2={"进程","时间","优先级"};String[]col3={"起址","长度","状态"};String[]col4={"起址","长度","占用进程"}; readyTable=newJTable(readydata,col1);//readyTable.setEnabled(false);runningTable=newJTable(runningdata,col2); runningTable.setRowHeight(22); runningTable.setEnabled(false);allocTable=newJTable(allocdata,col4); allocTable.setEnabled(false);divTable=newJTable(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); JScrollPanerunningSP=newJScrollPane(); JScrollPanereadySP2=newJScrollPane(); JScrollPanedivSP=newJScrollPane();JScrollPaneallocSP=newJScrollPane();runningSP.getViewport().add(runningTable); readySP2.getViewport().add(readyTable);divSP.getViewport().add(divTable);allocSP.getViewport().add(allocTable);//int[]prorityArray=newint[10];for(inti=0;i<10;i++){prorityCom.addItem(i);//prorityArray[i]=i;}jobList=newJList();waitingList=newJList();JScrollPanereadySP=newJScrollPane(readyList); JScrollPanejobSP=newJScrollPane(jobList); JScrollPanewaitingSP=newJScrollPane(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(newMyActionListener());newButton.addActionListener(newMyActionListener());susButton.addActionListener(newMyActionListener());relaxButton.addActionListener(newMyActionListener());}publicvoidsus(){try{Thread.sleep(1000);}catch(Exceptionex){}} classMyActionListenerimplementsActionListener {publicvoidactionPerformed(ActionEvente){intcount=0;PcbDTOtest=newPcbDTO();JButtonjb=(JButton)e.getSource();intmax=-1;if(jb==startButton){//while(true)//{intrunAllocFlag=-1;if((String)runningTable.getValueAt(0,0)==null||(String)runningTable.getVal ueAt(0,0)==""){try{Thread.sleep(0);}catch(Exceptionex){}到3");for(intj=first;j!=end;){if(!readyDtoArray[j].getProcessState().equals("waiting")){max=j;break;}j=(j+1)%6;}for(intj=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{等待中……");}}else{/*try{Thread.sleep(2000);}catch(InterruptedExceptione1){}*/到1");runningTable.setValueAt("",0,0);runningTable.setValueAt("",0,1);runningTable.setValueAt("",0,2);//如果运行时间为0则撤销进程，否则将进程重新添加到就绪队列中if(a.getRunTime()<=0){//收回内存空间for(inti=0;i<point;i++){if(newSort[i].getBase()>=a.getBase()){newSort[i]=newSort[i+1];}}point--;//设置内存分配表的内容for(inti=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);//把收回的内存加入到记录未分分区的数组intmemoryEnd=0;intlocation=0;intup=-1;//intdown=-1;for(inti=0;i<20;i++){if(divDtoArray[i].getDivFalg()==1){memoryEnd=divDtoArray[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()+divDto Array[down].getLength()));divDtoArray[down].setDivFlag(0);for(inti=(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;}}}elseif(up>=0&&down<0){divDtoArray[up].setLength((divDtoArray[up].getLength()+a.getLimit()));}elseif(up<0&&down>=0){divDtoArray[down].setLength((divDtoArray[down].getLength()+a.getLimit()));divDtoArray[down].setDivBase(a.getBase());elseif(up<0&&down<0){for(inti=0;i<20;i++){if(divDtoArray[i].getDivBase()>a.getBase()||divDtoArray[i].getDivFalg()==0 ){location=i;break;}}for(inti=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(inti=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()){intrunLength=0;PcbDTOjobToReady=(PcbDTO)jobDtoVector.elementAt(0);for(inti=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){inti=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);}elseif(runLength>0){intc2=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;intruni=0;//用于记录当前新生成的PcbDTO对象应该插入到newSort中的位置for(;runi<point;runi++){if(jobToReady.getBase()<newSort[runi].getBase()){break;}}//如果不是插入到数组末尾，则把比它大的都向后挪一位并设置JTable中的显示for(inti=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;}}//}}elseif(jb==newButton){intnewAllocFlag=-1;intnewLength=0;if(nameText.getText().trim().length()==0){JOptionPane.showMessageDialog(null,"进程名不能为空！");}elseif(timeText.getText().trim().length()==0){JOptionPane.showMessageDialog(null,"运行时间不能为空"); }elseif(spaceText.getText().trim().length()==0){JOptionPane.showMessageDialog(null,"空间不能为空");}else{test.setRunTime(Integer.parseInt(timeText.getText()));test.setLimit(Integer.parseInt(spaceText.getText()));Strings=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("");PcbDTOb=(PcbDTO)jobDtoVector.elementAt(0);for(inti=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){inti=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);}elseif(newLength>0){intc1=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;intnewi=0;//用于记录当前新生成的PcbDTO对象应该插入到newSort中的位置for(;newi<point;newi++){if(b.getBase()<newSort[newi].getBase()){break;}}//如果不是插入到数组末尾，则把比它大的都向后挪一位并设置JTable中的显示for(inti=point;i>newi;i--){newSort[i]=newSort[i-1];。