下载文档原格式
操作系统实验报告书院系名称：电子工程学院电子指导教师：班级：学号：学生姓名：实验题目一：进程一、实验目的通过观察、分析实验现象，深入理解进程及进程在调度执行和内存空间等方面的特点，掌握在POSIX 规范中fork和kill系统调用的功能和使用。
二、实验内容（1）补充POSIX 下进程控制的残缺版实验程序（2）回答下列问题：1. 你最初认为运行结果会怎么样？2. 实际的结果什么样？有什么特点？试对产生该现象的原因进行分析。
3. proc_number 这个全局变量在各个子进程里的值相同吗？为什么？4. kill 命令在程序中使用了几次？每次的作用是什么？执行后的现象是什么？5. 使用kill 命令可以在进程的外部杀死进程。
进程怎样能主动退出？这两种退出方式哪种更好一些？三、实验步骤1.根据题意进入DOC环境中编写程序。
2.编译，链接，运行程序，进行调试。
3.分析实验结果及回答问题。
四、调试情况，回答问题及体会1、对自己设计进行评价，指出合理和不足之处，提出改进的方案。
2、在设计过程中的感受。
调试情况：回答上述实验内容中的问题1．预期结果：会持续输出0-9号进程，直到输入数字键+回车，则会杀死该进程，接下来的输出将不会有该进程号，当输入q+回车，则退出程序。
2．实际结果：与预期差不多，因输入进程总数20大于设定的最大进程数，因此按进程数10来处理。
随机输出0-9号进程，sleep(SLEEP_INTERV AL)，循环输出，直到输入数字键，则会杀死该数字对应的进程，直到输入q退出循环，然后杀死本组所有进程。
分析：每创建一个子进程时，将其pid存储在pid[i]中，i存储在proc_number，然后调用死循环函数do_something()，输出该进程的代号proc_number；当输入数字键时，主进程会执行kill(pid[ch-'0'],SIGTERM)，从而杀死（ch-‘0’）号进程。
windows的实验报告（完整版）实验标题：Windows的实验报告一、实验目的本实验旨在深入了解Windows操作系统的基本原理和功能，并掌握Windows操作系统的安装、配置和使用方法。
二、实验内容1. Windows操作系统的安装通过制作启动盘或使用光盘安装，选择适当的版本和安装选项进行Windows操作系统的安装。
2. Windows操作系统的配置进行系统设置，包括语言和区域设定、时区设定、键盘和鼠标设置等。
3. Windows操作系统的使用掌握Windows操作系统的基本操作，包括桌面管理、文件和文件夹管理、应用程序的安装和卸载、系统设置等。
4. Windows操作系统的网络配置了解并设置Windows操作系统的网络连接，包括有线网络和无线网络的配置。
三、实验步骤1. Windows操作系统的安装按照安装引导界面的指示，选择合适的选项完成安装过程。
注意选择适配的驱动程序并进行相应设置。
2. Windows操作系统的配置在系统设置中，选择适当的语言和区域，设定正确的时区。
根据个人需求，进行键盘和鼠标相关设置。
3. Windows操作系统的使用3.1 桌面管理：了解和使用桌面的基本布局，包括桌面图标的添加、删除、移动等操作。
3.2 文件和文件夹管理：学习使用资源管理器对文件和文件夹进行管理，包括创建、复制、粘贴、删除等操作。
3.3 应用程序的安装和卸载：了解如何通过Windows商店或第三方应用程序进行安装，并学会使用控制面板进行软件的卸载。
3.4 系统设置：掌握系统设置的方法，包括背景壁纸的更换、屏幕分辨率的调整、电源管理等。
4. Windows操作系统的网络配置4.1 有线网络的配置：了解如何通过网线连接计算机和局域网以及设置IP地址、子网掩码等网络参数。
4.2 无线网络的配置：学习如何连接无线网络并进行密码设置，了解无线网络的高级配置选项。
四、实验结果经过以上实验步骤的操作，成功完成了Windows操作系统的安装、配置和使用。
操作系统实验实验报告一、实验目的操作系统是计算机系统中最为关键的核心软件，它管理着计算机的硬件资源和软件资源，为用户提供了一个方便、高效、稳定的工作环境。
本次操作系统实验的目的在于通过实际操作和实践，深入理解操作系统的基本原理和核心概念，掌握操作系统的基本功能和操作方法，提高对操作系统的认识和应用能力。
二、实验环境本次实验使用的操作系统为 Windows 10 专业版，开发工具为Visual Studio 2019，编程语言为 C 和 C+＋。
实验硬件环境为一台配备Intel Core i7 处理器、16GB 内存、512GB SSD 硬盘的个人计算机。
三、实验内容（一）进程管理实验1、进程创建与终止通过编程实现创建新的进程，并在完成任务后终止进程。
在实验中，我们使用了 Windows API 函数 CreateProcess 和 TerminateProcess 来完成进程的创建和终止操作。
通过观察进程的创建和终止过程，深入理解了进程的生命周期和状态转换。
2、进程同步与互斥为了实现进程之间的同步与互斥，我们使用了信号量、互斥量等同步对象。
通过编写多线程程序，模拟了多个进程对共享资源的访问，实现了对共享资源的互斥访问和同步操作。
在实验中，我们深刻体会到了进程同步与互斥的重要性，以及不正确的同步操作可能导致的死锁等问题。
（二）内存管理实验1、内存分配与释放使用 Windows API 函数 VirtualAlloc 和 VirtualFree 进行内存的分配和释放操作。
通过实验，了解了内存分配的不同方式（如堆分配、栈分配等）以及内存释放的时机和方法，掌握了内存管理的基本原理和操作技巧。
2、内存分页与分段通过编程模拟内存的分页和分段管理机制，了解了内存分页和分段的基本原理和实现方法。
在实验中，我们实现了简单的内存分页和分段算法，对内存的地址转换和页面置换等过程有了更深入的理解。
（三）文件系统实验1、文件操作使用 Windows API 函数 CreateFile、ReadFile、WriteFile 等进行文件的创建、读取和写入操作。
操作系统教程实验指导书实验一WINDOWS进程初识1、实验目的（1）学会使用VC编写基本的Win32 Consol Application（控制台应用程序)。
（2）掌握WINDOWS API的使用方法。
（3）编写测试程序，理解用户态运行和核心态运行。
2、实验内容和步骤（1）编写基本的Win32 Consol Application步骤1：登录进入Windows，启动VC++ 6.0。
步骤2：在“FILE”菜单中单击“NEW”子菜单，在“projects”选项卡中选择“Win32 Consol Application”,然后在“Project name”处输入工程名，在“Location”处输入工程目录。
创建一个新的控制台应用程序工程。
步骤3：在“FILE”菜单中单击“NEW”子菜单，在“Files”选项卡中选择“C++ Source File”, 然后在“File”处输入C/C++源程序的文件名。
步骤4：将清单1-1所示的程序清单复制到新创建的C/C++源程序中。
编译成可执行文件。
步骤5：在“开始”菜单中单击“程序”-“附件”-“命令提示符”命令，进入Windows “命令提示符”窗口，然后进入工程目录中的debug子目录，执行编译好的可执行程序：E:\课程\os课\os实验\程序\os11\debug>hello.exe运行结果 (如果运行不成功，则可能的原因是什么？) ：答：运行成功，结果：（2）计算进程在核心态运行和用户态运行的时间步骤1：按照（1）中的步骤创建一个新的“Win32 Consol Application”工程，然后将清单1-2中的程序拷贝过来，编译成可执行文件。
步骤2：在创建一个新的“Win32 Consol Application”工程，程序的参考程序如清单1-3所示，编译成可执行文件并执行。
步骤3：在“命令提示符”窗口中运行步骤1中生成的可执行文件，测试步骤2中可执行文件在核心态运行和用户态运行的时间。
篇一：操作系统实验报告完全版《计算机操作系统》实验报告班级：姓名：学号：实验一进程控制与描述一、实验目的通过对windows 2000编程，进一步熟悉操作系统的基本概念，较好地理解windows 2000的结构。
通过创建进程、观察正在运行的进程和终止进程的程序设计和调试操作，进一步熟悉操作系统的进程概念，理解windows 2000中进程的“一生”。
二、实验环境硬件环境：计算机一台，局域网环境；软件环境：windows 2000 professional、visual c++6.0企业版。
三、实验内容和步骤第一部分:程序1-1windows 2000 的gui 应用程序windows 2000 professional下的gui应用程序，使用visual c++编译器创建一个gui应用程序，代码中包括了winmain()方法，该方法gui类型的应用程序的标准入口点。
:: messagebox( null, “hello, windows 2000” , “greetings”,mb_ok) ;/* hinstance */ , /* hprevinstance */, /* lpcmdline */, /* ncmdshow */ )return(0) ; }在程序1-1的gui应用程序中，首先需要windows.h头文件，以便获得传送给winmain() 和messagebox() api函数的数据类型定义。
接着的pragma指令指示编译器/连接器找到user32.lib库文件并将其与产生的exe文件连接起来。
这样就可以运行简单的命令行命令cl msgbox.cpp来创建这一应用程序，如果没有pragma指令，则messagebox() api函数就成为未定义的了。
这一指令是visual studio c++ 编译器特有的。
接下来是winmain() 方法。
其中有四个由实际的低级入口点传递来的参数。
《操作系统》实验报告一、实验目的操作系统是计算机系统中最为关键的组成部分之一，本次实验的主要目的是深入理解操作系统的基本原理和功能，通过实际操作和观察，熟悉操作系统的核心概念，包括进程管理、内存管理、文件系统和设备管理等，提高对操作系统的实际应用能力和问题解决能力。
二、实验环境本次实验在以下环境中进行：操作系统：Windows 10开发工具：Visual Studio 2019编程语言：C+＋三、实验内容1、进程管理实验进程是操作系统中最基本的执行单元。
在这个实验中，我们使用C+＋编写程序来创建和管理进程。
通过观察进程的创建、执行和结束过程，理解进程的状态转换和资源分配。
首先，我们编写了一个简单的程序，创建了多个子进程，并通过进程标识符（PID）来跟踪它们的运行状态。
然后，使用等待函数来等待子进程的结束，并获取其返回值。
在实验过程中，我们发现进程的创建和销毁需要消耗一定的系统资源，而且进程之间的同步和通信需要谨慎处理，以避免出现死锁和竞争条件等问题。
2、内存管理实验内存管理是操作系统的核心功能之一，它直接影响系统的性能和稳定性。
在这个实验中，我们研究了动态内存分配和释放的机制。
使用 C+＋中的 new 和 delete 操作符来分配和释放内存。
通过观察内存使用情况和内存泄漏检测工具，了解了内存分配的效率和可能出现的内存泄漏问题。
同时，我们还探讨了内存分页和分段的概念，以及虚拟内存的工作原理。
通过模拟内存访问过程，理解了页表的作用和地址转换的过程。
3、文件系统实验文件系统是操作系统用于管理文件和目录的机制。
在这个实验中，我们对文件的创建、读写和删除进行了操作。
使用 C+＋的文件流操作来实现对文件的读写。
通过创建不同类型的文件（文本文件和二进制文件），并对其进行读写操作，熟悉了文件的打开模式和读写方式。
此外，还研究了文件的权限设置和目录的管理，了解了如何保护文件的安全性和组织文件的结构。
4、设备管理实验设备管理是操作系统与外部设备进行交互的桥梁。
《操作系统》课内实验报告一、实验目的本次《操作系统》课内实验的主要目的是通过实际操作和观察，深入理解操作系统的基本原理和功能，掌握常见操作系统命令的使用，提高对操作系统的实际应用能力和问题解决能力。
二、实验环境本次实验在计算机实验室进行，使用的操作系统为 Windows 10 和Linux（Ubuntu 发行版）。
实验所使用的计算机配置为：Intel Core i5 处理器，8GB 内存，500GB 硬盘。
三、实验内容1、进程管理在 Windows 系统中，通过任务管理器观察进程的状态、优先级、CPU 使用率等信息，并进行进程的结束和优先级调整操作。
在 Linux 系统中，使用命令行工具（如 ps、kill 等）实现相同的功能。
2、内存管理使用 Windows 系统的性能监视器和资源监视器，查看内存的使用情况，包括物理内存、虚拟内存的占用和分配情况。
在 Linux 系统中，通过命令（如 free、vmstat 等）获取类似的内存信息，并分析内存的使用效率。
3、文件系统管理在 Windows 系统中，对文件和文件夹进行创建、复制、移动、删除等操作，了解文件的属性设置和权限管理。
在 Linux 系统中，使用命令（如 mkdir、cp、mv、rm 等）完成相同的任务，并熟悉文件的所有者、所属组和权限设置。
4、设备管理在 Windows 系统中，查看设备管理器中的硬件设备信息，安装和卸载设备驱动程序。
在 Linux 系统中，使用命令（如 lspci、lsusb 等）查看硬件设备，并通过安装内核模块来支持特定设备。
四、实验步骤1、进程管理实验（1）打开 Windows 系统的任务管理器，切换到“进程”选项卡，可以看到当前系统中正在运行的进程列表。
（2）选择一个进程，右键点击可以查看其属性，包括进程 ID、CPU 使用率、内存使用情况等。
（3）通过“结束任务”按钮可以结束指定的进程，但要注意不要随意结束系统关键进程，以免导致系统不稳定。
一、实验概述实验名称：操作系统课程实验实验目的：1. 理解操作系统基本概念、原理及功能；2. 掌握操作系统的基本操作和应用；3. 提高实际操作能力和分析问题、解决问题的能力。
实验内容：1. 操作系统基本概念及原理的学习；2. 操作系统基本操作的应用；3. 实验项目：文件读写、多进程、多线程。
二、实验环境操作系统：Windows 10编译器：Visual Studio语言：C/C++实验平台：Windows 10系统下的虚拟机三、实验过程1. 操作系统基本概念及原理的学习操作系统是计算机系统中最基本的系统软件，负责管理计算机硬件资源、提供用户接口以及执行各种应用程序。
在实验过程中，我们学习了以下基本概念及原理：（1）进程管理：进程是操作系统能够进行运算处理的独立单位，具有动态性、并发性、异步性和独立性等特点。
进程管理主要包括进程的创建、调度、同步、通信和终止等。
（2）内存管理：内存管理是操作系统核心功能之一，主要负责分配、回收、保护和管理内存资源。
内存管理方式有分页、分段、段页式等。
（3）文件系统：文件系统是操作系统用于存储、检索和管理文件的机制。
文件系统主要包括目录结构、文件属性、文件操作等。
（4）设备管理：设备管理负责管理计算机系统中的各种外部设备，包括输入、输出和存储设备。
设备管理主要包括设备分配、设备驱动程序、缓冲区管理等。
2. 操作系统基本操作的应用在实验过程中，我们应用以下基本操作：（1）进程管理：创建、调度、同步、通信和终止进程。
（2）内存管理：分配、回收、保护和管理内存资源。
（3）文件系统：创建、删除、读写文件，实现目录结构的管理。
（4）设备管理：分配、回收、控制和管理设备。
3. 实验项目：文件读写、多进程、多线程（1）文件读写实验实验目的：掌握文件的基本操作，实现文件的创建、打开、读取、写入和关闭。
实验步骤：① 创建一个文件，命名为“test.txt”。
② 打开文件，以读写模式。
操作系统课程实验报告一、实验目的操作系统是计算机系统中最核心的软件之一，它负责管理计算机的硬件资源和软件资源，为用户提供一个方便、高效、安全的工作环境。
本实验的目的是通过实际操作和观察，深入理解操作系统的基本原理和功能，掌握操作系统的常用命令和操作方法，提高解决实际问题的能力。
二、实验环境操作系统：Windows 10开发工具：Visual Studio Code三、实验内容1、进程管理观察进程的创建、终止和状态转换。
使用任务管理器查看系统中的进程信息，包括进程 ID、CPU 使用率、内存占用等。
通过编程实现创建和终止进程的功能。
2、内存管理了解内存的分配和回收机制。
使用 Windows 系统提供的性能监视器查看内存的使用情况。
编程实现简单的内存分配和释放算法。
3、文件系统管理熟悉文件和目录的操作，如创建、删除、复制、移动等。
研究文件的属性，如文件名、文件大小、创建时间等。
通过编程实现文件的读写操作。
4、设备管理认识设备的驱动程序和设备管理策略。
查看系统中的设备信息，如磁盘驱动器、打印机等。
模拟设备的中断处理过程。
四、实验步骤1、进程管理实验打开任务管理器，观察当前系统中正在运行的进程。
可以看到进程的名称、进程 ID、CPU 使用率、内存占用等信息。
使用 C+＋语言编写一个简单的程序，创建一个新的进程。
在程序中，使用`CreateProcess`函数来创建新进程，并设置进程的属性和参数。
编写另一个程序，用于终止指定的进程。
通过获取进程 ID，然后使用`TerminateProcess`函数来终止进程。
2、内存管理实验打开 Windows 性能监视器，选择“内存”选项卡，可以查看内存的使用情况，包括物理内存、虚拟内存、页面文件等的使用量和使用率。
编写一个 C 程序，使用动态内存分配函数（如`malloc`和`free`）来分配和释放内存。
在程序中，不断分配和释放一定大小的内存块，观察内存的使用情况和性能变化。
操作系统实验报告1. 实验目的本次实验的目的是通过设计一个简单的操作系统，深入理解操作系统的基本原理、结构和功能，并通过实践掌握操作系统的核心概念和实现方式。
2. 实验环境本次实验使用的实验环境如下：- 操作系统：Linux Ubuntu 18.04- 开发语言：C/C++- 开发工具：GCC编译器，GNU Make3. 实验内容及步骤本次实验包括以下几个主要内容和步骤：3.1 系统引导- 在操作系统启动时，首先执行系统引导程序，加载操作系统内核到内存中。
- 系统引导程序负责初始化硬件设备，建立起基本的运行环境，然后将控制权转交给操作系统内核。
3.2 内核初始化- 内核初始化过程包括初始化各种数据结构，建立进程控制块（PCB），初始化设备驱动程序等。
- 内核初始化完成后，操作系统进入空闲状态，等待用户的操作请求。
3.3 进程管理- 操作系统需要支持进程管理功能，包括进程的创建、销毁、调度和切换等。
- 进程管理模块负责分配和回收进程资源，根据调度算法决定进程的执行顺序，实现进程的并发执行。
3.4 内存管理- 操作系统需要支持内存管理功能，包括内存的分配和释放、内存的保护和共享等。
- 内存管理模块负责维护内存的使用情况，并根据进程的需求进行内存的分配和回收。
3.5 文件系统- 操作系统需要支持文件系统，提供对文件的创建、打开、读写和关闭等操作。
- 文件系统模块负责管理文件和目录的结构，以及实现对文件的存储和访问策略。
4. 实验结果与分析我们根据上述步骤，设计并实现了一个简单的操作系统。
通过测试和分析，得出以下实验结果和结论：4.1 系统启动与内核初始化- 当系统启动时，我们能够成功加载操作系统的内核，并初始化各种硬件设备。
- 内核初始化过程能够正确建立进程控制块（PCB），并初始化各个设备驱动程序。
4.2 进程管理- 我们能够成功创建和销毁进程，并按照设定的调度算法进行进程的切换。
- 进程间能够实现正确的互斥和同步操作，避免资源竞争和死锁等问题。
. .中南大学《操作系统》实验报告姓名：福星专业班级：软件 1006班学号：完成日期： 2011.11.22进程调度与存管理一、实验目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。
当就续进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。
实验模拟实现处理机调度，以加深了解处理机调度的工作，并体会优先级和时间片轮转调度算法的具体实施方法。
帮助了解在不同的存储管理方式下，应怎样实现主存空间的分配和回收。
二、实验要求1、可随机输入若干进程，并按优先权排序；2、从就绪队首选进程运行：优先权-1/要求运行时间-1要求运行时间=0时，撤销该进程3、重新排序，进行下轮调度。
4、可随时增加进程；5、规定道数，设置后备队列和挂起状态。
若存中进程少于规定道数，可自动从后备队列调度一作业进入。
被挂起进程入挂起队列，设置解挂功能用于将指定挂起进程解挂入就绪队列。
6、每次调度后，显示各进程状态。
7、自行假设主存空间大小，预设操作系统所占大小并构造未分分区表；表目容：起址、长度、状态（未分/空表目）8、结合以上实验，PCB增加为：{PID，要求运行时间，优先权，状态，所需主存大小，主存起始位置，PCB指针}9、采用最先适应算法分配主存空间；10、进程完成后，回收主存，并与相邻空闲分区合并。
11、采用图形界面；三、实验容选择一个调度算法，实现处理机调度。
1、设计一个按优先权调度算法实现处理机调度的程序；2、设计按时间片轮转实现处理机调度的程序。
3、主存储器空间的分配和回收。
在可变分区管理方式下，采用最先适应算法实现主存空间的分配和回收。
四、实验原理该模拟系统采用java语言实现，要实现的功能有新建进程、进程调度、挂起进程、解挂进程、删除进程，道数和时间片大小可以由用户自己调整，有两种调度策略：按优先权调度和按时间片轮转调度。
每个进程可能有5种状态：新建(new)、就绪(ready)、运行(running)、阻塞(waiting)、挂起(suspend)。
每个状态都有一个队列用来存放处于该状态的进程，不同的调度策略采用不同的队列实现。
当创建进程时，如果存中的进程数还没达到规定道数，则将新建进程插入就绪队列，如果存中进程数已经达到规定道数，则插到后备队列，后备队列中的进程的状态为new。
CPU每次调度时都从就绪队列中取进程，在进程执行过程中如果下一个操作时IO操作，则将进程插入到waiting队列。
在系统运行过程中可以执行进程挂起操作，但执行的挂起操作时系统自动暂停运行，在弹出窗口选择要挂起的进程后，将选中的进程从原来的队列中删除并插入到挂起队列。
进行解挂操作时将选中的进程从挂起队列中删除并插入该进程原来所处的队列。
➢按优先级调度：当选择按优先权调度时，所有队列都采用优先队列，优先队列采用一个有序链表实现，进程的优先权值越大代表优先级越高，优先队列中的进程按优先权从大到小排列，当新进程插入时根据该进程的优先权插入到队列中的合适位置，插入后保持队列按优先权从大到小排列，如果新进程与队列中某个进程优先权值相等，则该新进程插到那个进程后面，以遵循先来先服务的规则。
当要从队列中取出进程时总是取队列中第一个进程，因为该进程的优先级最高。
➢按时间片轮转调度：当选择按时间片轮转调度时，所有队列都采用先进先出队列，先进先出队列采用一个普通单向链表实现，当新进程插入时插入到队列的末尾，当要取进程时取队首进程，这样就实现了先进先出。
➢存管理该实验基于实验一完成，核心是存的分配和回收，在实验一的基础上增加存管理部分，在新建进程的时候增加一个输入存大小的输入框，在进程进入存时要分配存，在进程销毁时要回收存，如果进入存时存不足，则将进程插入到后备队列等待下次调度。
系统维护一个存表，每个表项代表一个空间，每个空间保存了该空间的起始地址和空间大小以及空间使用状态。
初始时只有一个空间，当CPU启动时要分配存，存分配采用最先适应算法。
回收存时如果有相邻空闲空间，则要进行空闲空间合并。
}}五、源代码及截图：1.divDTO：public 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.PcbDTO：public 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;}}3.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 JFrame("进程调度-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("就绪队列"); waitingLabel = new JLabel("等待队列"); 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) {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() + divDtoArray[down].getLength()));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();}}运行截图：运行后开始界面输入进程后界面建立后挂起挂起后各存分配解挂操作异常时的提示六、实验总结这个程序，我参考了课本，互联网以及相关资料。
