东北大学操作系统第一次实验报告
操作系统安全实验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、账户管理成功创建了具有不同权限的用户账户,并能够根据需求灵活调整权限设置。
严格的密码策略有效地增加了密码的安全性,减少了被破解的风险。
账户锁定策略在一定程度上能够阻止暴力破解攻击。
《操作系统》实验报告
《操作系统》实验报告一、实验目的操作系统是计算机系统中最为关键的组成部分之一,本次实验的主要目的是深入理解操作系统的基本原理和功能,通过实际操作和观察,熟悉操作系统的核心概念,包括进程管理、内存管理、文件系统和设备管理等,提高对操作系统的实际应用能力和问题解决能力。
二、实验环境本次实验在以下环境中进行:操作系统: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)通过“结束任务”按钮可以结束指定的进程,但要注意不要随意结束系统关键进程,以免导致系统不稳定。
东北大学操作系统实验报告
{
public:
char name;
string status;
};
vector<Pro> ru,re,bl; //ru->running,re->ready,bl->blocked
//function declaration
int helloUI();
re.push_back(process);
else if(sta == "b")
bl.push_back(process);
else
cout << "Error!!" << endl;
cout << "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^" << endl;
cout << endl;
}
else
cout << "Error in ruTObl2." << endl;
showPCB();
return 0;
}
int blTOre()
{
if(!bl.empty()) //blockedQueue is not empty.
{
re.push_back(bl.front());
bl.erase(bl.begin());
{
int act; //choose action
helloUI();
cout << "Please initialize the process." << endl;
操作系统安全实验1实验报告
操作系统安全实验1一、实验目的1. 了解Windows的文件系统2. 掌握Windows操作系统的访问控制和审核技术3. 掌握系统安全配置和安全分析方法4.理解Windows平台下的漏洞扫描原理5. 掌握系统备份与恢复方法二、实验环境PC机,Windows XP操作系统,X-Scan v3.3,Ghost软件一套三、实验内容1. 系统安全配置与分析2. 管理用户帐户3. 授权管理4.设置审核策略5. 使用X-Scan对系统进行安全扫描6. 系统的网络服务管理7. 系统备份与恢复四、实验步骤与结果分析1、系统安全配置与分析(1)修改密码策略首先在“控制面板”中选择“管理工具”——“本地安全设置”——“帐户策略”——“密码策略”如下所示:双击“密码必须符合复杂性要求”或者右击它选择属性,启用该策略,如下所示:双击“密码长度最小值”,设置最短密码长度为8个字符,如下所示:设置“密码最短存留期”,确定用户在可以更改密码之前必须使用该密码的天数,设置为7天。
如下所示:设置“密码最长存留期”,确定系统在要求用户更改密码之前可以使用该密码的天数,设置为30天。
设置“强制密码历史”,防止用户重新使用旧密码,设置为3。
如下所示:设置完成后退出“本地安全设置”,在“运行”中输入命令:gpupdate,系统将刷新刚才修改的安全策略。
选择一个普通用户,为该用户重设口令,体会密码加强策略的作用,起初用户名设为love,密码设为520。
如下所示:结合密码复杂性设置原则(大写字母+小写字母+数字)再将密码修改为abc19881211,结果创建成功。
(2)设置帐户锁定策略对帐户锁定策略进行设置,值为2,然后重新登录系统,使用用户zhengjiaen口令登录系统,体会帐户锁定的作用。
如下所示:(4)系统安全策略分析在“运行”中输入MMC,打开控制台界面。
单击“文件”——“添加/删除管理单元”——“添加”,选择“安全配置和分析”并添加,如下所示:右击“安全配置与分析”,选择“打开数据库”,可以通过输入数据库名称1,并选择一个安全模板创建一个新的安全策略数据库,利用这个数据库可以分析当前计算机的安全配置与安全策略模板的差异,如下所示:利用安全策略模板对当前计算机进行配置。
操作系统实验报告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资源管理器”相似。
东北大学操作系统实验报告
课程编号:B080000070《操作系统》实验报告姓名班级指导教师石凯实验名称《操作系统》实验开设学期2016-2017第二学期开设时间第11周——第18周报告日期2017年7月3日评定成绩评定人石凯评定日期2017年7月5日东北大学软件学院实验一进程的同步与互斥实验题目:通过学习和分析基础例子程序,使用windows进程和线程编程(也可以采用Java 或Unix/Linux的POSIX线程编程)实现一个简单的生产者/消费者问题的程序。
关键代码:import java.util.ArrayList;public class Produce {public Object object;public ArrayList<Integer> list;//用list存放生产之后的数据,最大容量为1public Produce(Object object,ArrayList<Integer> list ){this.object = object;this.list = list;}public void produce() {synchronized (object) {/*只有list为空时才会去进行生产操作*/try {while(!list.isEmpty()){System.out.println("生产者"+Thread.currentThread().getName()+" waiting");object.wait();}int value = 9999;list.add(value);System.out.println("生产者"+Thread.currentThread().getName()+" Runnable");object.notifyAll();//然后去唤醒因object调用wait方法处于阻塞状态的线程}catch (InterruptedException e) {e.printStackTrace();}}}}import java.util.ArrayList;public class Consumer {public Object object;public ArrayList<Integer> list;//用list存放生产之后的数据,最大容量为1public Consumer(Object object,ArrayList<Integer> list ){this.object = object;this.list = list;}public void consmer() {synchronized (object) {try {/*只有list不为空时才会去进行消费操作*/while(list.isEmpty()){System.out.println("消费者"+Thread.currentThread().getName()+" waiting");object.wait();}list.clear();System.out.println("消费者"+Thread.currentThread().getName()+" Runnable");object.notifyAll();//然后去唤醒因object调用wait方法处于阻塞状态的线程}catch (InterruptedException e) {e.printStackTrace();}}}}实验结果:思考题:(1)如何控制进程间的相互通信?答:主要有:管道,信号,共享内存,消息队列(2)什么是进程的同步?什么是进程的互斥?分别有哪些实现方式?答:进程互斥是进程之间的间接制约关系。
《操作系统》课内实验报告
《操作系统》课内实验报告一、实验目的操作系统是计算机系统的核心组成部分,本次《操作系统》课内实验旨在通过实际操作和观察,深入理解操作系统的基本原理、功能和运行机制。
具体目的包括:1、熟悉操作系统的常用命令和操作,如文件管理、进程管理、内存管理等。
2、掌握操作系统的资源分配和调度策略,观察其对系统性能的影响。
3、培养解决操作系统相关问题的能力,提高动手实践和分析问题的能力。
二、实验环境本次实验在以下环境中进行:1、操作系统:Windows 10 专业版2、开发工具:Visual Studio Code三、实验内容及步骤(一)文件管理实验1、创建、删除和重命名文件及文件夹打开文件资源管理器,在指定目录下创建新的文件夹和文本文件。
对创建的文件和文件夹进行重命名操作,观察文件名的变化。
选择部分文件和文件夹进行删除操作,验证是否成功删除。
2、文件复制、移动和属性设置选取一些文件,将其复制到其他目录,并观察复制过程和结果。
把特定文件移动到不同的位置,检查文件是否正确迁移。
设置文件的属性,如只读、隐藏等,查看属性设置后的效果。
(二)进程管理实验1、查看系统进程打开任务管理器,观察当前正在运行的进程列表。
了解进程的名称、PID(进程标识符)、CPU 使用率、内存占用等信息。
2、进程的终止和优先级设置选择一个非关键进程,尝试终止其运行,观察系统的反应。
调整某些进程的优先级,观察其对系统资源分配和运行效率的影响。
(三)内存管理实验1、查看内存使用情况通过系统性能监视器,查看物理内存和虚拟内存的使用情况。
观察内存使用量随时间的变化趋势。
2、内存优化操作关闭一些不必要的后台程序,释放占用的内存资源。
调整虚拟内存的大小,观察对系统性能的改善效果。
四、实验结果与分析(一)文件管理实验结果1、成功创建、删除和重命名文件及文件夹,系统能够准确响应操作,文件名和文件夹名的修改即时生效。
2、文件的复制和移动操作顺利完成,数据无丢失和损坏。
《操作系统》课程实验报告
《操作系统》课程实验报告一、实验目的本次《操作系统》课程实验的主要目的是通过实际操作和观察,深入理解操作系统的工作原理、进程管理、内存管理、文件系统等核心概念,并掌握相关的操作技能和分析方法。
二、实验环境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)观察并分析在不同的并发情况下,系统的运行结果和资源竞争情况。
东北大学操作系统实验之Linux及进程状态
操作系统实验报告一实验一进程状态转换及其PCB的变化一、实验目的:自行编制模拟程序,通过形象化的状态显示,使学生理解进程的概念、进程之间的状态转换及其所带来的PCB内容、组织的变化,理解进程与其PCB间的一一对应关系。
二、实验内容及要求:(1)、设计并实现一个模拟进程状态转换及其相应PCB内容、组织结构变化的程序。
(2)、独立编写、调试程序。
进程的数目、进程的状态模型(三状态、五状态、七状态或其它)以及PCB的组织形式可自行选择。
(3)、合理设计与进程PCB相对应的数据结构。
PCB的内容要涵盖进程的基本信息、控制信息、资源需求及现场信息。
(4)、设计出可视性较好的界面,应能反映出进程状态的变化引起的对应PCB内容、组织结构的变化。
(5)、代码书写要规范,要适当地加入注释。
(6)、鼓励在实验中加入新的观点或想法,并加以实现。
(7)、认真进行预习,完成预习报告。
(8)、实验完成后,要认真总结,完成实验报告。
五状态模型:三、主要数据结构:struct Run_type //运行态进程{char name;int state;int needtime;int priority;};struct Ready_type //就绪态进程{char name;int needtime;int priority;};struct Blocked_type //阻塞态进程{char name;int needtime;int priority;};四、程序源代码:#include<stdio.h>#include<stdlib.h>#include<string.h>int i=0; int j=0;struct Run_type{char name;int state;int needtime;int priority;};struct Ready_type{char name;int needtime;int priority;};struct Blocked_type{char name;int needtime;int priority;};struct Run_type Cpu;struct Ready_type Ready[10];struct Blocked_type Blocked[10];void Creat(){ //创建一个新的进程int k=0;label1:printf(" input new process name(input a letter): \n");scanf("%s",&(Ready[i].name));getchar();for(k=0;k<i;k++)if(Ready[i].name==Ready[k].name||Ready[i].name==Ready[k].name+32||Ready[i].n ame==Ready[k].name-32){printf("the process is already exist!");goto label1;}printf("input needtime (input a int number):\n");label3:scanf("%d",&(Ready[i].needtime));getchar();if(Ready[i].needtime<1||Ready[i].needtime>100){printf("please input the true needtime(1--100)\n");goto label3;}printf(" input the priority(1--10): \n");label2:scanf("%d",&(Ready[i].priority));getchar();if(Ready[i].priority<1||Ready[i].priority>10){printf("please 1--10!\n");goto label2;}i++;}void Dispath() //P135{int t;char v;int k;int j;if(Cpu.state==0)if(Ready[i-1].needtime==0){printf("* there is no process ready!\n");exit(0);}else{for(k=0;k<i-1;k++)for(j=0;j<i-k-1;j++)if(Ready[j].priority>Ready[j+1].priority){t=Ready[j].priority;Ready[j].priority=Ready[j+1].priority;Ready[j+1].priority=t;t=Ready[j].needtime;Ready[j].needtime=Ready[j+1].needtime;Ready[j+1].needtime=t;v=Ready[j].name;Ready[j].name=Ready[j+1].name;Ready[j+1].name=v;}--i;=Ready[i].name;Cpu.needtime=Ready[i].needtime;Cpu.priority=Ready[i]. priority;Cpu.state=1;printf("*%5c is send to cpu! \n",);Cpu.needtime--;if(Cpu.needtime==0){printf("*%5c is finished \n",);Cpu.state=0;}}else{Ready[i].name=;Ready[i].needtime=Cpu.needtime;Ready[i].priority=Cpu.priority;for(k=0;k<i;k++)for(j=0;j<i-k;j++)if(Ready[j].priority>Ready[j+1].priority){t=Ready[j].priority;Ready[j].priority=Ready[j+1].priority;Ready[j+1].priority=t;t=Ready[j].needtime;Ready[j].needtime=Ready[j+1].needtime;Ready[j+1].needtime=t;v=Ready[j].name;Ready[j].name=Ready[j+1].name;Ready[j+1].name=v;}=Ready[i].name;Cpu.needtime=Ready[i].needtime;Cpu.priority=Ready[i]. priority;Cpu.state=1;printf("*%5c is send to cpu! \n",);Cpu.needtime--;if(Cpu.needtime==0){printf("*%5c is finished \n",);Cpu.state=0;}}}void Timeout(){if(Cpu.state==0){printf("* there is no process in cpu(please select Dispath!\n");exit(0);}else{Ready[i].name=;Ready[i].needtime=Cpu.needtime;Ready[i].priority=Cpu.priority;printf("%c is timeout \n",);=0;Cpu.needtime=0;Cpu.priority=0;Cpu.state=0;i++;}}void Eventwait(){if(Cpu.state!=0){Blocked[j].name=;Blocked[j].needtime=Cpu.needtime;Blocked[j].priority=Cpu.priority;printf("* %c is Blocked !\n",);j++;=Blocked[j].name;Cpu.needtime=Blocked[j].needtime;Cpu.priority=Blocked[j].priority;Cpu.state=0;}elseprintf("* There is no process in cpu!");}void Eventoccurs(char a){int k=0;int m=0;int n=0;int p=0;if(Blocked[0].needtime==0){printf("* there is no process blocked!\n");exit(0);}else{for(k;k<j;k++)if(Blocked[k].name==a){Ready[i].name=Blocked[k].name;Ready[i].needtime=Blocked[k].needtime;Ready[i].priority=Blocked[k].priority;p=1;m=j-k;for(n;n<m;n++){Blocked[k].name=Blocked[k+1].name;Blocked[k].needtime=Blocked[k+1].needtime;Blocked[k].priority=Blocked[k+1].priority;k++;}j--;i++;}if(p==1)printf("* %c is ready!\n",a);elseprintf("* %c is not found! \n",a);}}void main(){Cpu.state=0;int Cputime=0;int x=6;while(x!=0){printf("\n1:input new process 2:Dispath\n");printf("3:Timeout4:Eventwait\n");printf("5:Eventoccurs(select whose eventoccur ) 0:exit\n");label4:scanf("%d",&x);getchar();printf("\n==============================================================================\n");if(x==0||x==1||x==2||x==3||x==4||x==5){switch(x){case 1:Creat();break;case 2:Dispath();break;case 3:Timeout();break;case 4:Eventwait();break;case 5:char a;scanf("%c",&a);getchar(); Eventoccurs(a);break;default:printf("please select from 0 to 5\n");}printf("----------------------------- Cputime:%3d----------------------------------\n",Cputime);printf("| ProceNsname NeedTime Priority |\n");if(Cpu.state!=0)//显示Cpu中的程序{printf("| Cpu:%16c",);printf("%20d",Cpu.needtime);printf("%18d|\n",Cpu.priority);}elseprintf("| * Cpu is free |\n");int y=0;if(i==0)//显示Ready队列中的数据{printf("| *There is no process ready. |\n");}else{for(y;y<i;y++)//显示Ready中的程序{printf("| Ready%d:",y);printf("%15c",Ready[y].name);printf("%20d",Ready[y].needtime);printf("%18d|\n",Ready[y].priority);}}int z=0;if(j==0) //显示Blocked队列中的程序{printf("| *There is no process blocked. |\n");}else{for(z;z<j;z++){printf("| Blocked%d:",z);printf("%13c",Blocked[z].name);printf("%20d",Blocked[z].needtime);printf("%18d |\n",Blocked[z].priority);}}Cputime++;if(Cpu.state!=0)Cpu.needtime=Cpu.needtime-1;printf("-----------------------------------------------------------------------------\n");}else{printf("please input 0--5\n");goto label4;}}}五、运行结果:1.创建a,b两个进程2、调度进程(由于b优先级高,所以b先进入运行态)3、当b时间片到了,b变为就绪态4、再次调度(由于b优先级高,故还是b变成运行态)5、正在运行的b阻塞6、当b等待的事件发生,b重新进入就绪态六、程序使用说明:编译程序后若无错就执行程序,初始如下:其中:1表示创建新进程,随后输入进程名,所需时间,优先级 2表示系统调度进程,首先调度最高优先级3表示时间片已到,运行中的进程将编程就绪态4表示进程所需的事件尚未发生,进程将被阻塞5表示进程等待的事件已发生,进程从阻塞态变为就绪态 0退出程序10。
操作系统第一次实验报告
实验(一)操作系统的进程调度一、目的与要求1、目的进程是操作系统最重要的概念之一,进程调度又是操作系统核心的主要内容。
本实习要求学生独立地用高级语言编写和调试一个简单的进程调度程序。
调度算法可任意选择或自行设计。
例如,简单轮转法和优先数法等。
本实习可加深对于进程调度和各种调度算法的理解。
2、要求(1)设计一个有n 个进程工行的进程调度程序。
每个进程由一个进程控制块(PCB)表示。
进程控制块通常应包含下述信息:进程名、进程优先数、进程需要运行的时间、占用CPU 的时间以及进程的状态等,且可按调度算法的不同而增删。
(2)调度程序应包含2~3种不同的调度算法,运行时可任意选一种,以利于各种算法的分析比较。
(3)系统应能显示或打印各进程状态和参数的变化情况,便于观察诸进程的调度过程。
二、优先数法(以数值大为高优先级)进程就绪链按优先数大小从高到低排列,链首进程首先投入运行。
每过一个时间片,运行进程所需运行的时间片数减1,说明它已运行了一个时间片,优先数减一。
接着比较现行进程和就绪链链首进程的优先数,如果仍是现行进程高或者相同,就让现行进程继续进行,否则,调度就绪链链首进程投入运行。
原运行进程再按其优先数大小插入就绪链,且改变它们对应的进程状态,直至所有进程都运行完各自的时间片数。
三、实习题(1)编制和调试示例给出的进程调度程序,并使其投入运行。
(2)自行设计或改写一个进程调度程序,在相应机器上调试和运行该程序,其功能应该不亚于示例。
(3)直观地评测各种调度算法的性能。
四、思考题(1)示例中的程序,没有使用指针型(pointer)数据结构,如何用指针型结构改写本实例,使更能体现C 语言的特性。
(2)如何在程序中真实地模拟进程运行的时间片?(3)如果增加进程的“等待”状态,即进程因请求输入输出等问题而挂起的状态,如何在程序中实现?五:具体代码实现#include<iostream>#include<list>using namespace std;class PCB{public:string pname;//进程名int weight;//优先级int arritime;//进程到达时间,注意:是以时间片为单位int need_runtime;int cost_cputime;char state;//注:有3中状态,w表示就绪,r表示运行,f表示完成public:PCB (){pname="";weight=0;arritime=0;need_runtime=0;cost_cputime=0;state='w';};void change_1(){weight-=1;cost_cputime+=1;}void set_state(){state='f';}};ostream& operator<<(ostream& os,const PCB&pcb){os<<"进程名:"<<pcb.pname<<'\t'<<"优先级:"<<pcb.weight<<'\t'<<"到达时间:"<<pcb.arritime<<endl;os<<"需运行时间:"<<pcb.need_runtime<<'\t'<<"已用cpu时间:"<<pcb.cost_cputime<<'\t'<<"状态:"<<pcb.state<<endl;return os;}int main(){cout<<"请输入进程个数:"<<endl;string name;int wei;int arrit;int runtime;list<PCB> pro_list;int number;cin>>number;PCB progress;cout<<"请依次输入进程名,优先数,到达时间,需要运行时间"<<endl;while(number){cin>>name>>wei>>arrit>>runtime;cout<<endl;progress.pname=name;progress.weight=wei;progress.arritime=arrit;progress.need_runtime=runtime;pro_list.push_back(progress);number-=1;}/*PCB progress_one("pro1",3,0,4);PCB progress_two("pro2",3,2,5);PCB progress_three("pro3",6,3,5);PCB progress_four("pro4",2,4,5);*/int all=0;list<PCB>::iterator it=pro_list.begin();while(it!=pro_list.end()){cout<<*it;all+=it->need_runtime;it++;}cout<<endl;int time=0;//记录此刻的时间// cout<<"开始系统时间为"<<time<<endl;while(all){list<PCB>::iterator it=pro_list.begin();cout<<"就绪队列:"<<endl<<endl;list<PCB>::iterator itmax;int j=0;while(it!=pro_list.end()){if(it->arritime<=time){cout<<*it;if(j==0) {j=1;itmax=it;}else {if(itmax->weight<it->weight)itmax=it;//itmax始终指向就绪队列中优先级最大的进程}}it++;}if(j==0) {cout<<"输入的进程中应至少有一个到达时间为0的进程"<<endl; system("pause");return 0;}cout<<"进程"<<itmax->pname<<"运行一个时间片"<<endl;time+=1;itmax->change_1();if(itmax->need_runtime==itmax->cost_cputime) //如果进程需要运行的时间等于cpu运行的时间{itmax->set_state();cout<<*itmax<<endl;pro_list.erase(itmax);}elsecout<<*itmax<<endl;//cout<<"此刻系统时间"<<time<<endl<<endl;all-=1;}cout<<'\n';cout<<"进程全部运行完毕!"<<endl;system("pause");return 0;}六、实验截图:七、实验感想由于我刚开始对于cpp编程语言并不很熟悉,所以刚开始查询了许多资料,然后不断整合修改,后来慢慢的从能看懂,到会修改,直到会自己编写。
操作系统实验报告
write:用于写文件。
read:用于读文件。
rm:用于删除文件。
思考:
(1)如果引入磁盘索引结点,上述实现过程需要哪些修改?
(2)如果设计的是一个多用户文件系统,则又要进行哪些扩充?
3实验结果(给出编写的程序源代码和运行结果的截图并回答思考问题)
源代码:
实验心得:
基本上实现了DOS下简单文件系统的实现,通过学习基本掌握了文件系统的存储结构
(5)要求提供以下有关的操作:
format:对文件存储器进行格式化,即按照文件系统的结构对虚拟磁盘空间进行布局,并在其上创建根目录以及用于管理文件存储空间等的数据结构。
mkdir:用于创建子目录。
rmdir:用于删除子目录。
ls:用于显示目录。
cd:用于更改当前目录。
create:用于创建文件。
open:用于打开文件。
ID 0 1 2 3 4
PRIORITY 9 38 30 29 0
CPUTIME 0 0 0 0 0
ALLTIME 3 3 6 3 4
STARTBLOCK 2 -1 -1 -1 -1
BLOCKTIME 3 0 0 0 0
STATE ready ready ready ready ready
(5)为了清楚的观察各进程的调度过程,程序应将每个时间片内的情况显示出来,参照的具体格式如下:
(3)置换算法:请分别考虑OPT、FIFO和LRU算法。
(4)作业中指令的访问次序按下述原则生成:
•50%的指令是顺序执行的。
•25%的指令是均匀分布在前地址部分。
•25%的指令时均匀分布在后地址部分。
3实验结果(给出编写的程序源代码和运行结果的截图)
操作系统第一次实验
7.问:删除文件或目录rm(remove),区别rmdir只能删目录
8.问:显示一个文件内容cat
9.用户切换su
su和su -的区别是前者只是切换了root的身份,后者连同shell一起切换成root模式,shell类似于window下的cmd.exe
(2)
1.建立.c文件
除了用vim编辑器,还有一个编辑器emacs
man cmd例如:要获取gcc的命令信息,可向终端输入man gcc
下面是关于gcc的信息,按q可回到终端
2.问:怎么列出某个目录下的文件
输入命令ls,可查看全部文件
或者想查看某个目录下的文件,则可以“ls文件路径”
3.问:查找文件位于那个目录可以用find
4.问:切换目录可用“cd指定目录”
5.问:创建目录与删除目录分别用mkdir、rmdir;
实验内容及要求(详见实验讲义):
1)通过操作熟悉基本Linux命令
2)编写、编译、执行、调试一个C程序
3)复习C语言基本语法
4)虚拟机配置和Linux系统安装
实验用到的软件(:)
VMware 12
Fedora 23
实验内容、关键步骤(流程图、代码等)及结果分析(70分)
(1)
1.问:如何获取命令的帮助信息?
2.推出编辑模式vim是按esc然后输入:wq即可;emacs是ctrl+x+c
3.使用编译器gcc
不会怎么得到c.exe
实验过程中遇到的问题解决办法与实验体会(10分)【请注意:此处必须如实填写,为空或不适均扣10分】
操作系统课程实验报告
姓名
龙泳潮
学号
1301070034
操作系统实验报告1
操作系统实验报告1实验一进程控制与描述一、实验目的1. 利用Windows提供的API函数,编写程序,实现进程的创建和终止(如创建写字板进程及终止该进程)。
2. 加深对操作系统进程概念的理解,观察操作系统进程运行的动态性能,获得包含多进程的应用程序编程经验。
二、实验内容与步骤1. 进程的创建和终止。
编写一段程序,可以创建一个进程,并终止当前创建的进程。
试观察记录程序执行的结果,并分析原因。
2. 利用VC++6.0实现上述程序设计和调试操作,对于进程创建的成功与否、终止进程操作的成功与否提供一定的提示框。
3. 通过阅读和分析实验程序,学习创建进程、观察进程和终止进程的程序设计方法。
三、实验中遇到的问题及解决方法1.进程的句柄与退出代码查阅相关资料,对句柄的概念有一个初步的了解:从数据类型上来看它只是一个32位(或64位)的无符号整数。
在Windows环境中,句柄是用来标识项目的。
WINDOWS程序中并不是用物理地址来标识一个内存块,文件,任务或动态装入模块的。
相反,WINDOWS API给这些项目分配确定的句柄,并将句柄返回给应用程序,然后通过句柄来进行操作。
在程序设计中,句柄是一种特殊的智能指针。
当一个应用程序要引用其他系统(如数据库、操作系统)所管理的内存块或对象时,就要使用句柄。
句柄与普通指针的区别在于,指针包含的是引用对象的内存地址,而句柄则是由系统所管理的引用标识,该标识可以被系统重新定位到一个内存地址上。
这种间接访问对象的模式增强了系统对引用对象的控制。
在本实验中,Create Process()中创建了进程pi ,可直接用pi.hProcess获取。
2.句柄和进程ID的区别句柄实际是一个指针,他指向一块包含具体信息数据的内存,可以当做索引,所以进程句柄是当你要访问该进程时取得的,使用完毕必须释放。
id一般是一个标识符,用来区别不同项一个进程在不同的调用时间中有可能句柄的值是不一样的,但是ID只有也只能有一个。
《操作系统》实验报告
《操作系统》实验报告一、实验目的操作系统是计算机系统的核心组成部分,本次实验的主要目的是深入理解操作系统的工作原理和功能,通过实际操作和观察,掌握操作系统的进程管理、内存管理、文件系统管理等方面的知识和技能。
二、实验环境本次实验使用的操作系统为 Windows 10,开发工具为 Visual Studio 2019,编程语言为 C++。
三、实验内容及步骤1、进程管理实验(1)创建进程通过编程实现创建新的进程。
在代码中使用了 Windows API 函数CreateProcess 来创建一个新的进程。
首先,设置进程的启动信息,包括命令行参数、工作目录等。
然后,调用CreateProcess 函数创建进程,并检查返回值以确定创建是否成功。
(2)进程同步使用互斥量(Mutex)实现进程间的同步。
创建一个共享资源,多个进程尝试访问该资源。
通过互斥量来保证同一时间只有一个进程能够访问共享资源,避免了数据竞争和不一致的问题。
(3)进程通信采用管道(Pipe)进行进程间的通信。
创建一个匿名管道,一个进程作为发送端,向管道写入数据;另一个进程作为接收端,从管道读取数据。
通过这种方式实现了进程之间的数据交换。
2、内存管理实验(1)内存分配使用 Windows API 函数 VirtualAlloc 来分配内存。
指定分配的内存大小、访问权限等参数,并检查返回的内存指针是否有效。
(2)内存释放在不再需要使用分配的内存时,使用 VirtualFree 函数释放内存,以避免内存泄漏。
(3)内存保护设置内存的保护属性,如只读、读写等,以防止非法访问和修改。
3、文件系统管理实验(1)文件创建与写入使用 CreateFile 函数创建一个新文件,并通过 WriteFile 函数向文件中写入数据。
(2)文件读取使用 ReadFile 函数从文件中读取数据,并将读取的数据输出到控制台。
(3)文件属性操作获取文件的属性信息,如文件大小、创建时间、修改时间等,并进行相应的操作和显示。
东北大学操作系统实验 绝对自创 实验报告 含可执行源代码 linux环境可运行 有截图
int data = 0;//生产者生产的数据
int num = 0;//缓冲区元素个数
int np = 0;//正在等待的生产者
int nc = 0;//正在等待的消费者
int main()
{
print();
char c;
while(scanf("%c",&c)!='e')
buffer.push(ch);
buffer.pop();
}
printf("\n");
}
三、实验结果
实验三进程的管道通信
一、实验目的
加深对进程概念的理解,明确进程和程序的区别。
学习进程创建的过程,进一步认识进程并发执行的实质。
分析进程争用资源的现象,学习解决进程互斥的方法。
学习解决进程同步的方法。
掌握Linux系统中进程间通过管道通信的具体实现。
read(fd[0],father,17);
cout << father << endl;
}
}
}
return 0;
}
三、实验结果
实验四页面置换算法
一、实验目的
进一步加深理解父子进程之间的关系及其并发执行。
理解内存页面调度的机理。
掌握页面置换算法及其实现方法。
培养综合运用所学知识的能力。
二、实验内容
#include <iostream>
{
if(Acess_Series[i] == M_Frame[j])//命中
{
cout << "子程序2 命中: " ;
东北大学 操作系统实验一报告
操作系统实验报告班级物联网1302班学号姓名实验一:熟悉Linux系统目的:①熟悉和掌握Linux系统基本命令,熟悉Linux编程环境,为以后的实验打下基础。
●启动退出、ls(显示目录内容)、cp(文件或目录的复制)、mv(文件、目录更名或移动)、rm(删除文件或目录)、mkdir(创建目录)、rmdir(删除空目录)、cd(改变工作目录)…●C语言编辑、编译内容及要求:●熟练掌握Linux基本文件命令;●掌握Linux编辑程序、对源代码进行编译、连接、运行及调试的过程;●认真做好预习,书写预习报告;●实验完成后要认真总结、完成实验报告login:用户登录系统使用login命令可以允许用户登录系统。
如果没有指定参数,登录时提示输入用户名。
如果该用户不是root,且如果/etc/nologin文件存在,这个文件的内容被显示到屏幕上,登录被终止。
命令语法:Login [选项][用户名]exit:退出系统使用exit命令可以退出shell命令语法:exit[选项]ls:列出目录和文件信息使用ls命令,对于目录而言将列出其中的所有的子目录与文件信息,对于文件而言将输出命令语法:ls[选项][目录|文件]ls命令部分选项含义选项含义-a 显示指定的目录下子目录机文件,包括隐藏文件-A 显示指定目录所有子目录与文件,但不列出.,..-l 以长格式来显示文件的详细信息-d 如果参数是目录,只显示名称而不显示其下的个文件机子目录-F 显示文件类型cp:复制文件和目录使用cp命令可以复制文件vhe目录到其他目录中。
如果同时指定两个以上的文件或目录,且最后的目的地是一个已经存在的目录,则它会把前面指定的所有的文件或目录复制到该目录中。
若同时指定多个文件或目录,而最后的目的地并非一个已存在的目录,则会出现错误信息。
命令语法:cp [选项][源文件|目录][目标文件|目录]cp命令部分选项含义-i 覆盖文件之前先询问用户-f 强行复制文件或目录,不论目的文件或目录是否已经存在-R 递归处理,将指定目录下的文件及子目录一并处理-v 显示执行过程-r 递归处理,将指定目录下的文件与子目录一并处理。
操作系统第一次实验报告
操作系统实验报告实验名称:线程控制实验计算机科学与技术学院目录一、实验目的和要求 (2)二、实验内容 (2)三、实验步骤 (2)四、实验结果与分析 (3)1.单线程 (3)2.单线程(睡眠4s) (3)3.多线程 (4)4.多线程(每个子线程睡眠1s) (4)5.单线程与多线程对比 (5)五、程序源代码 (5)1.单线程实验代码 (5)2.单线程实验代码 (6)六、实验体会 (7)一、实验目的和要求通过本实验掌握在Linux操作系统中遵循Posix线程标准接口进行多线程程序编程,熟练掌握线程的创建pthread_create(),线程的终止pthread_exit(),等待线程合并pthread_join()等线程控制操作,利用信号量或者互斥锁实现线程建的同步。
二、实验内容问题:求1000000个浮点数(精确到小数点后4位)的平均值(和,最大值,最小值),具体的问题描述流程图如下图图1所示:三、实验步骤1、随机生成1000000个浮点数;2、创建4个子线程,分别求250000个浮点数之和;3、完成1000000个浮点数之和并打印结果;4、统计多线程并发执行完成计算的时间;5、写一个单线程程序,同样完成1000000个随机数求和的计算,统计计算时间,并和前面结果进行对比;6、让单线程程序睡眠四秒钟、多线程程序各子程序睡一秒的条件下(两个程序总的睡眠时间相同),对比执行结果;7、分析两次对比结果的差异,写出自己的见解。
四、实验结果与分析1、单线程完成1000000个浮点数的求和运算所用的时间情况如下图图2所示:图2 单线程计算时间分析:实验中每次随机产生一个0到1之间的浮点数,1000000个这样的数相加的话的平总和大概就在500000左右(按照随机数的平均值原理),实验中sum=,显然结果正确,整个计算运行时间为。
2、单线程完成1000000个浮点数的求和运算,单线程中睡眠4秒钟,所用的时间情况如下图图3所示:图3 单线程计算时间(睡眠4秒)分析:根据上一次单线程的执行情况来看,这一次让单线程睡眠4秒钟,最后执行时间刚好就是4秒加上计算时间。
操作系统第一次实验报告_操作系统临界区问题
操作系统第一次实验报告_操作系统临界区问题操作系统临界区问题刘唯墨一、实验目的本实验讨论临界区问题及其解决方案。
实验首先创建两个共享数据资源的并发线程。
在没有同步控制机制的情况下,我们将看到某些异常现象。
针对观察到的现象,本实验采用两套解决方案:利用Windows 的mutex 机制采用软件方案然后比较这两种方案的性能优劣。
二、实验步骤1、制造混乱Windows 操作系统支持抢先式调度,这意味着一线程运行一段时间后,操作系统会暂停其运行并启动另一线程。
也就是说,进程内的所有线程会以不可预知的步调并发执行。
为了制造混乱,我们首先创建两个线程t1 和t2。
父线程(主线程)定义两个全局变量,比如accnt1 和accnt2。
每个变量表示一个银行账户,其值表示该账户的存款余额,初始值为0。
线程模拟在两个账户之间进行转账的交易。
也即,每个线程首先读取两个账户的余额,然后产生一个随机数r,在其中一个账户上减去该数,在另一个账户上加上该数。
代码如下:#include#include#includeint accnt1=0;int accnt2=0;double begin=0;double end=0;double time=0;int a=1;//HANDLE hMutex=CreateMutex(NULL,FALSE,NULL); DWORD WINAPI run(LPVOID p) {int counter=0;int tmp1,tmp2,r;//WaitForSingleObject(hMutex,INFINITE);begin=GetTickCount();do {tmp1=accnt1;tmp2=accnt2;r=rand();accnt1=tmp1+r;accnt2=tmp2-r;counter++;} while (accnt1+accnt2==0&&counter<1000000); end=GetTickCount();time=end-begin;printf("进?程¨?%d所¨′用??时o?à间?为a%lf\n",a,time); a++;//ReleaseMutex(hMutex);counter=0;return 0;}int main(int argc, char *argv[]){CreateThread(NULL,0,run,NULL,0,NULL); CreateThread(NULL,0,run,NULL,0,NULL);system("PAUSE");return 0;}执行结果如下:从运行结果可以看出,每次进程2都可以全部完成,完成一次计数所需要的时间为62ms,而进城1无法全部完成,所用时间不一定。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验1:熟悉Linux系统一、题目:熟悉Linux系统二、目的:熟悉与掌握Linux系统基本命令,熟悉Linux编程环境,为以后的实验打下基础。
1、启动、退出、ls(显示目录内容)、cp(文件或目录的复制)、mv(文件、目录更名或移动)、rm(删除文件或目录)、mkdir(创建目录)、rmdir(删除空目录)、cd(改变工作目录)…2、C语言编辑、编译三、内容及要求:1、熟练掌握Linux基本文件命令;2、掌握Linux编辑程序、对源代码进行编译、连接、运行及调试的过程;3、认真做好预习,书写预习报告;4、实验完成后要认真总结、完成实验报告。
四、内容及要求:在Linux环境下编制、调试源程序的实际过程(每一步的具体说明)。
实验2:进程状态一、题目:进程状态二、目的:自行编制模拟程序,通过形象化的状态显示,使学生理解进程的概念、进程之间的状态转换及其所带来的PCB内容、组织的变化,理解进程与其PCB间的一一对应关系。
三、内容及要求1、设计并实现一个模拟进程状态转换及其相应PCB组织结构变化的程序;2、独立设计、编写、调试程序;3、程序界面应能反映出在模拟条件下,进程之间状态转换及其对应的PCB组织的变化。
4、进程的状态模型(三状态、五状态、七状态或其它)可自行选择,5、代码书写要规范,要适当地加入注释;6、鼓励在实验中加入新的观点或想法,并加以实现;7、认真进行预习,完成预习报告;8、实验完成后,要认真总结,完成实验报告。
四、程序流程图图4、1 进程转换流程五、使用的数据结构及其说明struct PCB //进程控制块PCB{char name; //名字标识string state; //状态int time; //执行时间};typedef struct PCB ElemType;struct QNode{ElemType data;struct QNode *next;}; //链式队列结点typedef struct QNode QNode; //结点typedef struct QNode *PNode;typedef struct{PNode frnt;PNode rear;} LinkQueue; //链式队列六、程序源代码、文档注释及文字说明#include <iostream>#include<stdlib、h>#include<fstream>#include<windows、h>using namespace std;struct PCB //进程控制块PCB{char name; //名字标识string state; //状态int time; //执行时间};typedef struct PCB ElemType;struct QNode{ElemType data;struct QNode *next;}; //链式队列结点typedef struct QNode QNode; //结点typedef struct QNode *PNode;typedef struct{PNode frnt;PNode rear;} LinkQueue; //链式队列void Insert_Queue(LinkQueue &Q,ElemType e) //插入{PNode ptr=(PNode)malloc(sizeof(QNode));if(!ptr){cout<<"(Insert_Queue)动态分配结点失败!\n";exit(1);}ptr->data=e;ptr->next=NULL;Q、rear->next=ptr;Q、rear=ptr;}int Init_Queue(LinkQueue &Q) //初始化{Q、frnt=Q、rear=(PNode)malloc(sizeof(QNode));if(!Q、frnt)exit(1);Q、frnt->next=NULL;return 0;}int Delete_Queue(LinkQueue &Q,ElemType &e) //删除(头结点删除法){PNode ptr;if(Q、frnt==Q、rear) //空队列return 1;ptr=Q、frnt->next; //删除第一个元素Q、frnt->next=ptr->next;e=ptr->data;if(Q、rear==ptr)Q、rear=Q、frnt;free(ptr);return 0;}int Empty_Queue(LinkQueue Q) //判断就是否为空队列,就是1,否0{return (Q、frnt==Q、rear?1:0);}void Print_Queue(LinkQueue &Q) //打印队列元素{PNode ptr;if(Q、frnt==Q、rear) //队列为空时,返回提示信息{cout<<"\t\tempty、\n";}else{ptr=Q、frnt->next;while(ptr!=NULL){cout<<"\t\tProcess's name : "<<ptr->data、name<<endl;ptr=ptr->next;}}}void Print_State(LinkQueue &Q_Ready,LinkQueue &Q_Running,LinkQueue &Q_Blocked){cout<<"\t-----------------------------\n";cout<<"\n\tStatus_Ready:\n";Print_Queue(Q_Ready);cout<<"\n\tStatus_Running: \n";Print_Queue(Q_Running);cout<<"\n\tStatus_Blocked: \n";Print_Queue(Q_Blocked);cout<<"\n\t-----------------------------\n";}void Transision_Two(LinkQueue &Q1,LinkQueue &Q2){ElemType e;if(Empty_Queue(Q1)){cout<<"\nERROR! 前一个队列为空!、\n";return;}Delete_Queue(Q1,e);Insert_Queue(Q2,e);}int main(){int num;char choose;ElemType e;LinkQueue Q_Ready,Q_Running,Q_Blocked;Init_Queue(Q_Ready);Init_Queue(Q_Blocked);Init_Queue(Q_Running);cout<<"\t请输入进入Ready态的进程数目: ";cin>>num;cout<<endl;for(int i=1; i<=num; i++){cout<<"\t第"<<i<<"个进程----";cout<<"\n\t请输入进程名字: ";cin>>e、name;cout<<"\t请输入进程状态: ";cin>>e、state;cout<<"\t请输入进程时间: ";cin>>e、time;Insert_Queue(Q_Ready,e);}cout<<"\t***********************************进程状态转换分割线************************************\n";cout<<"\tN=创建进程(New),D=调度(Dispatch),T=时间片到(Timeout),W=等待事件(Event Wait),";cout<<"\n\tC=事件发生(Event Occur),E=退出进程(Exit),P=输出各进程(Print),O=退出程序(Overgame)"<<endl;cout<<"\t请选择操作(N,D,T,W,C,E,P,O): ";cin>>choose;while(choose!='O'){switch(choose){case 'N'://N=创建进程(New){cout<<"\t请输入进入Ready态的进程数目: ";cin>>num;cout<<endl;for(int i=1; i<=num; i++){cout<<"\t第"<<i<<"个进程----";cout<<"\n\t请输入进程名字: ";cin>>e、name;cout<<"\t请输入进程状态: ";cin>>e、state;cout<<"\t请输入进程时间: ";cin>>e、time;Insert_Queue(Q_Ready,e);}}Print_State(Q_Ready,Q_Running,Q_Blocked);break;case 'D'://D=调度(Dispatch)Transision_Two(Q_Ready,Q_Running);Print_State(Q_Ready,Q_Running,Q_Blocked);break;case 'T'://T=时间片到(Timeout)Transision_Two(Q_Running,Q_Ready);Print_State(Q_Ready,Q_Running,Q_Blocked);break;case 'W'://W=等待事件(Event Wait)Transision_Two(Q_Running,Q_Blocked);Print_State(Q_Ready,Q_Running,Q_Blocked);break;case 'C': //C=事件发生(Event Occur)Transision_Two(Q_Blocked,Q_Ready);Print_State(Q_Ready,Q_Running,Q_Blocked);break;case 'E': //E=退出进程(Exit)if(Empty_Queue(Q_Running)){cout<<"\n\tRelease Error! 没有正在执行的进程、\n";Print_State(Q_Ready,Q_Running,Q_Blocked);break;}Delete_Queue(Q_Running,e);Print_State(Q_Ready,Q_Running,Q_Blocked);break;case 'P'://P=输出各进程(Print)Print_State(Q_Ready,Q_Running,Q_Blocked);break;case 'O'://O=退出程序(Overgame)exit(1);default:cout<<"输出不符合规则,请重新输入!"<<endl; //操作异常处理break;}cout<<"\t***********************************进程状态转换分割线************************************\n";cout<<"\tN=创建进程(New),D=调度(Dispatch),T=时间片到(Timeout),W=等待事件(Event Wait),";cout<<"\n\tC=事件发生(Event Occur),E=退出进程(Exit),P=输出各进程(Print),O=退出程序(Overgame)"<<endl;cout<<"\t请选择操作(N,D,T,W,C,E,P,O): ";cin>>choose;}return 0;}七、运行结果及其说明运行结果如下截图所示,在截图中相继调用了"N=创建进程(New),D=调度(Dispatch),T=时间片到(Timeout),W=等待事件(Event Wait), C=事件发生(Event Occur),E=退出进程(Exit),P=输出各进程(Print),O=退出程序(Overgame)"命令。