东北大学操作系统实验 绝对自创 实验报告 含可执行源代码 linux环境可运行 有截图

合集下载

Linux操作系统实验实验报告

Linux操作系统实验实验报告

L i n u x操作系统实验实验报告Document number:NOCG-YUNOO-BUYTT-UU986-1986UT实验1:安装Linux系统【实验目的和要求】:安装Linux系统,掌握操作系统的系统配置,建立应用环境的过程。

【实验内容】:1、首先在windows系统中安装虚拟机。

在网上找到VMwareWorksttionPro版本,确定安装目录。

一直下一步,不需要太多的说明。

2、图为安装完成后的界面。

3、然后在阿里巴巴开源镜像网站下载centos系统镜像,然后虚拟机创建新的虚拟机,进行一些简单的虚拟机设置,设置了网络链接nat模式等等。

安装完成后的界面实验2:Linux下c语言开发【实验目的】:学会和掌握用c语言开发一个应用程序的全过程,包括,编译,调试等等。

【实验步骤】:首先在系统中查看是否已经安装有gcc,输入查看命令发现没有,于是需要安装gcc。

在centos系统中可以使用比较简便的yum命令。

在之前已经配置好了yum源。

直接输入yuminstallgcc。

回车自动安装程序和需要的依赖包。

因为虚拟机中和电脑很多地方切换使用不方便,所以安装了xshell软件。

图为xshell中的截图。

安装完毕。

然后使用vi或者vim编写运行,在屏幕上打印出hello,world。

实验3:进程创建【实验目的和要求】1.了解进程的概念及意义;2.了解子进程和父进程3.掌握创建进程的方法。

【实验内容】1.子进程和父进程的创建;2.编写附件中的程序实例【实验步骤】一1、打开终端,输入命令,在文件中输入中的代码;2、输入命令,回车后显示无错误;3、输入命令:./1_fork运行程序。

二、1、打开终端,输入命令,在文件中输入中的代码;2、输入命令,回车后显示无错误:3、输入命令:./2_vfork运行程序。

从上面可以看到两次的运行结果不一样。

我们知道write函数是不带缓存的。

因为在fork之前调用write,所以其数据写到标准输出一次。

linux操作系统 实验报告

linux操作系统 实验报告

linux操作系统实验报告Linux操作系统实验报告一、引言Linux操作系统是一种开源的、免费的操作系统,其内核由Linus Torvalds于1991年首次发布。

Linux操作系统具有稳定性高、安全性强、灵活性大等优点,因此在互联网、服务器、嵌入式系统等领域得到广泛应用。

本实验报告将介绍Linux操作系统的基本特点、安装过程以及常用命令的使用。

二、Linux操作系统的基本特点1. 开源性Linux操作系统的内核及相关软件源代码对用户开放,任何人都可以查看、修改和分发。

这使得Linux操作系统具有高度的透明度和可定制性,用户可以根据自己的需求进行定制和优化。

2. 多用户、多任务Linux操作系统支持多用户同时登录,并且可以同时运行多个任务。

这使得多个用户可以在同一台计算机上独立地进行工作,提高了计算机的利用率。

3. 稳定性和安全性Linux操作系统具有良好的稳定性和安全性。

由于其内核的设计和实现方式,Linux操作系统可以长时间运行而不会出现系统崩溃或死机的情况。

同时,Linux操作系统提供了丰富的安全机制,如文件权限控制、用户身份验证等,可以有效保护系统和用户的数据安全。

三、Linux操作系统的安装过程1. 准备安装介质在安装Linux操作系统之前,需要准备一个可启动的安装介质,如光盘或USB闪存驱动器。

这些介质可以从Linux官方网站或其他可信渠道下载。

2. 进入安装界面将安装介质插入计算机,并按下开机键启动计算机。

在启动过程中,选择从安装介质启动。

随后,将进入Linux操作系统的安装界面。

3. 设置安装选项在安装界面中,可以设置安装选项,如语言、时区、键盘布局等。

根据实际需要进行选择和设置。

4. 分区和格式化磁盘在安装界面中,可以对硬盘进行分区和格式化操作。

根据实际需求,可以选择使用整个硬盘或者将硬盘分为多个分区。

5. 安装系统在分区和格式化完成后,可以开始安装Linux操作系统。

根据安装界面的提示,选择安装位置和安装选项,然后等待安装过程完成。

东北大学linux实验报告

东北大学linux实验报告

东北大学linux实验报告东北大学Linux实验报告引言:在当今信息技术高速发展的时代,计算机科学与技术已经成为了各个领域不可或缺的一部分。

作为计算机领域的重要组成部分,操作系统在实际应用中起着至关重要的作用。

Linux作为一种开源的操作系统,具有稳定性、安全性和灵活性等优势,因此在学术界和工业界均得到了广泛的应用和研究。

本文将对东北大学Linux实验进行总结和分析,以期对Linux操作系统有更深入的了解。

一、实验背景东北大学开设的Linux实验课程旨在帮助学生掌握Linux操作系统的基本原理和应用技巧。

通过实验,学生能够了解Linux的启动过程、文件系统管理、用户权限管理、网络配置等关键概念和操作。

实验采用了虚拟机技术,使得学生可以在实验室或家中的个人电脑上进行实验,提高了实验的灵活性和便捷性。

二、实验内容1. Linux的安装与启动在本实验中,我们首先需要在虚拟机中安装Linux操作系统。

通过选择适当的Linux发行版和版本,进行分区、格式化、安装等步骤,最终完成Linux的安装。

安装完成后,我们需要了解Linux的启动过程,包括BIOS、MBR、GRUB等关键环节。

2. 文件系统管理Linux操作系统以文件为中心,因此文件系统管理是Linux实验的重要内容之一。

通过实验,我们学会了使用命令行和图形界面两种方式来管理文件和目录,包括创建、删除、复制、移动、重命名等操作。

此外,还学习了文件权限和所有权的概念,掌握了chmod、chown等命令的使用方法。

3. 用户权限管理在Linux系统中,用户权限管理是非常重要的一部分。

通过实验,我们学会了创建用户、设置密码、分配权限等操作。

同时,还了解了Linux的用户组概念,学习了添加用户到用户组、设置用户组权限等操作。

4. 网络配置网络配置是Linux实验中的另一个重要内容。

通过实验,我们了解了网络接口的配置和管理,包括IP地址、子网掩码、网关等参数的设置。

东北大学操作系统实验报告4-2017

东北大学操作系统实验报告4-2017

东北⼤学操作系统实验报告4-2017实验四进程的管道通信⼀、实验⽬的1、加深对进程概念的理解,明确进程和程序的区别。

2、学习进程创建的过程,进⼀步认识进程并发执⾏的实质。

3、分析进程争⽤资源的现象,学习解决进程互斥的⽅法。

4、学习解决进程同步的⽅法。

5、掌握Linux系统中进程间通过管道通信的具体实现⼆、实验内容使⽤系统调⽤pipe()建⽴⼀条管道,系统调⽤fork()分别创建两个⼦进程,它们分别向管道写⼀句话,如:Child process1 is sending a message!Child process2 is sending a message!⽗进程分别从管道读出来⾃两个⼦进程的信息,显⽰在屏幕上注:实际要求最好创建两个以上⼦进程,但不需要太多三、实验要求1、这是⼀个设计型实验,要求⾃⾏、独⽴编制程序。

2、两个⼦进程要并发执⾏。

3、实现管道的互斥使⽤。

当⼀个⼦进程正在对管道进⾏写操作时,另⼀个欲写⼊管道的⼦进程必须等待。

使⽤系统调⽤lockf(fd[1],1,0)实现对管道的加锁操作,⽤lockf(fd[1],0,0)解除对管道的锁定。

4、实现⽗⼦进程的同步,当⽗进程试图从⼀空管道中读取数据时,便进⼊等待状态,直到⼦进程将数据写⼊管道返回后,才将其唤醒。

四、程序流程图⽗进程⼦进程五、程序代码及注释#include#include//写管程⽤到的那些函数⽤到的头⽂件#include#include//wait⽤到这个int main(){int fd[2];pipe(fd); //⽗进程创建管道char outpipe[50],inpipe[50]; //存放字符串int pid1,pid2,pid3; //存放返回值while((pid1 = fork()) == -1); //创建不成功就跳不出来了if(pid1 == 0) //⼦进程1{sleep(1); //sleep函数可以决定⼦进程的顺序,等的时间长的话进⼊就晚,输出也就晚lockf(fd[1], 1, 0); //对管道写⼊端⼝加锁sprintf(outpipe,"\n child process 1 is sending message !\n");write(fd[1], outpipe, 50); //把字符串内容写⼊管道写⼊⼝lockf(fd[1], 0, 0); //对管道写⼊⼝解锁exit(0);}else//⽗进程{while((pid2 = fork()) == -1);if(pid2 == 0) //⼦进程2{sleep(2);lockf(fd[1], 1, 0);sprintf(outpipe,"\n child process 2 is sending message !\n");write(fd[1], outpipe, 50);lockf(fd[1], 0, 0);exit(0);}else//⽗进程{while((pid3 = fork()) == -1);if(pid3 == 0) //⼦进程3{sleep(3);lockf(fd[1], 1, 0);sprintf(outpipe,"\n child process 3 is sending message !\n");write(fd[1], outpipe, 50);lockf(fd[1], 0, 0);exit(0);}else//⽗进程{wait(0); //阻塞,等待⼦进程read(fd[0], inpipe, 50); //从管道读出⼝读出信息放到数组printf("%s\n",inpipe);wait(0);read(fd[0], inpipe, 50);printf("%s\n",inpipe);wait(0);read(fd[0], inpipe, 50);printf("%s\n",inpipe); //三个⼦进程,要输出三次exit(0);}}}}六、运⾏结果及说明因为加了锁,不会出现⼦进程同时往管道⾥写的情况,所以,⼦进程互斥地往管道⾥写,⽗进程从管道⾥读并输出,就显⽰成了如上图模样注:⼀个之前不明⽩的流程由fork创建的新进程被称为⼦进程(child process)。

j计算机操作系统实验报告1

j计算机操作系统实验报告1

计算机操作系统 计算机操作系统实验报告学 姓号: 名:2080121 2080121 王佰荣 2009-122009-12-14提交日期: 成 绩:东北大学秦皇岛分校实验报告【实验编号】 实验编号】1【实验名称】 实验名称】 Linux 安装实验 实验内容 1.熟练掌握 内容】 2.掌握虚拟机的使用 掌握虚拟机的使用。

【实验内容】1.熟练掌握 Linux 系统的安装 2.掌握虚拟机的使用。

实验步骤 步骤】 【实验步骤】 一.虚拟机的使用 <1>.新建虚拟机 <1>.新建虚拟机 Vmware,单击菜单“file—new— machine” 1. 打开 Vmware,单击菜单“file—new—virtual machine”,开始创建虚拟机 虚拟机提供两种安装方式“Typical” Custom” 选择“Typical” 2. 虚拟机提供两种安装方式“Typical”和“Custom”,选择“Typical” 选择需要安装的操作系统, Linux— 3. 选择需要安装的操作系统,选择 Linux—Red Hat Linux 4. 输入虚拟机名称和保存文件夹 选择网络连接方式,选择“ networking” 5. 选择网络连接方式,选择“Use bridged networking” 6. 设定虚拟机的硬盘容量为 3G <2>.调整虚拟机的参数 <2>.调整虚拟机的参数 单击出现的“ settings” 调整虚拟机的参数. 单击出现的“Edit virtual machine settings”,调整虚拟机的参数.单击 Memory”可以调整虚拟机的内存; “Memory”可以调整虚拟机的内存;单击 internet”可以调整网卡的工作 “internet” 模式;单击“cd-rom” 文件代替光盘, 模式;单击“cd-rom”可以设置虚拟机的光驱使用 ISO 文件代替光盘,单 add” remove”按钮可以添加、删除硬件。

操作系统实验报告

操作系统实验报告
(2)a. Linux/UNIX的进程和CPU管理类命令:(8个)
命令名
功能
Ps
显示进程状态
Pstree
显示进程树(display a tree of processes)
Kill
给进程发信号
Killhall
按名给进程发信号(kill processes by name)
Skill,snice
报告进程状态(report process status)
(set and get scheduling algorithm/parameters)
sched_rr_get_interval
查看指定进程的SCHED_RR值(get the SCHED_RR interval for the named process)
f. Linux/UNIX进程管理类系统调用(4):与进程跟踪/进程运行时间有关的系统调用(2个)
设置静态优先级范围(get static priority range)
sched_setparam,sched_getparam
设置/查看调度参数
(set and get scheduling parameters)
sched_setscheduler,sched_getscheduler
设置/查看调度算法和参数
7,进程状态START。
8,队列指针NEXT,用来将PCB排成队列。
(3)优先数改变的原则:
1,进程在就绪队列中呆一个时间片,优先数加1。
<程序3>
#include<stdio.h>
main()
{
int p1,p2,i;
while((pl = fork ( ) ) ==-1);

东北大学操作系统实验一报告

东北大学操作系统实验一报告

操作系统实验报告班级物联网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命令部分选项含义cp:复制文件和目录使用cp命令可以复制文件vhe目录到其他目录中。

如果同时指定两个以上的文件或目录,且最后的目的地是一个已经存在的目录,则它会把前面指定的所有的文件或目录复制到该目录中。

若同时指定多个文件或目录,而最后的目的地并非一个已存在的目录,则会出现错误信息。

命令语法:cp [选项][源文件|目录][目标文件|目录]cp命令部分选项含义命令格式:mv [选项] 源文件或目录目标文件或目录.mv命令部分选项含义命令格式:rm [选项] 文件…rm命令部分选项含义能是当前目录中已有的目录命令格式:mkdir [选项] 目录..mkdir命令部分选项含义命令格式:cd [目录名]。

东北大学操作系统实验报告

东北大学操作系统实验报告

课程编号: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)什么是进程的同步?什么是进程的互斥?分别有哪些实现方式?答:进程互斥是进程之间的间接制约关系。

东北大学操作系统实验之Linux及进程状态

东北大学操作系统实验之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。

东北大学操作系统实验报告

东北大学操作系统实验报告
cin >> nam;
= nam;
process.status = "r2";
re.push_back(process);
cout << "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^" << endl;
cout << endl;
if(ru.empty())
{
cin >> act;
if(act == 2)
ruTOre();
else if(act == 3)
ruTObl();
else if(act == 4)
blTOre();
else if(act == 5)
neTOre();
else if(act == 6)
ruTOex();
else
cout << "Error in select."<<endl;
class Pro //process class
{
public:
char name;
string status;
};
vector<Pro> ru,re,bl; //ru->running,re->ready,bl->blocked
//function declaration
int helloUI();
基础内容:编写程序使其模拟两个进程,即生产者(producer)进程和消费者(Consumer)进程工作;生产者每次产生一个数据,送入缓冲区中;消费者每次从缓冲区中取走一个数据。每次写入和读出数据时,都将读和写指针加一。当指针到达缓冲区尾,重新将指针退回起点;

东北大学操作系统实验三报告

东北大学操作系统实验三报告

操作系统实验报告班级物联网1302班学号姓名实验3 进程同步和通信-生产者和消费者问题模拟1. 目的:调试、修改、运行模拟程序,通过形象化的状态显示,使学生理解进程的概念,了解同步和通信的过程,掌握进程通信和同步的机制,特别是利用缓冲区进行同步和通信的过程。

通过补充新功能,使学生能灵活运用相关知识,培养创新能力。

2. 内容及要求:1) 调试、运行模拟程序。

2) 发现并修改程序中不完善的地方。

3) 修改程序,使用随机数控制创建生产者和消费者的过程。

4) 在原来程序的基础上,加入缓冲区的写互斥控制功能,模拟多个进程存取一个公共缓冲区,当有进程正在写缓冲区时,其他要访问该缓冲区的进程必须等待,当有进程正在读取缓冲区时,其他要求读取的进程可以访问,而要求写的进程应该等待。

5) 完成1)、2)、3)功能的,得基本分,完成4)功能的加2分,有其它功能改进的再加2分3. 程序说明:本程序是模拟两个进程,生产者(producer)和消费者(Consumer)工作。

生产者每次产生一个数据,送入缓冲区中。

消费者每次从缓冲区中取走一个数据。

缓冲区可以容纳8个数据。

因为缓冲区是有限的,因此当其满了时生产者进程应该等待,而空时,消费者进程应该等待;当生产者向缓冲区放入了一个数据,应唤醒正在等待的消费者进程,同样,当消费者取走一个数据后,应唤醒正在等待的生产者进程。

就是生产者和消费者之间的同步。

每次写入和读出数据时,都将读和写指针加一。

当读写指针同样时,又一起退回起点。

当写指针指向最后时,生产者就等待。

当读指针为零时,再次要读取的消费者也应该等待。

为简单起见,每次产生的数据为0-99的整数,从0开始,顺序递增。

两个进程的调度是通过运行者使用键盘来实现的。

4. 程序使用的数据结构进程控制块:包括进程名,进程状态和执行次数。

缓冲区:一个整数数组。

缓冲区说明块:包括类型,读指针,写指针,读等待指针和写等待指针。

5. 程序使用说明启动程序后,如果使用'p'键则运行一次生产者进程,使用'c'键则运行一次消费者进程。

操作系统实验报告

操作系统实验报告
close:用于关闭文件。
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实验结果(给出编写的程序源代码和运行结果的截图)

linux操作系统实验报告全部

linux操作系统实验报告全部
3.熟悉常用命令和系统调用列表;
4.熟悉外存目录树结构;
5.熟悉程序开发工具:编辑、编译、连接、调试;
6.学会获得帮助信息。
代码:
#include <stdio.h>
int main() {
printf("Hello World\n");
return 0;
}
【实验结果】
【实验题目】2进程的创建和控制
if(pid2==0)
{
1ockf(fd[1],1,0);
sprintf(OutPipe,“child 2 processis sending message!“);
write (fd[1],OutPipe,50);
sleep (5);
lockf (fd[l],0,0);
exit(0);
}
else
{
signal(16,stop);
printf(%d”,SIG_DEL);
waiting();
lockf(stdout,1,0);
printf("child process 1 is killed by parent!\n”);
1ockf(stdout,0,0);
exit(0);
}
}
voidwaiting()
}
}
#include<stdio2,i;
while((pl = fork ( ) ) ==-1);
if(pl ==0)
{
lockf(1,1,0),
for(i =0 ; i<500 ; i++)printf ((“child %d/n”,i );
lockf(1,0,0);

linux操作系统实验报告

linux操作系统实验报告

linux操作系统实验报告Linux操作系统实验报告一、引言在计算机科学领域,操作系统是一种非常重要的软件,它负责管理计算机硬件和软件资源,提供用户与计算机之间的接口。

Linux操作系统是一种开源的、免费的操作系统,它具有高度的可定制性和稳定性,因此在科研、教育和商业领域都得到广泛应用。

本实验报告将介绍我们在课程中对Linux操作系统的实验内容和实验结果。

二、实验目的本次实验的目的是让我们学生通过亲自操作和实践,深入了解Linux操作系统的特点、功能和使用方法。

通过实验,我们将学会如何安装Linux操作系统、使用Linux命令行界面、管理文件和目录、配置网络和安全等。

三、实验环境我们使用的实验环境是一台配置较高的个人计算机,该计算机上安装了虚拟机软件。

我们选择了一款常用的虚拟机软件VirtualBox,并在其上安装了Ubuntu Linux操作系统。

四、实验内容1. Linux操作系统安装我们首先学习了如何在虚拟机上安装Linux操作系统。

通过下载Ubuntu的镜像文件,并创建虚拟机实例,我们成功地完成了Linux操作系统的安装。

在安装过程中,我们需要设置用户名、密码和网络配置等信息。

2. Linux命令行界面Linux操作系统的命令行界面是其最基本的用户接口。

我们学习了一些常用的Linux命令,如cd、ls、mkdir、rm等,用于管理文件和目录。

我们还学习了如何使用管道和重定向符号来处理命令的输入和输出。

3. 文件和目录管理Linux操作系统以文件和目录的形式来组织和管理数据。

我们学习了如何创建、复制、移动和删除文件和目录。

我们还学习了如何修改文件和目录的权限和所有权。

4. 网络配置在现代计算机网络中,网络配置是非常重要的一部分。

我们学习了如何配置Linux操作系统的网络设置,包括IP地址、子网掩码、网关等。

我们还学习了如何使用ping命令测试网络连通性。

5. 安全配置在网络环境中,安全性是一个重要的考虑因素。

东北大学操作系统实验 绝对自创 实验报告 含可执行源代码 linux环境可运行 有截图

东北大学操作系统实验 绝对自创 实验报告 含可执行源代码 linux环境可运行 有截图
queue<int> blockp;//等待进入缓冲区的数据
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 命中: " ;

操作系统Linux系统使用实验报告

操作系统Linux系统使用实验报告

操作系统Linux系统使用实验报告电大教师评语教师签字日期成绩学生姓名学号实验名称 Linux 系统使用实验实验报告一、实验目的学会 Linux 系统的基本操作和常用命令,学会使用 vi 编辑器建立、编辑、显示及加工处理文本文件。

二、实验要求:(1)基本操作和常用命令①能够正确地登录和退出 Linux 系统。

②熟悉使用 Linux 常用命令。

(2) vi 编辑器①能够正确地进入和退出 vi。

. ②利用文本插入方式建立-一个文件。

③在新建的文本文件上移动光标位置。

④对该文件执行删除、复原、修改、替换等操作。

三、实验步骤 (1) 登录和退出 Linux 系统①登录。

不论是 GUI 方式或命令行方式的 Linux,在登录系统时,用户都需要输入注册名和密码。

密码验证正确后,用户登录成功。

Linux 系统提供的命令需要在 shell 环境下运行。

为此,要从图形界面进入 shell 界面(即命令行界面)。

在桌面环境下,可以利用终端程序进入传统的命令行操作界面,进入方式有多种,如在“开始”菜单中选择“实用工具”rarr;“终端程序”命令。

②修改用户密码。

用户在使用 Linux 系统的过程中,如果需要,可以使用 passwd 命令修改自己的用户登录密码。

注意:普通用户只能修改自己的密码,管理员 root 用户可以设置任何用户的密码。

③退出系统。

要退出终端程序,可以单击窗口右上角的“关闭”按钮,或在 shell 提示符下执行 exit 命令或logout 命令,也可按快捷键 Ctrl+D。

(2)常用命令命令功能命令功能 cal 显示日历 grep 搜索指定的模式 cat 显示文件内容 ls 列出所有目录 cd 改变目录 more 分页显示文件内容 cp 复制文件 rm 删除文件或目录 date 显示日期 wc 统计文件 echo 显示输入参数 who 显示登录的用户信息(3)vi 编辑器①进入 vi。

②建立一个文件,如 file.c。

linux系统基本操作实验报告

linux系统基本操作实验报告

竭诚为您提供优质文档/双击可除linux系统基本操作实验报告篇一:linux操作系统指令实验报告实验一Linux的基本操作和常用命令的使用一、实验目的1.学会安装Linux操作系统2.掌握Linux系统的一些基本操作3.掌握常用Linux命令的使用方法4.了解Linux命令中参数选项的用法和作用二、实验环境1.Linux软件和计算机三、实验内容或步骤1.安装Linux操作系统,并进行相关配置。

2.基本操作和常用命令。

(一).文件操作命令(1)查看文件与目录用以下命令查看文件与目录:ls/usr/binls–ldir(2)显示文件内容命令(cat)设当前目录下包括两个文件text1、text2,用以下列命令了解cat命令的使用:cattext1cattext1text2>text3cattext3|more(3)文件复制命令(cp)了解cp命令的功能和使用技巧,并注意它们的区别:cp/root/*/tempcpreadmetext4cp–r/root/*/temp(带目录复制)cp/root/.[a-z]*/temp(复制所有小写字母开头的隐藏文件)(4)文件改名命令(mv)了解mv命令的功能和使用方法,并注意各命令的区别:mvtext4newtextmvnewtext/home(5)删除文件命令(rm)了解rm命令的功能和使用方法:rmnewtext(二).目录操作命令的使用(1)改变当前目录命令(cd)和显示当前目录命令(pwd)掌握cd命令的功能和使用,并了解以下各命令的区别:cd/rootcd..(返回上一级目录)cd(返回到用户目录内)-1-pwd(显示当前目录在文件系统层次中的位置)(2)建立子目录命令(mkdir)在用户目录下创建如图5-4所示的目录结构。

(3)删除子目录命令(rmdir)在图5-4所建立的目录结构中,删除a1和b1目录。

命令如下:rmdir/home/x/b1rm–r/home/x/a1rm–rf/home/x/a1注意:可选项-r和-f的作用。

LINUX操作系统实验报告..

LINUX操作系统实验报告..

LINUX操作系统实验报告::LINUX操作系统实验报告1、实验目的1.1 理解LINUX操作系统的基本概念1.2 掌握LINUX系统的安装和配置过程1.3 学习LINUX命令行操作和文件管理1.4 探究LINUX操作系统的网络配置和服务管理2、实验环境2.1 操作系统:Ubuntu 20:04 LTS2.2 软件工具:VirtualBox3、实验内容3.1 LINUX系统的安装3.1.1 准备安装盘或镜像文件3.1.2 创建虚拟机并引导安装程序3.1.3 设置分区和文件系统3.1.4 安装引导加载程序3.2 LINUX系统的基本配置3.2.1 设置主机名和网络配置3.2.2 安装基本软件包和驱动程序 3.2.3 配置用户和组权限3.2.4 配置系统服务和启动项3.3 LINUX命令行操作3.3.1 基本命令的使用3.3.2 文件和目录操作3.3.3 系统信息和网络配置命令 3.3.4 进程和服务管理命令3.4 LINUX文件管理3.4.1 文件和目录的创建与删除 3.4.2 文件权限和所有权的管理 3.4.3 文件的复制和移动3.4.4 文件的查找和过滤3.5 LINUX网络配置3.5.1 IP地质和子网掩码的配置3.5.2 网关和DNS的配置3.5.3 网络服务的启动和管理3.5.4 远程登录和文件传输4、实验步骤4.1 安装LINUX操作系统4.1.1 LINUX安装镜像文件并创建虚拟机4.1.2 引导虚拟机并按照安装向导进行安装 4.2 配置LINUX系统4.2.1 设置主机名和网络配置4.2.2 安装必要的软件和驱动程序4.2.3 创建用户和设置用户权限4.2.4 配置系统服务和启动项4.3 使用LINUX命令4.3.1 使用常见的命令操作文件和目录4.3.2 查看和管理系统的进程4.3.3 配置和管理系统服务4.3.4 网络配置和管理命令的使用4.4 文件管理操作4.4.1 创建、复制、移动和删除文件4.4.2 修改文件权限和所有权4.4.3 查找文件和过滤文件内容4.4.4 压缩和解压缩文件4.5 网络配置和服务管理4.5.1 配置IP地质、子网掩码、网关和DNS4.5.2 启动和管理网络服务4.5.3 使用远程登录和文件传输工具5、实验结果与分析在实验过程中,成功完成了LINUX操作系统的安装和配置。

linux操作系统实验报告

linux操作系统实验报告

linux操作系统实验报告Linux 操作系统实验报告一、实验目的本次实验的主要目的是深入了解和熟悉Linux 操作系统的基本操作、命令行使用、文件系统管理以及进程管理等方面的知识和技能。

通过实际操作和实践,提高对 Linux 操作系统的掌握程度,为今后在相关领域的学习和工作打下坚实的基础。

二、实验环境本次实验使用的是虚拟机软件 VirtualBox 安装的 Ubuntu 2004 LTS操作系统。

虚拟机配置为 2GB 内存,20GB 硬盘空间。

实验在Windows 10 操作系统的主机上进行。

三、实验内容及步骤(一)用户和权限管理1、创建新用户使用`sudo adduser <username>`命令创建新用户,例如创建用户名为`testuser` 的新用户。

2、设置用户密码使用`sudo passwd <username>`命令为新用户设置密码。

3、切换用户使用`su <username>`命令切换到新用户。

4、用户权限管理修改`/etc/sudoers` 文件,为新用户赋予特定的权限,例如允许执行特定的管理员命令。

(二)文件和目录操作1、查看文件和目录使用`ls` 命令查看当前目录下的文件和目录,使用`ls l` 命令查看详细信息,包括文件权限、所有者、大小和修改时间等。

2、创建、删除文件和目录使用`touch <filename>`命令创建新文件,使用`mkdir <directoryname>`命令创建新目录。

使用`rm <filename>`命令删除文件,使用`rmdir <directoryname>`命令删除空目录,使用`rm r <directoryname>`命令删除非空目录。

3、复制、移动文件和目录使用`cp <source> <destination>`命令复制文件或目录,使用`mv <source> <destination>`命令移动文件或目录。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
running.push(ch);
running.pop();
}
cout << endl;
cout << "block: ";
for(int i = 0;i < n3;i++)
{
ch = block.front();
cout << ch;
block.push(ch);
block.pop();
}
cout << endl;
{
cout << M_Frame[n] << " ";
}
cout << endl;
flag_l = 1;//表示命中
cout << "请输入随机数数组长度: " ;
cin >> total_instruction;
int Acess_Series[total_instruction];
int Acess_Num;//页程序个数
cout << "请输入页程序个数:";
cin >> Acess_Num;
srand(time(NULL));//初始化随机数组
read(fd[0],father,17);
cout << father << endl;
}
}
}
return 0;
}
三、实验结果
实验四页面置换算法
一、实验目的
进一步加深理解父子进程之间的关系及其并发执行。
理解内存页面调度的机理。
掌握页面置换算法及其实现方法。
培养综合运用所学知识的能力。
二、实验内容
#include <iostream>
float lru_ok = 0;//lru命中数
float lru_miss = 0;//lru缺页数
intframe_num;//内存中分配页面个数
cout << "请输入内存中分配页面个数:";
cin >> frame_num;
int M_Frame[frame_num] = {0};
int total_instruction;//随机数组长度
{
int n1,n2,n3;
char ch;
n1 = ready.size();
n2 = running.size();
n3 = block.size();
cout << "___________________" << endl;
cout << "ready: ";
for(int i = 0;i < n1;i++)
while(scanf("%d",&p)!= EOF)
{
switch(p)
{
case 2: f2();break;
case 3: f3();break;
case 4: f4();break;
default:break;
}
}
return 0;
}
void f1()
{
char c = ready.front();
char father[20] ;
int main()
{
int fd[2];
int re = pipe(fd);
pid_t p1,p2,p3;
int *status = NULL;
p1 = fork();
if(p1 == 0)
{
lockf(fd[1],1,0);
printf("子进程一正在写入,prd = :%d\n",getpid());
ready.pop();
running.push(c);
print();
}
void f2()
{
char c = running.front();
running.pop();
ready.push(c);
print();
f1();
}
void f3()
{
char c = running.front();
running.pop();
if(p1 > 0)
{
int p2 = fork();//创建子进程二
if(p2 == 0)//子进程二 LRU
{
cout << "这里是子进程二:LRU算法" << endl;
for(int i = 0;i < total_instruction;i++)
{
for(int j = 0;j < frame_num;j++)
queue<int> blockp;//等待进入缓冲区的数据
int data = 0;//生产者生产的数据
int num = 0;//缓冲区元素个数
int np = 0;//正在等待的生产者
int nc = 0;//正在等待的消费者
int main()
{
print();
char c;
while(scanf("%c",&c)!='e')
cout << "访问页的顺序为:";
for(int i = 0;i < total_instruction;i++)
{
Acess_Series[i] = rand() % Acess_Num+1;
cout << Acess_Series[i] << " ";
}
cout << endl;
int p1 = fork();//创建子进程一
buffer.push(ch);
buffer.pop();
}
printf("\n");
}
三、实验结果
实验三进程的管道通信
一、实验目的
加深对进程概念的理解,明确进程和程序的区别。
学习进程创建的过程,进一步认识进程并发执行的实质。
分析进程争用资源的现象,学习解决进程互斥的方法。
学习解决进程同步的方法。
掌握Linux系统中进程间通过管道通信的具体实现。
{
ch = ready.front();
cout << ch;
ready.push(ch);
ready.pop();
}
cout << endl;
cout << "running: ";
for(int i = 0;i < n2;i++)
{
ch = running.front();
cout << ch;
{
if(Acess_Series[i] == M_Frame[j])//命中
{
cout << "子程序2 命中: " ;
lru_ok++;
int t;
t = M_Frame[frame_num-1];
M_FramBiblioteka [frame_num-1] = M_Frame[j];
M_Frame[j] = t;
for(int n = 0;n < frame_num;n++)
lockf(fd[1],0,0);
exit(0);
}
else if(p2 > 0)
{
p3 = fork();
if(p3 == 0)
{
lockf(fd[1],1,0);
printf("子进程三正在写入,prd = :%d\n",getpid());
write(fd[1],child_3,27);
lockf(fd[1],0,0);
#include <cstdlib>
#include <cstdio>
#include <unistd.h>
using namespace std;
int main()
{
intflag_f = 0;
intflag_l = 0;
float fifo_ok = 0;//fifo命中数
float fifo_miss = 0;//fifo缺页数
#include <cstdio>
#include <cstdlib>
#include <queue>
using namespace std;
void producer();//生产者
void print();//显示缓冲区
void consumer();//消费者
queue<int> buffer;//缓冲区
{
switch(c)
{
case 'p': producer();print();break;
case 'c': consumer();print(); break;
case 'e': exit(0);
}
}
}
void producer()//生产者
{
if(num < 8)
{
if(nc > 0)
{
data++;
相关文档
最新文档