操作系统部分实验报告1
操作系统实验实验报告
操作系统实验实验报告一、实验目的操作系统是计算机系统中最为关键的核心软件，它管理着计算机的硬件资源和软件资源，为用户提供了一个方便、高效、稳定的工作环境。
本次操作系统实验的目的在于通过实际操作和实践，深入理解操作系统的基本原理和核心概念，掌握操作系统的基本功能和操作方法，提高对操作系统的认识和应用能力。
二、实验环境本次实验使用的操作系统为 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 等进行文件的创建、读取和写入操作。
操作系统安全实验1实验报告
操作系统安全实验1实验报告一、实验目的本次操作系统安全实验的主要目的是让我们深入了解操作系统的安全机制，通过实际操作和观察，掌握一些常见的操作系统安全配置和防护方法，提高对操作系统安全的认识和应对能力。
二、实验环境本次实验使用的操作系统为Windows 10 和Linux（Ubuntu 2004），实验设备为个人计算机。
三、实验内容与步骤（一）Windows 10 操作系统安全配置1、账户管理创建新用户账户，并设置不同的权限级别，如管理员、标准用户等。
更改账户密码策略，包括密码长度、复杂性要求、密码有效期等。
启用账户锁定策略，设置锁定阈值和锁定时间，以防止暴力破解密码。
2、防火墙配置打开 Windows 防火墙，并设置入站和出站规则。
允许或阻止特定的应用程序通过防火墙进行网络通信。
3、系统更新与补丁管理检查系统更新，安装最新的 Windows 安全补丁和功能更新。
配置自动更新选项，确保系统能够及时获取并安装更新。
4、恶意软件防护安装并启用 Windows Defender 防病毒软件。
进行全盘扫描，检测和清除可能存在的恶意软件。
（二）Linux（Ubuntu 2004）操作系统安全配置1、用户和组管理创建新用户和组，并设置相应的权限和归属。
修改用户密码策略，如密码强度要求等。
2、文件系统权限管理了解文件和目录的权限设置，如读、写、执行权限。
设置特定文件和目录的权限，限制普通用户的访问。
3、 SSH 服务安全配置安装和配置 SSH 服务。
更改 SSH 服务的默认端口号，增强安全性。
禁止 root 用户通过 SSH 登录。
4、防火墙配置（UFW）启用 UFW 防火墙。
添加允许或拒绝的规则，控制网络访问。
四、实验结果与分析（一）Windows 10 操作系统1、账户管理成功创建了具有不同权限的用户账户，并能够根据需求灵活调整权限设置。
严格的密码策略有效地增加了密码的安全性，减少了被破解的风险。
账户锁定策略在一定程度上能够阻止暴力破解攻击。
(完整word版)操作系统实验报告.实验一 WINDOWS进程初识
操作系统教程实验指导书实验一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、设备管理实验设备管理是操作系统与外部设备进行交互的桥梁。
计算机操作系统实验报告
计算机操作系统实验报告一、实验目的本次计算机操作系统实验的主要目的是深入了解操作系统的工作原理和功能，通过实际操作和观察，增强对操作系统概念的理解，提高解决实际问题的能力。
二、实验环境1、操作系统：Windows 10 专业版2、开发工具：Visual Studio 20193、编程语言：C+＋三、实验内容1、进程管理实验创建多个进程，并观察它们的执行顺序和资源占用情况。
使用进程控制块（PCB）来跟踪进程的状态变化，如就绪、运行、阻塞等。
2、内存管理实验模拟内存分配和回收算法，如首次适应算法、最佳适应算法和最坏适应算法。
观察不同算法在内存利用率和分配效率方面的表现。
3、文件系统实验创建、读取、写入和删除文件，了解文件的操作流程。
研究文件的存储结构和目录管理方式。
4、线程同步与互斥实验使用互斥锁和信号量来实现线程之间的同步和互斥操作。
观察在多线程环境下资源竞争和同步的效果。
四、实验步骤1、进程管理实验步骤编写 C+＋程序，使用系统调用创建多个进程。
在每个进程中输出进程的标识符和当前执行时间。
通过观察控制台输出，分析进程的执行顺序和资源占用情况。
2、内存管理实验步骤实现不同的内存分配算法，并在程序中模拟内存请求和释放的过程。
记录每次内存分配和回收的结果，计算内存利用率和分配时间。
3、文件系统实验步骤使用文件操作函数创建文件，并写入一些数据。
读取文件中的数据，并将其输出到控制台。
删除文件，观察文件系统的变化。
4、线程同步与互斥实验步骤创建多个线程，共享一些公共资源。
在访问公共资源的代码段前使用互斥锁或信号量进行同步控制。
观察线程的执行结果，确保资源的正确访问和修改。
五、实验结果与分析1、进程管理实验结果与分析实验结果显示，进程的执行顺序是不确定的，取决于操作系统的调度策略和进程的优先级。
资源占用情况也因进程的不同而有所差异，一些进程可能占用较多的 CPU 时间和内存，而另一些则相对较少。
2、内存管理实验结果与分析首次适应算法在分配速度上较快，但容易产生内存碎片。
华科操作系统实验报告
华科操作系统实验报告一、实验目的操作系统是计算机系统的核心组成部分，对于理解计算机的工作原理和提高计算机应用能力具有重要意义。
本次华科操作系统实验的主要目的是通过实际操作和实践，深入理解操作系统的基本概念、原理和功能，掌握操作系统的核心技术和应用方法，提高我们的实践能力和问题解决能力。
二、实验环境本次实验使用的操作系统为Windows 10 和Linux（Ubuntu 2004），开发工具包括 Visual Studio Code、GCC 编译器等。
实验硬件环境为个人计算机，配置为英特尔酷睿 i7 处理器、16GB 内存、512GB 固态硬盘。
三、实验内容1、进程管理进程创建与销毁进程调度算法模拟进程同步与互斥2、内存管理内存分配与回收算法实现虚拟内存管理3、文件系统文件操作与管理文件系统的实现与优化4、设备管理设备驱动程序编写设备分配与回收四、实验步骤及结果1、进程管理实验进程创建与销毁首先，使用 C 语言编写程序，通过系统调用创建新的进程。
在程序中，使用 fork(）函数创建子进程，并在子进程和父进程中分别输出不同的信息，以验证进程的创建和执行。
实验结果表明，子进程和父进程能够独立运行，并输出相应的信息。
进程调度算法模拟实现了先来先服务（FCFS）、短作业优先（SJF）和时间片轮转（RR）三种进程调度算法。
通过模拟多个进程的到达时间、服务时间和优先级等参数，计算不同调度算法下的平均周转时间和平均等待时间。
实验结果显示，SJF 算法在平均周转时间和平均等待时间方面表现较好，而 RR 算法能够提供较好的响应时间和公平性。
进程同步与互斥使用信号量和互斥锁实现了进程的同步与互斥。
编写了生产者消费者问题的程序，通过信号量控制生产者和消费者对缓冲区的访问，避免了数据竞争和不一致的情况。
实验结果表明，信号量和互斥锁能够有效地实现进程间的同步与互斥，保证程序的正确性。
2、内存管理实验内存分配与回收算法实现实现了首次适应（First Fit）、最佳适应（Best Fit）和最坏适应（Worst Fit）三种内存分配算法。
操作系统实验报告
一、实验目的1. 理解操作系统基本原理和概念。
2. 掌握操作系统常见操作和命令。
3. 熟悉操作系统实验环境。
4. 提高动手实践能力。
二、实验环境1. 操作系统：Linux Ubuntu 18.042. 编程语言：C/C++3. 开发工具：GCC三、实验内容1. 进程管理实验2. 内存管理实验3. 文件系统实验四、实验步骤及结果1. 进程管理实验（1）实验步骤1）创建一个简单的进程```c#include <stdio.h>#include <stdlib.h>#include <sys/types.h>#include <unistd.h>int main() {pid_t pid = fork();if (pid == 0) {// 子进程printf("Child process, PID: %d\n", getpid()); } else {// 父进程printf("Parent process, PID: %d\n", getpid()); printf("Child process, PID: %d\n", pid);}return 0;}```2）编译并运行程序```gcc -o process process.c./process```3）查看进程信息```ps -ef | grep process```（2）实验结果编译并运行程序后，可以看到父进程和子进程的PID。
2. 内存管理实验（1）实验步骤1）创建一个简单的内存分配和释放程序```c#include <stdio.h>#include <stdlib.h>int main() {int p = (int )malloc(sizeof(int));if (p == NULL) {printf("Memory allocation failed\n"); return -1;}p = 10;printf("Value of p: %d\n", p);free(p);return 0;}```2）编译并运行程序```gcc -o memory memory.c./memory```（2）实验结果程序成功分配和释放内存，并打印出内存中的值。
国开(电大)操作系统课程实验报告1
国开(电大)操作系统课程实验报告1
概要
该实验报告旨在记录国开(电大)操作系统课程实验1的过程和
结果。
本次实验的主要目标是熟悉操作系统的基本概念和任务管理。
实验过程
1. 阅读实验指南：仔细阅读了实验指南，了解了实验要求和流程。
2. 环境搭建：安装了虚拟机软件并创建了一个虚拟机，用于实
验的操作系统。
3. 实验步骤：
- 步骤1：启动虚拟机并登录操作系统。
- 步骤2：查看当前系统的任务列表。
- 步骤3：创建一个新的任务，并添加一些测试内容。
- 步骤4：查看更新后的任务列表，确认新任务的添加成功。
4. 实验结果：
- 成功完成了所有实验步骤。
- 通过查看任务列表，确认新任务的添加成功。
总结
通过本次实验，我进一步了解了操作系统的基本概念和任务管理。
实践操作系统的相关操作，加深了对操作系统的理解和熟悉度。
在实验过程中，我遵循实验指南，按照步骤进行操作，并取得了预
期的实验结果。
改进建议
对于下次实验，建议在实验过程中记录更多的细节和操作步骤，便于后续复和总结。
同时，对于实验中遇到的问题，可以记录下来
并尝试寻找解决方案，以便在以后的实验中更好地应对类似问题。
操作系统实验报告1
《操作系统》实验报告实验序号：01 实验项目名称：操作系统环境学号1107xxx 姓名xxx 专业、班级软件工程1103 实验地点计—502 指导教师徐冬时间2013.9.23 实验目的1) 了解和学习Windows系统管理工具及其使用；2) 熟悉Windows系统工具的内容和应用；由此，进一步熟悉Windows操作系统的应用环境。
工具/准备工作在开始本实验之前，请回顾教科书的相关内容。
需要准备一台运行Windows 操作系统的计算机。
实验内容与步骤1. 计算机管理2. 事件查看器3. 性能监视4. 服务5. 数据库 (ODBC)为了帮助用户管理和监视系统，Windows提供了多种系统管理工具，其中最主要的有计算机管理、事件查看器和性能监视等。
如图2所示。
图2 基于虚拟机的操作系统计算环境管理步骤1：登录进入Windows。
步骤2：在“开始”菜单中单击“设置”-“控制面板”命令，双击“管理工具”图标。
在本地计算机“管理工具”组中，有哪些系统管理工具，基本功能是什么：1) Internet 信息服务；管理IIS,Internet 和Intranet站点的WEB服务器。
2) Server Extensions 管理器；Server Extensions管理器。
3)计算机管理；管理磁盘以及使用其他系统工具来管理本地或远程的计算机。
4)性能；显示系统性能图表以及配置数据日志和警报。
5)本地安全策略；查看和修改本地安全策略，如用户权限和审核策略。
6)事件查看器；显示来自于Windows和其他程序的监视与排错消息。
7)组件服务；配置和管理COM+应用程序。
1. 计算机管理使用“计算机管理”可通过一个合并的桌面工具来管理本地或远程计算机，它将几个Windows管理实用程序合并到一个控制台目录树中，使管理员可以轻松地访问特定计算机的管理属性和工具。
步骤3：在“管理工具”窗口中，双击“计算机管理”图标。
“计算机管理”使用的窗口与“Windows资源管理器”相似。
《操作系统》课程实验报告
《操作系统》课程实验报告一、实验目的本次《操作系统》课程实验的主要目的是通过实际操作和观察，深入理解操作系统的工作原理、进程管理、内存管理、文件系统等核心概念，并掌握相关的操作技能和分析方法。
二、实验环境1、操作系统：Windows 10 专业版2、开发工具：Visual Studio Code3、编程语言：C/C+＋三、实验内容（一）进程管理实验1、进程创建与终止通过编程实现创建新进程，并观察进程的创建过程和资源分配情况。
同时，实现进程的正常终止和异常终止，并分析其对系统的影响。
2、进程同步与互斥使用信号量、互斥锁等机制实现进程之间的同步与互斥。
通过模拟多个进程对共享资源的访问，观察并解决可能出现的竞争条件和死锁问题。
（二）内存管理实验1、内存分配与回收实现不同的内存分配算法，如首次适应算法、最佳适应算法和最坏适应算法。
观察在不同的内存请求序列下，内存的分配和回收情况，并分析算法的性能和优缺点。
2、虚拟内存管理研究虚拟内存的工作原理，通过设置页面大小、页表结构等参数，观察页面的换入换出过程，以及对系统性能的影响。
（三）文件系统实验1、文件操作实现文件的创建、打开、读取、写入、关闭等基本操作。
观察文件在磁盘上的存储方式和文件系统的目录结构。
2、文件系统性能优化研究文件系统的缓存机制、磁盘调度算法等，通过对大量文件的读写操作，评估不同优化策略对文件系统性能的提升效果。
四、实验步骤（一）进程管理实验步骤1、进程创建与终止（1）使用 C/C+＋语言编写程序，调用系统函数创建新进程。
（2）在子进程中执行特定的任务，父进程等待子进程结束，并获取子进程的返回值。
（3）通过设置异常情况，模拟子进程的异常终止，观察父进程的处理方式。
2、进程同步与互斥（1）定义共享资源和相关的信号量或互斥锁。
（2）创建多个进程，模拟对共享资源的并发访问。
（3）在访问共享资源的关键代码段使用同步机制，确保进程之间的正确协作。
（4）观察并分析在不同的并发情况下，系统的运行结果和资源竞争情况。
武科大操作系统实验报告
一、实验目的1. 理解操作系统的基本概念和功能。
2. 掌握操作系统的基本操作和命令。
3. 熟悉操作系统的文件系统结构。
4. 学会使用操作系统的各种工具和命令。
二、实验环境1. 操作系统：Windows 102. 操作系统版本：64位3. 实验软件：Windows PowerShell三、实验内容1. 操作系统的基本概念和功能2. 操作系统的基本操作和命令3. 操作系统的文件系统结构4. 操作系统的工具和命令四、实验步骤1. 操作系统的基本概念和功能（1）打开Windows PowerShell。
（2）使用命令“dir”查看当前目录下的文件和文件夹。
（3）使用命令“ipconfig”查看网络配置信息。
（4）使用命令“systeminfo”查看系统信息。
2. 操作系统的基本操作和命令（1）创建文件夹：使用命令“mkdir 文件夹名”。
（2）删除文件夹：使用命令“rmdir 文件夹名”。
（3）创建文件：使用命令“echo 内容 > 文件名”。
（4）删除文件：使用命令“del 文件名”。
3. 操作系统的文件系统结构（1）使用命令“tree”查看文件系统结构。
（2）使用命令“cd”切换目录。
（3）使用命令“cd..”返回上级目录。
4. 操作系统的工具和命令（1）使用命令“netstat”查看网络连接。
（2）使用命令“tasklist”查看进程列表。
（3）使用命令“systeminfo”查看系统信息。
（4）使用命令“net user”查看用户列表。
五、实验结果与分析1. 操作系统的基本概念和功能通过实验，我们了解了操作系统的基本概念和功能，包括文件管理、进程管理、内存管理、设备管理、用户管理等。
2. 操作系统的基本操作和命令通过实验，我们学会了使用Windows PowerShell的基本操作和命令，如创建文件夹、删除文件夹、创建文件、删除文件等。
3. 操作系统的文件系统结构通过实验，我们熟悉了Windows操作系统的文件系统结构，能够使用命令查看文件系统结构，切换目录等。
操作系统原理_实验报告
一、实验目的1. 理解操作系统基本原理，包括进程管理、内存管理、文件系统等。
2. 掌握操作系统的基本命令和操作方法。
3. 通过实验加深对操作系统原理的理解和掌握。
二、实验环境1. 操作系统：Linux2. 编程语言：C语言3. 开发工具：Eclipse三、实验内容本次实验主要分为以下几个部分：1. 进程管理实验2. 内存管理实验3. 文件系统实验四、实验步骤及结果1. 进程管理实验实验步骤：- 使用C语言编写一个简单的进程管理程序，实现进程的创建、调度、同步和通信等功能。
- 编写代码实现进程的创建，通过调用系统调用创建新的进程。
- 实现进程的调度，采用轮转法进行进程调度。
- 实现进程同步，使用信号量实现进程的互斥和同步。
- 实现进程通信，使用管道实现进程间的通信。
实验结果：- 成功创建多个进程，并实现了进程的调度。
- 实现了进程的互斥和同步，保证了进程的正确执行。
- 实现了进程间的通信，提高了进程的效率。
2. 内存管理实验实验步骤：- 使用C语言编写一个简单的内存管理程序，实现内存的分配、释放和回收等功能。
- 实现内存的分配，采用分页存储管理方式。
- 实现内存的释放，通过调用系统调用释放已分配的内存。
- 实现内存的回收，回收未被使用的内存。
实验结果：- 成功实现了内存的分配、释放和回收。
- 内存分配效率较高，回收内存时能保证内存的连续性。
3. 文件系统实验实验步骤：- 使用C语言编写一个简单的文件系统程序，实现文件的创建、删除、读写等功能。
- 实现文件的创建，通过调用系统调用创建新的文件。
- 实现文件的删除，通过调用系统调用删除文件。
- 实现文件的读写，通过调用系统调用读取和写入文件。
实验结果：- 成功实现了文件的创建、删除、读写等功能。
- 文件读写效率较高，保证了数据的正确性。
五、实验总结通过本次实验，我对操作系统原理有了更深入的理解和掌握。
以下是我对实验的几点总结：1. 操作系统是计算机系统的核心，负责管理和控制计算机资源，提高计算机系统的效率。
操作系统实验报告总结
操作系统实验报告总结操作系统实验报告总结引言操作系统是计算机系统中非常重要的一个组成部分，它负责管理计算机硬件和软件资源，为用户提供一个良好的工作环境。
通过操作系统实验，我们深入了解了操作系统的原理和功能，并通过实践掌握了操作系统的基本操作和管理技巧。
本文将对我们在操作系统实验中的学习和收获进行总结。
实验一：操作系统的安装与配置在本次实验中，我们学习了如何安装和配置操作系统。
通过实践，我们了解了操作系统的安装过程和常见的配置选项。
在安装过程中，我们需要选择适合我们计算机硬件的操作系统版本，并进行相应的设置。
通过这个实验，我们对操作系统的安装和配置有了更深入的了解。
实验二：进程管理进程是操作系统中的一个重要概念，它代表了一个正在运行的程序。
在本次实验中，我们学习了进程的创建、调度和终止等操作。
通过实践，我们掌握了如何使用操作系统提供的命令和工具来管理进程，如查看进程列表、创建新进程、终止进程等。
这些操作对于提高系统的资源利用率和运行效率非常重要。
实验三：内存管理内存管理是操作系统中的另一个重要概念，它负责管理计算机的内存资源。
在本次实验中，我们学习了内存的分配和释放、虚拟内存的管理等操作。
通过实践，我们了解了操作系统如何通过页表、地址映射等技术来管理内存资源。
这些知识对于保证系统的稳定性和性能至关重要。
实验四：文件系统文件系统是操作系统中用于管理文件和目录的一种机制。
在本次实验中，我们学习了文件系统的创建、读写文件等操作。
通过实践，我们掌握了如何使用操作系统提供的命令和工具来管理文件和目录，如创建文件、复制文件、删除文件等。
这些操作对于有效地组织和管理文件非常重要。
实验五：设备管理设备管理是操作系统中的另一个重要模块，它负责管理计算机的硬件设备。
在本次实验中，我们学习了设备的初始化、打开、关闭等操作。
通过实践，我们了解了操作系统如何通过设备驱动程序来管理硬件设备。
这些知识对于保证系统的稳定性和性能至关重要。
操作系统实验
操作系统实验报告（一）Linux基本操作与编程（验证性 2学时）1、实验目(de)：1）熟悉Linux操作系统(de)环境和使用.2）了解LINUX系统(de)安装过程.（注：表示可选择）3）掌握Linux环境下(de)命令操作.2、实验内容：（1）完成LINUX系统(de)登录,启动终端.进行下列操作并记录结果(要求：结果以屏幕截图表示).1）运行pwd命令,确定你当前(de)工作目录.2）利用以下命令显示当前工作目录(de)内容： ls –l3）运行以下命令： ls –al4）使用mkdir命令建立一个子目录subdir.5）使用cd命令,将工作目录改到根目录（/）上.6）使用ls-l命令列出/dev(de)内容.7）使用不带参数(de)命令cd改变目录,然后用pwd命令确定你当前(de)工作目录是哪里8）使用命令cd ../..,你将工作目录移到什么地方（2）在LINUX下查看你(de)文件.1）利用cd命令,将工作目录改到你(de)主目录上.2）将工作目录改到你(de)子目录subdir,然后运行命令： date > file1 将当前日期和时间存放到新建文件file1中.3）使用cat命令查看file1文件(de)内容.4）利用man命令显示date命令(de)用法： man date5）将date命令(de)用法附加到文件file1(de)后面：man date >> file16）利用cat命令显示文件file1(de)内容.7）利用ls -l file1命令列出文件file1(de)较详细(de)信息.运行ls -l/bin 命令显示目录(de)内容.8）利用ls -l/bin|more命令行分屏显示/bin目录(de)内容.9）利用cp file1 fa命令生成文件file1(de)副本.然后利用ls -l命令查看工作目录(de)内容.10）用cd命令返回你(de)主目录,输入命令ls –l后,解释屏幕显示(de)第一列内容(de)含义.（3）编写能输出“Hello world”问候语(de)C程序,并在终端中编译、执行.要求记录所使用(de)命令及结果.操作步骤：1）在文本编辑器中,编写C程序如下：include ""main(){ printf("hello"); }2) 在终端中,用gcc命令进行编译,生成可执行文件a.gcc –o a3) 在终端中执行a (de)命令如下：./a（4）编写一个程序：显示信息“Time for Play”,并能在后台运行一段时间（自定义）后,弹出信息提醒用户.要求记录所使用(de)命令及结果.（提示：使用sleep(s)函数）3、实验结果分析：（对上述实验内容中(de)各题结果,进行分析讨论.并回答下列问题）（1）进程包括哪些特征间断性, 失去封闭性, 不可再现性, 动态性, 并发性, 独立性（2）在Linux中,如何设置前、后台命令和程序(de)执行命令后直接加 & ,这个命令就在后台执行；正在运行(de)命令,使用Ctrl+z ,就挂起； jobs命令,可以现实后台,包括挂起(de)命令；使用 bg %作业号就可以把挂起(de)命令在后台执行；使用 fg %作业号就可以把后台命令调到前台（3）你所使用(de)Linux系统(de)内核版本是多少用什么命令查看内核版本目前你所了解(de)各发行版本(de)情况如何Linux version (gcc version (Red Hat (GCC) ) 1 SMP Tue Jan 2911:48:01 EST 2013（4）你对Linux系统有什么认识linux是一款开放性(de)操作系统,也可以说成是开放(de)源代码系统,这些代码可以完全自由(de)修改可以再任何(de)计算机上去运行它,也就是“可移植性”,其次大家都知道,linux是由UNIX(de)概念所开发出来(de),所以它也继承了UNIX(de)稳定和效率(de)特点4、总结：你对本次实验有什么体会或看法.操作系统实验报告（二）文件访问权限设置与输入输出重定向（2学时）一、实验目(de)1、掌握linux(de)文件访问权限设置.2、熟悉输入输出重定向和管道操作.二、实验内容1、启动进入红帽linux系统2、设置文件权限：在用户主目录下创建目录test,进入test目录,用vi 创建文件file1,并输入任意(de)文字内容.用ls -l显示文件信息,注意文件(de)权限和所属用户和组.对文件file1设置权限,使其他用户可以对此文件进行写操作：chmod o+w file1.用ls -l查看设置结果.取消同组用户对此文件(de)读取权限：chmod g-r file1.查看设置结果.用数字形式来为文件file1设置权限,所有者可读、可写、可执行；其他用户和所属组用户只有读和执行(de)权限：chmod 755 file1.设置完成后查看设置结果.3、输入、输出重定向和管道（1) 输出重定向用ls命令显示当前目录中(de)文件列表：ls –l.使用输出重定向,把ls命令在终端上显示(de)当前目录中(de)文件列表重定向到文件list中：ls –l > list.查看文件list中(de)内容,注意在列表中会多出一个文件list,其长度为0. 这说明shell是首先创建了一个空文件,然后再运行ls命令：cat list.再次使用输出重定向,把ls命令在终端上显示(de)当前目录中(de)文件列表重定向到文件list中.这次使用追加符号>>进行重定向：ls –l >> list.查看文件list(de)内容,可以看到用>>进行重定向是把新(de)输出内容附加在文件(de)末尾,注意其中两行list文件(de)信息中文件大小(de)区别：cat list.重复命令ls –l > list.再次查看文件list中(de)内容,和前两次(de)结果相比较,注意list文件大小和创建时间(de)区别.（2) 管道who |grep root命令(de)结果是命令ls –l |wc –l结果是4、退出linux系统操作步骤：在主菜单上选择“注销” ->关闭计算机.三、实验结果与讨论（根据实验结果回答下列问题）1. 文件(de)权限如下：-rw-r—r-- 1 root root 19274 Jul 14 11:00回答：-rw-r—r-- (de)含义是什么答：是LINUX/FTP(de)简易权限表示法：对应于本用户-所在组-其他人(de)权限,每一个用执行（x）-读取(r)-写入(w)如本题若是说自己可以读取写入不可以执行,所在组和其他人只能读取.2、文件(de)所有者添加执行权限(de)命令是答：chmod u+x 、赋予所有用户读和写文件权限(de)命令是四、答：chmod a+w,a+r 个人体会（你对本次实验有什么体会或看法）操作系统实验报告（三）文件和目录管理一、实验目(de)1) 掌握在Linux系统下(de)文件和文件系统(de)概念及命令；2) 掌握Linux系统下(de)目录操作.二、实验内容1. 进入linux终端后,用命令(de)操作结果回答下列问题：1）vi(de)三种工作模式是其中不能进行直接转换(de)是什么模式到什么模式命令模式、文本输入模式、末行模式命令模式不能直接到末行模式2）在vi中退出时,保存并退出(de)操作步骤是Ese：wq3）用vi 创建myfile1文件,并在其中输入任意文字一行,创建myfile2文件,任意输入文字3行.请问执行命令：cat <myfile1 >myfile2 后,myfile2中还有几行内容该命令(de)作用是用命令操作验证你(de)回答.myfile2中还有1行内容该命令(de)作用是替换myfile(de)内容4）请用至少两种不同(de)命令创建一个文本文件（）,在其中写入“我是2014级学生,我正在使用Linux系统.”,记录命令及执行结果.1、Vi创建2、5)用___pwd________命令可查看所创建文件(de)绝对路径,写出它(de)绝对路径__/root_________；用___ls -l________命令查看该文件(de)类型及访问权限,其访问权限（数字和字母）分别是多少__-rw- r- - r- - 6 4 4______________.6）若将该文件(de)访问权限修改为：所有者有读写权限；其他用户只读；同组用户可读写,请写出命令,并记录结果.7）查找my开头(de)所有文件,可___find my_________命令,写出命令并记录结果8）在/home下创建子目录user,并在其中创建2个文件,名为file1和file2,file1(de)内容是/root目录(de)详细信息；file2(de)内容任意,最后将这两个文件合并为file3文件,请先写出命令序列,并在终端中验证,记录结果.2. 文件及目录操作,写出操作所使用(de)命令,并记录结果.在终端中完成下列命令操作,并记录结果在root用户主目录下创建一个mydir子目录和一个myfile文件,再在mydir下建立d1和d2两个子目录.查看mydir和myfile(de)默认权限查看当前myfile和mydir(de)权限值是多少将myfile文件分别复制到root 和dd1(de)主目录中将root主目录中(de)myfile改为yourfile通过从键盘产生一个新文件并输入I am a student查找文件是否包含student字符串三、实验结果与分析,回答下列问题：1、能够创建文件(de)命令有哪些vi 和cat>name2、能够查看当前目录(de)绝对路径(de)命令是pwd3、Linux中按用户属性将用户分成哪些类型根据文件(de)访问权限,用户又被分成哪些类型能够查看文件访问权限(de)命令是用户同组其他可读可写可执行 cat f1四、小结（本次实验(de)体会或小结）操作系统实验报告（四）作业调度算法模拟（验证性2学时）1、实验目(de)：1)掌握作业调度(de)主要功能及算法.2)通过模拟作业调度算法(de)设计加深对作业管理基本原理(de)理解.3)熟悉Linux环境下应用程序(de)编程方法.2、实验内容：（1）作业调度算法（FCFS）编程模拟：编制一段程序,对所输入(de)若干作业,输入、输出数据样例如下表所示.按FCFS算法模拟调度,观察、记录并分析调度(de)输出结果情况.输入输出样例1：FCFS算法include <>include <>define SIZE 5struct Job_type{char no[2]; o,&job[i].tb,&job[i].tr);printf("输入作业顺序:\n");for(i=0;i<SIZE;i++)printf("\t%s\t%d\t%d\n",job[i].no,job[i].tb,job[i].tr);}void fcfs(){ int i,j,t=0,tw=0,tt=0;for(i=0;i<SIZE-1;i++)for(j=i+1;j<SIZE;j++)if(job[i].tb>job[j].tb){x=job[i];job[i]=job[j];job[j]=x;}printf("FCFS调度结果:\n");printf("开始时间作业号到达时间运行时间完成时间等待时间周转时间\n");for(i=0;i<SIZE;i++){printf(" %d",t);t=t+job[i].tr;tw=t-job[i].tb-job[i].tr; b; o,job[i].tb,job[i].tr,t,tw,tt);}}void main(){load();fcfs();}（2）作业调度算法（SJF）编程模拟：编程实现由短作业优先算法,分别用下面两组输入、输出数据样例进行模拟,观察分析运行结果.输入输出样例2：SJF算法输入输出A 0 4B 0 3C 0 5D 0 2E 0 1A 0 6 10 10B 0 3 6 6C 0 10 15 15D 0 1 3 3E 0 0 1 1include <>include <>define SIZE 5struct Job_type{char no[2]; o,&job[i].tb,&job[i].tr);printf("输入作业顺序:\n");for(i=0;i<SIZE;i++)printf("\t%s\t%d\t%d\n",job[i].no,job[i].tb,job[i].tr);}void sjf()n=i; pl[i].pfn=ERR;}for(i=1;i<total;i++){ pfc[i-1].next=&pfc[i];pfc[i-1].pfn=i-1;}pfc[total-1].next=NULL;pfc[total-1].pfn=total-1;freepf_head=&pfc[0];}void FIFO(int total){ int i,j;pfc_type p,t;initialize(total);busypf_head=busypf_tail=NULL;for(i=0;i<page_len;i++){if(pl[page[i]].pfn==ERR){ diseffect+=1;if(freepf_head==NULL){p=busypf_head->next;pl[busypf_head->pn].pfn=ERR; freepf_head=busypf_head;freepf_head->next=NULL;busypf_head=p;}p=freepf_head->next;freepf_head->next=NULL;freepf_head->pn=page[i];pl[page[i]].pfn=freepf_head->pfn;if(busypf_tail==NULL)busypf_head=busypf_tail=freepf_head; else{ busypf_tail->next=freepf_head;busypf_tail=freepf_head;}freepf_head=p;}}printf("FIFO:%d",diseffect);}main(){ int i; int k;printf(“请输入页(de)引用序列：\n”); for(k=0;k<page_len;k++)scanf("%d",&page[k]);for(i=4;i<=7;i++){printf("%2d page frames ",i);FIFO(i);}参考程序LRU算法,略三、实验结果分析：（对上述实验各题所使用(de)原始数据、调试数据与状态（包括出错）及最终结果进行记录并分析.）随着块数(de)增加,缺页数目也减少,4个实验中3个实验(de)块数增加到了5以后,即使块数再增加,缺页数目也是保持不变.只有实验4,块数增加到7以后,缺页数目又再次减少了四、总结：你对本次实验有什么体会或看法.。
操作系统实验报告 实验一 进程管理
实验一进程管理一、目的进程调度是处理机管理的核心内容..本实验要求编写和调试一个简单的进程调度程序..通过本实验加深理解有关进程控制块、进程队列的概念;并体会和了解进程调度算法的具体实施办法..二、实验内容及要求1、设计进程控制块PCB的结构PCB结构通常包括以下信息：进程名进程ID、进程优先数、轮转时间片、进程所占用的CPU时间、进程的状态、当前队列指针等..可根据实验的不同;PCB结构的内容可以作适当的增删..为了便于处理;程序中的某进程运行时间以时间片为单位计算..各进程的轮转时间数以及进程需运行的时间片数的初始值均由用户给定..2、系统资源r1…r w;共有w类;每类数目为r1…r w..随机产生n进程P i id;s j;k;t;0<=i<=n;0<=j<=m;0<=k<=dt为总运行时间;在运行过程中;会随机申请新的资源..3、每个进程可有三个状态即就绪状态W、运行状态R、等待或阻塞状态B;并假设初始状态为就绪状态..建立进程就绪队列..4、编制进程调度算法：时间片轮转调度算法本程序用该算法对n个进程进行调度;进程每执行一次;CPU时间片数加1;进程还需要的时间片数减1..在调度算法中;采用固定时间片即：每执行一次进程;该进程的执行时间片数为已执行了1个单位;这时;CPU时间片数加1;进程还需要的时间片数减1;并排列到就绪队列的尾上..三、实验环境操作系统环境：Windows系统..编程语言：C..四、实验思路和设计1、程序流程图2、主要程序代码//PCB结构体struct pcb{public int id; //进程IDpublic int ra; //所需资源A的数量public int rb; //所需资源B的数量public int rc; //所需资源C的数量public int ntime; //所需的时间片个数public int rtime; //已经运行的时间片个数public char state; //进程状态;W等待、R运行、B阻塞//public int next;}ArrayList hready = new ArrayList;ArrayList hblock = new ArrayList;Random random = new Random;//ArrayList p = new ArrayList;int m; n; r; a;a1; b;b1; c;c1; h = 0; i = 1; time1Inteval;//m为要模拟的进程个数;n为初始化进程个数//r为可随机产生的进程数r=m-n//a;b;c分别为A;B;C三类资源的总量//i为进城计数;i=1…n//h为运行的时间片次数;time1Inteval为时间片大小毫秒//对进程进行初始化;建立就绪数组、阻塞数组..public void input//对进程进行初始化;建立就绪队列、阻塞队列{m = int.ParsetextBox4.Text;n = int.ParsetextBox5.Text;a = int.ParsetextBox6.Text;b = int.ParsetextBox7.Text;c = int.ParsetextBox8.Text;a1 = a;b1 = b;c1 = c;r = m - n;time1Inteval = int.ParsetextBox9.Text;timer1.Interval = time1Inteval;for i = 1; i <= n; i++{pcb jincheng = new pcb;jincheng.id = i;jincheng.ra = random.Nexta + 1;jincheng.rb = random.Nextb + 1;jincheng.rc = random.Nextc + 1;jincheng.ntime = random.Next1; 5;listBox1.Items.Add"产生进程ID：" + jincheng.id;listBox1.Items.Add"所需A资源数目：" + jincheng.ra;listBox1.Items.Add"所需B资源数目：" + jincheng.rb;listBox1.Items.Add"所需C资源数目：" + jincheng.rc;listBox1.Items.Add"所需时间片数：" + jincheng.ntime;if a - jincheng.ra >= 0 && b - jincheng.rb >= 0 && c - jincheng.rc >= 0{a = a - jincheng.ra;b = b - jincheng.rb;c = c - jincheng.rc;jincheng.state = 'W';hready.Addjincheng;//加入就绪队列}else{jincheng.state = 'B';hblock.Addjincheng;//加入阻塞队列}listBox1.Items.Add"当前进程状态：" + jincheng.state;}}//从数组起始地址开始输出该数组的内容public void dispArrayList list{ArrayList list1 = new ArrayList;list1 = list;if list1.Count > 0{for int j = 0; j < list1.Count; j++{pcb p = pcblist1j;listBox1.Items.Add" " + p.id.ToString + " " + p.state.ToString + " " + p.ra.ToString + " " + p.rb.ToString + " " + p.rc.ToString+" " + p.ntime.ToString + " " + p.rtime.ToString + " \r\n";}}else{listBox1.Items.Add"\r\n\t 该队列中没有进程\r\n";}}//输出就绪数组和阻塞数组的信息public void outputall{listBox1.Items.Add"当前就绪队列的信息";listBox1.Items.Add"进程ID 进程状态A资源数B资源数C资源数所需时间片已运行时间片";disphready;listBox1.Items.Add"当前就阻塞列的信息";listBox1.Items.Add"进程ID 进程状态A资源数B资源数C资源所需时间片已运行时间片";disphblock;}//运行就绪数组的头进程;运行一个时间片;轮转一个时间片;时间片轮转调度算法public void running{ArrayList hready1 = new ArrayList;hready1 = hready;pcb p1 = new pcb;p1=pcbhready10;p1.state='R';p1.rtime= p1.rtime + 1;h=h+1;listBox1.Items.Add"\r\n~~~~~~~当前正在运行进程ID是:" +p1.id + "~~~~~~~~\r\n";listBox1.Items.Add"\r\n进程ID 进程状态A资源数B资源数C资源数所需时间片已运行时间片\r\n";listBox1.Items.Addp1.id + " " +p1.state+ " " + p1.ra + " " + p1.rb + " " + p1.rc + " " + p1.ntime + " " + p1.rtime;if p1.ntime==p1.rtime{listBox1.Items.Addp1.id.ToString+"的进程已经完成\r\n";a = a + p1.ra;b = b + p1.rb;c = c + p1.rc;hready.RemoveAt0;}else{p1.state='W';hready1.Addp1;hready.RemoveAt0;}}//检测当前资源数目是否满足阻塞数组里进程的需求public void testblock{ArrayList hblock1 = new ArrayList;hblock1 = hblock;for int m = 0; m < hblock1.Count; m++{p1 = pcbhblock1m;if a - p1.ra >= 0 && b - p1.rb >= 0 && c - p1.rc >= 0{p1.state='W';hready.Addp1;a = a - p1.ra;b = b - p1.rb;c = c - p1.rc;listBox1.Items.Add"ID号为："+p1.id + "的进程由阻塞队列转入就绪队列~~\r\n";hblock.RemoveAtm;m--;}}}//检测是否有新的进程产生;随机产生新进程public void testnew{int t;if r>0//r为随机产生的进程数目{t = random.Next9 + 1;if t <= 7{listBox1.Items.Add"\r\n有新的进程申请加入：~~";pcb jincheng = new pcb;jincheng.id = i++;jincheng.ra = random.Nexta + 1;jincheng.rb = random.Nextb + 1;jincheng.rc = random.Nextc + 1;jincheng.ntime = random.Next1; 5;jincheng.rtime = 0;listBox1.Items.Add"产生进程ID：" + jincheng.id;listBox1.Items.Add"所需A资源数目：" + jincheng.ra;listBox1.Items.Add"所需B资源数目：" + jincheng.rb;listBox1.Items.Add"所需C资源数目：" + jincheng.rc;listBox1.Items.Add"所需时间片数：" + jincheng.ntime;if a - jincheng.ra >= 0 && b - jincheng.rb >= 0 && c - jincheng.rc >= 0{a = a - jincheng.ra;b = b - jincheng.rb;c = c - jincheng.rc;jincheng.state = 'W';listBox1.Items.Add"进程状态为：" + jincheng.state;hready.Addjincheng;//加入就绪队列listBox1.Items.Add"资源满足新进程请求;该进程进入就绪队列~~\r\n";else{jincheng.state = 'B';hblock.Addjincheng;//加入阻塞队列listBox1.Items.Add"进程状态为：" + jincheng.state;listBox1.Items.Add"资源不满足新进程请求;该进程进入阻塞队列~~\r\n";}}}r = r - 1;}//系统三类资源变化情况的显示public void rescore//系统三类资源变化情况的显示{if a > a1 { textBox1.Text = a1.ToString; }if a < 0 { textBox1.Text = "0"; }if a >= 0 && a < a1 { textBox1.Text = a.ToString; }if b > b1 { textBox2.Text = b1.ToString; }if b < 0 { textBox2.Text = "0"; }if b >= 0 && b <= b1 { textBox2.Text = b.ToString; }if c > c1 { textBox3.Text = c1.ToString; }if c < 0 { textBox3.Text = "0"; }if c >= 0 && c <= c1 { textBox3.Text = c.ToString; }}//时间片轮转调度算法先来先服务FCFS算法public void runFcfs{if hready.Count>0{outputall;running;testblock;testnew;rescore;}else{timer1.Enabled = false;textBox1.Text = a1.ToString;textBox2.Text = b1.ToString;textBox3.Text = c1.ToString;listBox1.Items.Add"\r\n<<<<<<<<所有进程都已经运行结束>>>>>>>~\r\n";}//计时器触发时间片轮转调度算法private void timer1_Tickobject sender; EventArgs erunFcfs;}//开始模拟按钮单击执行函数private void button1_Clickobject sender; EventArgs e {runmain;button1.Enabled = false;textBox1.Enabled = false;textBox2.Enabled = false;textBox3.Enabled = false;textBox4.Enabled = false;textBox5.Enabled = false;textBox6.Enabled = false;textBox7.Enabled = false;textBox8.Enabled = false;textBox9.Enabled = false;}//清除屏幕按钮单击执行函数private void button2_Clickobject sender; EventArgs e {textBox1.Text = "";textBox2.Text = "";textBox3.Text = "";textBox4.Text = "";textBox5.Text = "";textBox6.Text = "";textBox7.Text = "";textBox8.Text = "";textBox9.Text = "";listBox1.Items.Clear;textBox4.Enabled = true;textBox5.Enabled = true;textBox6.Enabled = true;textBox7.Enabled = true;textBox8.Enabled = true;textBox9.Enabled = true;button1.Enabled = true;}//运行的主函数public void runmain{input;imer1.Enabled = true；3、运行界面和运行结果界面中;可以任意设定需要模拟的进程总数如5;初始化进程个数如3;还有A、B、C三类资源的总数如10、10、10..为了方便显示;还可以设定时间片的长度如500毫秒..除此之外;在运行过程中;所有的资源都是随机生成的;并且其中新进程的产生也是随机的;但是产生的进程总数不会多于开始设定的模拟的进程总数;以防止不断产生新进程;程序不断运行..在显示窗口的上方;还会实时显示资源的变化情况;方便对运行的观察..当运行结束后;可以通过工具栏中的显示选项中的保存结果按钮;将结果保存成txt文件格式;方便运行后的结果分析..五、心得体会本次实验;我的任务是设计一个允许n个进程并发运行的进程管理模拟系统..该系统包括有简单的进程控制、同步与通讯机构;系统在运行过程中能显示各进程的状态及有关参数的变化情况;从而观察诸进程的运行过程及系统的管理过程;我是用C写的;在我的电脑能够运行通过;虽不能尽善尽美;但也基本能实现老师的要求..两个星期的实验;虽然时间有点短;但我也收获不少;这次实验;加深了我对进程概念及进程管理的理解；比较熟悉进程管理中主要数据结构的设计及进程调度算法、进程控制机构、同步机构及通讯机构的实施..也让我认识到自己的不足;操作系统的有些知识;我知道的还不多;没有掌握好;还需要多多学学;不断提升自己的能力..实验中;我们小组分工合作;共同学习;虽然在实验中遇到了一些问题;但在老师和同学的细心指导和热心帮助下解决了..同时;了解到团队精神的重要性;也为以后的学习和工作打下了坚实的基础;同时积累了宝贵的经验..。
操作系统实验报告
操作系统实验报告一、实验目的本次操作系统实验的主要目的是通过实际操作和观察，深入理解操作系统的工作原理和关键机制，包括进程管理、内存管理、文件系统以及设备管理等方面。
同时，培养我们解决实际问题的能力，提高对操作系统相关知识的综合运用水平。
二、实验环境本次实验使用的操作系统为 Windows 10 和 Linux（Ubuntu 2004 LTS），实验所使用的编程工具包括 Visual Studio Code、gcc 编译器等。
三、实验内容及步骤（一）进程管理实验1、进程创建与终止在 Windows 系统中，使用 C+＋语言编写程序，通过调用系统 API函数创建新的进程，并观察进程的创建和终止过程。
在 Linux 系统中，使用 C 语言编写程序，通过 fork(）系统调用创建子进程，并通过 wait(）函数等待子进程的终止。
2、进程调度观察Windows 和Linux 系统中进程的调度策略，包括时间片轮转、优先级调度等。
通过编写程序模拟进程的执行，设置不同的优先级和执行时间，观察系统的调度效果。
（二）内存管理实验1、内存分配与释放在 Windows 系统中，使用 C+＋语言的 new 和 delete 操作符进行内存的动态分配和释放，并观察内存使用情况。
在 Linux 系统中，使用 C 语言的 malloc(）和 free(）函数进行内存的分配和释放，通过查看系统的内存使用信息来验证内存管理的效果。
2、虚拟内存管理研究 Windows 和 Linux 系统中的虚拟内存机制，包括页表、地址转换等。
通过编写程序访问虚拟内存地址，观察系统的处理方式和内存映射情况。
（三）文件系统实验1、文件操作在 Windows 和 Linux 系统中，使用编程语言对文件进行创建、读取、写入、删除等操作。
观察文件的属性、权限设置以及文件在磁盘上的存储方式。
2、目录操作实现对目录的创建、删除、遍历等操作。
研究目录结构和文件路径的表示方法。
山大操作系统实验 1
山大操作系统实验1 -CAL-FENGHAI-(2020YEAR-YICAI)_JINGBIAN操作系统原理实验报告——实验一张咪软件工程四班一、实验目的加深对于进程并发执行概念的理解。
实践并发进/线程的创建和控制方法。
观察和体验进程的动态特性。
进一步理解进程生命期期间创建、变换、撤销状态变换的过程。
掌握进程控制的方法，了解父子进程间的控制和协作关系。
练习Linux系统中进/线程创建与控制有关的系统调用的编程和调试技术。
二、实验要求编写一个多进程并发执行程序。
父进程每隔3秒重复建立两个子进程，首先创建的让其执行ls命令，之后创建执行让其执行ps命令，并控制ps命令总在ls 命令之前执行。
三、实验软硬件环境实验环境均为Linux操作系统，开发工具为gcc和g++。
四、实验思路调用fock()创建子进程。
创建键盘中断信号后，使用pause()可以暂停子进程执行，继续创建新的子进程。
子进程并发执行子进程可以首先通过键盘中断信号唤醒子进程。
通过exec()调用族装入一个新的执行程序。
在建立子进程2并且唤醒子进程1后子进程sleep(seconds = 5)。
这样就可以先执行ps后执行ls。
最后就是父进程的结束，程序结束。
五、实验模型六、调试排错1、首先遇到的问题是，对linux的操作不熟悉，不太明白makefile怎么使用，直接用了gcc2、在创建多个子进程上遇到了问题，在fock（）后又直接跟了一个fork（），这样创建的子进程是子进程的子进程，而不是父进程创建的第二个子进程。
所以应该在else语句块后面，也就是主进程执行段继续创建。
一般情况下，fork()按如下规则编程：main(){ pid_t pid;pid=fork();if(pid<0){n",getpid());}}}}}return (EXIT_SUCCESS);}#include<sys/>#include<>#include<>#include<>#include<>#include<>typedef void(*sighandler_t)(int);void sigcat(){printf("Process continue\n");}。
windows操作系统实验报告
windows操作系统实验报告1. 实验目的本实验旨在通过对Windows操作系统的实际操作，了解和掌握Windows操作系统的基本功能、应用程序管理、文件管理以及网络连接等方面的知识。
2. 实验环境本次实验使用的操作系统为Windows 10，并安装了常用应用程序和网络连接工具。
3. 实验步骤3.1 Windows操作系统的基本功能3.1.1 开机与关机在实验机器上按下电源按钮，进行开机操作，待Windows系统完全加载后，进入桌面。
点击“开始”按钮，选择“关机”选项，进行关机操作。
3.1.2 桌面的基本元素桌面是Windows操作系统的主要工作区域，它包含了以下基本元素：- 桌面图标：代表文件、文件夹或快捷方式，用于快速访问。
- 任务栏：位于屏幕底部，用于启动应用程序、显示当前运行的任务和系统图标等。
- 通知区域：位于任务栏的右侧，显示系统图标和通知。
3.2 应用程序管理3.2.1 启动应用程序在任务栏上单击鼠标右键，选择“启动任务管理器”打开任务管理器窗口。
点击“应用程序”选项卡，可以查看当前正在运行的应用程序。
双击某个应用程序图标或右键单击该应用程序图标，选择“打开”即可启动相应的应用程序。
3.2.2 切换应用程序使用Alt+Tab键可以在多个应用程序之间快速切换。
3.2.3 关闭应用程序在应用程序的窗口右上角找到“X”按钮，点击即可关闭该应用程序。
3.3 文件管理3.3.1 创建文件夹在桌面或文件资源管理器中，右键单击空白处，选择“新建” -> “文件夹”，输入文件夹名称即可创建新的文件夹。
3.3.2 复制、粘贴文件选中需要复制的文件或文件夹，按下Ctrl+C进行复制，在目标位置按下Ctrl+V进行粘贴。
3.3.3 删除文件选中需要删除的文件，按下Delete键或右键单击文件选择“删除”。
3.3.4 文件搜索点击“开始”按钮，在搜索框中输入文件名或相关关键词，系统会在磁盘中搜索匹配的文件并显示结果。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验报告课程名称_______操作系统实验_____________实验名称___Linux 的常用命令与基本管理___实验类型_____验证型_____________________实验地点___机房304___实验日期__2011.4.20_指导教师_________李文超_________________专业_计算机科学与技术_班级_____0901_______学号_____16_________姓名_____于雷_______成绩________________辽宁石油化工大学计算机与通信工程学院实验2Linux 的常用命令与基本管理(1) 实验目的：掌握Linux 操作系统中基本命令的用法，从而不用借助鼠标也能够完成部分基本操作，达到快速执行的目的。
例如，复制、删除、移动文件，创建账号，配置系统等。
（2）实验原理：（一）登录和退出Linux 系统用户登录系统时为了使系统能够识别自己必须输入用户名和密码经系统验证无后方能进入系统。
用户登录分两步进行，第一步输入用户的登录名，系统根据该登录名来识别用户，第二步输入用户的口令，该口令是用户自己选择的一个字符串对其他用户是保密的，是在登录时系统用来辨别真假用户的关键字。
1. 启动和登录系统超级用户的用户名为root 密码在安装系统时已设定系统启动成功后屏幕显示下面的提示：localhost login:这时输入超级用户名"root" 然后键入回车键此时用户会在屏幕上看到输入口令的提示：localhost login:rootPassword:这时需要输入口令，输入口令时口令不会在屏幕上显示出来，如果用户输入了错误的口令就会在屏幕上看到下列信息：login incorrect.这时需要重新输入，当用户正确地输入用户名和口令后就能合法地进入系统，屏幕显示：[root@loclhost/root] #此时说明用户已经登录到系统中，可以进行操作了。
这里"#"是超级用户的系统提示符，普通用户在建立了普通用户帐号以后就可以进行登录了。
不论是超级用户还是普通用户需要退出系统时在shell 提示符下键入exit 命令即可，还有其他退出系统的方法但上面一种是最安全的。
2. 重新启动系统以root 用户登录Linux 操作系统后执行reboot 命令可以重新启动linux 系统：[root@loclhost/root] # reboot3. 关闭系统shutdown 命令可以安全地关闭或重启Linux 系统。
它在系统关闭之前给系统上的所有登录用户提示一条警告信息。
该命令还允许用户指定一个时间参数，可以是一个精确的时间也可以是从现在开始的一个时间段。
精确时间的格式是hh:mm 表示小时和分钟，时间段由+ 和分钟数表示，系统执行该命令后会自动进行数据同步的工作，该命令的一般格式：shutdown [选项] [时间] [警告信息]命令中各选项的含义为:- k 并不真正关机而只是发出警告信息给所有用户- r 关机后立即重新启动- h 关机后不重新启动- f 快速关机重启动时跳过fsck- n 快速关机不经过init 程序- c 取消一个已经运行的shutdown需要特别说明的是该命令只能由超级用户使用。
例1 系统在十分钟后关机并且马上重新启动：# shutdown –r +10例2 系统马上关机并且不重新启动：# shutdown –h now（二）文件和目录操作命令1. ls 命令这个命令就相当于dos 下的dir 命令一样也是Linux 控制台命令中最为重要几个命令之一ls 最常用的参数有三个-a -l 和–F。
ls -aLinux 系统上的文件以. 开头的文件被系统视为隐藏文件，仅用ls 命令是看不到他们的，而用ls –a 除了显示一般文件名外连隐藏文件也会显示出来。
ls –l 这个参数是字母L 的小写不是数字1这个命令可以使用长格式显示文件内容，如果需要察看更详细的文件资料就要用到ls -l 这个指令：ls –F在列出的文件目录名称后加一符号，例如，可执行文件加"*", 目录则加"/"。
2. cd 命令cd 这个命令是用来进出目录的，它的使用方法和在dos 下没什么两样，但和dos 不同的是Linux 的目录对大小写是敏感的，如果大小写拼写有误，你的cd操作是成功不了的另外cd 如果直接输入cd 后面不加任何东西，会回到使用者自己的Home 目录，假设如果是root 那就是回到/root 。
这个功能同cd ~是一样的。
3. mkdir 和rmdirmkdir 命令用来建立新的目录如输入如下命令：mkdir work将在当前目录下新建一个work 目录。
rmdir 用来删除已建立的目录如输入如下命令：rmdir work将删除已存在的空目录work。
4. cpcp 这个命令相当于dos 下面的copy 命令，具体用法是：cp –r 源文件(source) 目的文件(target)参数r 是指连同源文件中的子目录一同拷贝。
5. rmrm 这个命令是用来删除文件的，rm命令常用的参数有三个-i,-r,-f。
比如我现在要删除一个名字为text 的一个文件输入如下命令：rm –i test系统会询问我们是否要删除test 文件，敲了y/n 确认是否要删除test 文件。
rm –r 目录名这个操作可以连同这个目录下面的子目录都删除，功能比上面讲到的rmdir 更强大，不仅可能删除指定的目录而且可以删除该目录下所有文件和子目录。
rm –f 文件名这个操作可以不经确认强制删除文件。
6. mvmv 这个命令的功能是移动目录或文件，引申的功能是给目录或文件重命名，比如mv /tmp/xxx.tar /root该命令将/tmp 目录下的xxx.tar 文件移动到/root 目录下。
而mv aaa.tar bbb.tar则是将当前目录下的文件aaa.tar 更名为bbb.tar。
7. catcat 这个命令是linux 中非常重要的一个命令，它的功能是显示或连结一般的ascii 文本文件。
它的用法如下：cat text该命令显示text 这个文件的内容。
cat file1 file2该命令依顺序显示file1,file2 的内容。
cat file1 file2>file3该命令把file1,file2 的内容结合起来再重定向>到file3 文件中。
8. moremore 是显示一般文本文件的指令，如果一个文本文件太长了，超过一个屏幕的画面，用cat 来看实在是不理想，就可以试试more ，用法如下：more file19. pwdpwd 这个命令的作用是显示用户当前的工作路径，直接输入pwd 即可。
（三）用户及用户组管理命令Linux的用户分类Linux是一个多用户操作系统，用户必须具备合法的账号才能登录，使用完毕必须退出操作系统。
另一方面，用户账号可以帮助系统管理员对系统的用户进行跟踪，并控制他们对系统资源的访问；也可以帮助用户组织文件，并提供安全性保护。
每个用户账号都拥有一个惟一的用户名和口令。
用户在登录时，键入正确的用户名和口令后，即可进入系统和自己的主目录。
Linux允许将用户分组进行管理，以简化访问和控制多用户，以避免为众多用户分别设置权限。
根据权限的不同，可以将用户划分为如下两种类型。
（1）root用户在Linux 中，超级用户称为root 用户。
root 用户可以控制所有的程序，访问所有文件，使用系统上的所有功能。
从管理的角度看，root 的权限是至高无上的。
因此，root 账号一定要通过安全的密码保护，这一点非常重要。
日常的使用不应该以root 用户登录。
（2）普通用户root 用户以外的所有用户都可以称为普通用户。
Linux 系统可以创建许多普通用户，并为其指定相应的权限。
普通用户也可以被赋予root 特权，但赋予root 特权一定要谨慎。
2．Linux用户的登录与运行级别使用系统前，必须先登录，系统验证用户账号和密码的合法性。
如果通过验证，则登录成功，反之不允许使用系统。
用户可以登录到字符模式或图形的Xwindows 模式。
若要改变登录的模式，可以修改文件/etc/inittab 中设置登录模式的一行：id:5:default 。
修改该行中的数字可控制用户进入的模式。
数字的具体定义如下。
0——停止运行（关机）。
1——单用户模式。
2——没有使用（可由用户定义）。
3——完全的多用户模式（字符界面）。
4——没有使用（可由用户定义）。
5——完全的多用户模式（带有基于X的登录屏幕）。
6——重新引导。
一般情况下，文件inittab中设置的级别为1、3或5。
0、6级别不要在这里使用。
当系统启动完毕且用户已经登录到相应的运行模式后，可以用命令init 加级别数在不同模式之间切换。
例如，init 0是关机、init 6是重新启动等。
1. useradduseradd 命令可以创建一个新的用户帐号，其最基本用法为：useradd 用户名如输入以下命令：useradd newuser系统将创建一个新用户newuser ，该用户的Home 目录为/home/newuser。
useradd 命令的参数较多，常用的组合为：useradd 用户名-g 组名–G 组名-d Home 目录名-p 密码其中-g 指定该用户的首要组。
-G 指定该用户的次要组-d 指定该用户的Home 目录-p 指定该用户的密码如输入以下命令：useradd oracle –g oinstall –G dba –d /home/oracle –p ora123系统将创建一个用户oracle oracle 用户的首要组为oinstall ，次要组为dbaHome ，目录为/home/oracle，密码为ora123。
2. userdeluserdel 命令用于删除一个已存在的帐号，其用法为：userdel 用户名3. groupaddgroupadd 命令可以创建一个新的用户组，其最基本用法为：groupadd 组名如输入以下命令：groupadd newgroup系统将创建一个新的用户组newgroup。
4. groupdelgroupdel 命令用于删除一个已存在的用户组，其用法为：groupdel 组名5. passwd出于系统安全考虑，Linux 系统中的每一个用户除了有其用户名外，还有其对应的用户口令。
用户可以随时用passwd 命令改变自己的口令，该命令的一般格式为：passwd输入该命令后，按系统提示依次输入密码和密码确认后，即可完成用户密码的修改。
此外超级用户还可以修改其他用户的口令，命令如下：passwd 用户名6. susu 命令这个命令非常重要，它可以让一个普通用户拥有超级用户或其他用户的权限，也可以让超级用户以普通用户的身份做一些事情。