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

合集下载

操作系统实验实验报告

操作系统实验实验报告

操作系统实验实验报告一、实验目的操作系统是计算机系统中最为关键的核心软件,它管理着计算机的硬件资源和软件资源,为用户提供了一个方便、高效、稳定的工作环境。

本次操作系统实验的目的在于通过实际操作和实践,深入理解操作系统的基本原理和核心概念,掌握操作系统的基本功能和操作方法,提高对操作系统的认识和应用能力。

二、实验环境本次实验使用的操作系统为 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 等进行文件的创建、读取和写入操作。

东北大学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地址、子网掩码、网关等参数的设置。

《操作系统》实验报告

《操作系统》实验报告

《操作系统》实验报告一、实验目的操作系统是计算机系统中最为关键的组成部分之一,本次实验的主要目的是深入理解操作系统的基本原理和功能,通过实际操作和观察,熟悉操作系统的核心概念,包括进程管理、内存管理、文件系统和设备管理等,提高对操作系统的实际应用能力和问题解决能力。

二、实验环境本次实验在以下环境中进行:操作系统: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)通过“结束任务”按钮可以结束指定的进程,但要注意不要随意结束系统关键进程,以免导致系统不稳定。

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

操作系统课程实验报告

操作系统课程实验报告

操作系统课程实验报告一、实验目的操作系统是计算机系统中最核心的软件之一,它负责管理计算机的硬件资源和软件资源,为用户提供一个方便、高效、安全的工作环境。

本实验的目的是通过实际操作和观察,深入理解操作系统的基本原理和功能,掌握操作系统的常用命令和操作方法,提高解决实际问题的能力。

二、实验环境操作系统:Windows 10开发工具:Visual Studio Code三、实验内容1、进程管理观察进程的创建、终止和状态转换。

使用任务管理器查看系统中的进程信息,包括进程 ID、CPU 使用率、内存占用等。

通过编程实现创建和终止进程的功能。

2、内存管理了解内存的分配和回收机制。

使用 Windows 系统提供的性能监视器查看内存的使用情况。

编程实现简单的内存分配和释放算法。

3、文件系统管理熟悉文件和目录的操作,如创建、删除、复制、移动等。

研究文件的属性,如文件名、文件大小、创建时间等。

通过编程实现文件的读写操作。

4、设备管理认识设备的驱动程序和设备管理策略。

查看系统中的设备信息,如磁盘驱动器、打印机等。

模拟设备的中断处理过程。

四、实验步骤1、进程管理实验打开任务管理器,观察当前系统中正在运行的进程。

可以看到进程的名称、进程 ID、CPU 使用率、内存占用等信息。

使用 C++语言编写一个简单的程序,创建一个新的进程。

在程序中,使用`CreateProcess`函数来创建新进程,并设置进程的属性和参数。

编写另一个程序,用于终止指定的进程。

通过获取进程 ID,然后使用`TerminateProcess`函数来终止进程。

2、内存管理实验打开 Windows 性能监视器,选择“内存”选项卡,可以查看内存的使用情况,包括物理内存、虚拟内存、页面文件等的使用量和使用率。

编写一个 C 程序,使用动态内存分配函数(如`malloc`和`free`)来分配和释放内存。

在程序中,不断分配和释放一定大小的内存块,观察内存的使用情况和性能变化。

操作系统课程 实验报告(完整版)

操作系统课程 实验报告(完整版)

中南大学《操作系统》实验报告姓名:孙福星专业班级:软件 1006班学号:3902100610完成日期: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)。

操作系统实验报告

操作系统实验报告
(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);

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

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

课程编号: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)观察并分析在不同的并发情况下,系统的运行结果和资源竞争情况。

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

东北大学操作系统实验报告
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)进程工作;生产者每次产生一个数据,送入缓冲区中;消费者每次从缓冲区中取走一个数据。每次写入和读出数据时,都将读和写指针加一。当指针到达缓冲区尾,重新将指针退回起点;

操作系统实验

操作系统实验

操作系统实验报告(一)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以后,缺页数目又再次减少了四、总结:你对本次实验有什么体会或看法.。

操作系统实验报告

操作系统实验报告
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实验结果(给出编写的程序源代码和运行结果的截图)

操作系统实验4-4实验报告

操作系统实验4-4实验报告

操作系统实验4-4实验报告一、实验目的本次操作系统实验 4-4 的目的是深入了解和掌握操作系统中进程管理的相关知识和技术,通过实际操作和观察,加深对进程调度算法、进程同步与互斥等概念的理解,并提高解决实际问题的能力。

二、实验环境本次实验使用的操作系统为 Windows 10,编程环境为 Visual Studio 2019。

三、实验内容1、进程调度算法的实现先来先服务(FCFS)算法短作业优先(SJF)算法时间片轮转(RR)算法优先级调度算法2、进程同步与互斥的实现使用信号量实现生产者消费者问题使用互斥锁实现哲学家进餐问题四、实验步骤1、进程调度算法的实现先来先服务(FCFS)算法设计数据结构来表示进程,包括进程ID、到达时间、服务时间等。

按照进程到达的先后顺序将它们放入就绪队列。

从就绪队列中选择第一个进程进行处理,计算其完成时间、周转时间和带权周转时间。

短作业优先(SJF)算法在设计的数据结构中增加作业长度的字段。

每次从就绪队列中选择服务时间最短的进程进行处理。

计算相关的时间指标。

时间片轮转(RR)算法设定时间片的大小。

将就绪进程按照到达时间的先后顺序放入队列。

每个进程每次获得一个时间片的执行时间,若未完成则重新放入队列末尾。

优先级调度算法为每个进程设置优先级。

按照优先级的高低从就绪队列中选择进程执行。

2、进程同步与互斥的实现生产者消费者问题创建一个共享缓冲区。

生产者进程负责向缓冲区中生产数据,消费者进程从缓冲区中消费数据。

使用信号量来控制缓冲区的满和空状态,实现进程的同步。

哲学家进餐问题模拟多个哲学家围绕一张圆桌进餐的场景。

每个哲学家需要同时获取左右两边的筷子才能进餐。

使用互斥锁来保证筷子的互斥访问,避免死锁的发生。

五、实验结果与分析1、进程调度算法的结果与分析先来先服务(FCFS)算法优点:实现简单,公平对待每个进程。

缺点:对短作业不利,平均周转时间可能较长。

短作业优先(SJF)算法优点:能有效降低平均周转时间,提高系统的吞吐量。

操作系统实验报告4

操作系统实验报告4

操作系统实验报告4一、实验目的本次操作系统实验的目的在于深入了解和掌握操作系统中进程管理、内存管理、文件系统等核心概念和相关操作,通过实际的实验操作,增强对操作系统原理的理解和应用能力,提高解决实际问题的能力。

二、实验环境本次实验使用的操作系统为 Windows 10,编程语言为 C++,开发工具为 Visual Studio 2019。

三、实验内容与步骤(一)进程管理实验1、进程创建与终止使用 C++语言编写程序,创建多个进程,并在进程中执行不同的任务。

通过进程的标识符(PID)来监控进程的创建和终止过程。

2、进程同步与互斥设计一个生产者消费者问题的程序,使用信号量来实现进程之间的同步与互斥。

观察生产者和消费者进程在不同情况下的执行顺序和结果。

(二)内存管理实验1、内存分配与释放编写程序,使用动态内存分配函数(如`malloc` 和`free`)来分配和释放内存。

观察内存的使用情况和内存泄漏的检测。

2、内存页面置换算法实现几种常见的内存页面置换算法,如先进先出(FIFO)算法、最近最少使用(LRU)算法和最佳置换(OPT)算法。

通过模拟不同的页面访问序列,比较不同算法的性能。

(三)文件系统实验1、文件创建与读写使用 C++语言的文件操作函数,创建一个新文件,并向文件中写入数据。

从文件中读取数据,并进行数据的处理和显示。

2、文件目录操作实现对文件目录的创建、删除、遍历等操作。

观察文件目录结构的变化和文件的组织方式。

四、实验结果与分析(一)进程管理实验结果与分析1、进程创建与终止在实验中,成功创建了多个进程,并通过控制台输出观察到了每个进程的 PID 和执行状态。

可以看到,进程的创建和终止是按照程序的逻辑顺序进行的,操作系统能够有效地管理进程的生命周期。

2、进程同步与互斥在生产者消费者问题的实验中,通过信号量的控制,生产者和消费者进程能够正确地实现同步与互斥。

当缓冲区为空时,消费者进程等待;当缓冲区已满时,生产者进程等待。

操作系统实验报告

操作系统实验报告

操作系统实验报告一、实验目的本次操作系统实验的主要目的是通过实际操作和观察,深入理解操作系统的工作原理和关键机制,包括进程管理、内存管理、文件系统以及设备管理等方面。

同时,培养我们解决实际问题的能力,提高对操作系统相关知识的综合运用水平。

二、实验环境本次实验使用的操作系统为 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. 进程的创建和管理2. 线程的创建和管理3. 进程同步的实现在实验过程中,我们将分别使用C语言和Linux操作系统实现上述功能。

二、实验过程1. 进程的创建和管理在这一部分实验中,我们要创建多个进程,实现进程的调度和管理功能。

我们采用了Linux系统下的fork()函数,用于创建子进程。

在程序运行时,首先创建一个父进程,然后使用fork()函数创建四个子进程,每个子进程都有自己的进程号(pid),并在屏幕上输出该进程号以示区分。

为了实现进程的调度功能,我们在代码中加入了sleep()函数,用于将进程挂起一段时间,然后再轮流执行其他进程。

2. 线程的创建和管理在这一部分实验中,我们使用了C语言的POSIX线程库pthread.h,实现多线程的功能。

同样地,我们采用了Linux系统下的fork()函数来创建线程。

在代码运行时,我们创建了两个线程,并在屏幕上输出线程号(tid)以示区分。

为了实现线程的调度和管理功能,我们在代码中加入了pthread_join()函数,用于等待线程的执行完成。

3. 进程同步的实现在这一部分实验中,我们使用了Linux系统下的进程同步工具——信号量(semaphore)。

在代码中,我们使用sem_init()函数创建信号量,使用sem_wait()函数阻塞进程或线程,使用sem_post()函数释放进程或线程。

为了更好地理解信号量的工作原理,我们将代码分为生产者和消费者两部分,其中生产者用于向缓冲区添加数据,消费者则用于删除数据。

在这个过程中,我们需要使用信号量控制生产者和消费者的数量,避免出现生产过多或消费过多的情况。

操作系统课程实验报告

操作系统课程实验报告

操作系统课程实验报告一、实验目的操作系统是计算机系统中最为关键的软件之一,它负责管理计算机的硬件资源和软件资源,为用户提供一个良好的工作环境。

通过操作系统课程实验,旨在深入理解操作系统的基本原理和功能,提高对操作系统的实际操作能力和问题解决能力。

二、实验环境本次实验使用的操作系统为Windows 10 和Linux(Ubuntu 1804),开发工具包括 Visual Studio Code、gcc 编译器等。

三、实验内容(一)进程管理1、进程创建与终止在 Windows 系统中,使用 C++语言创建多个进程,并通过进程句柄控制进程的终止。

在 Linux 系统中,使用 fork()系统调用创建子进程,并通过 exit()函数终止进程。

2、进程同步与互斥使用信号量实现进程之间的同步与互斥。

在 Windows 中,利用CreateSemaphore()和 WaitForSingleObject()等函数进行操作;在Linux 中,通过 sem_init()、sem_wait()和 sem_post()等函数实现。

(二)内存管理1、内存分配与释放在 Windows 中,使用 HeapAlloc()和 HeapFree()函数进行动态内存的分配与释放。

在 Linux 中,使用 malloc()和 free()函数完成相同的操作。

2、内存页面置换算法实现了几种常见的内存页面置换算法,如先进先出(FIFO)算法、最近最少使用(LRU)算法等,并比较它们的性能。

(三)文件系统管理1、文件创建与读写在 Windows 和 Linux 系统中,分别使用相应的 API 和系统调用创建文件,并进行读写操作。

2、目录操作实现了目录的创建、删除、遍历等功能。

四、实验步骤(一)进程管理实验1、进程创建与终止(1)在 Windows 系统中,编写 C++程序,使用 CreateProcess()函数创建新进程,并通过 TerminateProcess()函数终止指定进程。

操作系统实验报告四

操作系统实验报告四

操作系统实验报告四操作系统实验报告四引言操作系统是计算机系统中最重要的软件之一,它负责管理计算机硬件和软件资源,为用户提供一个良好的运行环境。

操作系统实验是学习操作系统的重要途径之一,通过实际操作和实验验证,可以更好地理解和掌握操作系统的原理和机制。

本篇文章将围绕操作系统实验报告四展开,从实验目的、实验环境、实验步骤、实验结果和实验总结等方面进行论述。

实验目的操作系统实验报告四的主要目的是通过实验,深入了解操作系统中进程调度的原理和实现方法。

进程调度是操作系统中的一个重要组成部分,它决定了进程在处理器上的执行顺序,直接影响着系统的性能和响应速度。

通过本次实验,我们将学习和掌握不同的进程调度算法,并通过实验验证它们的性能和效果。

实验环境本次实验使用的操作系统是Linux,实验环境是一台配置较高的计算机。

实验过程中,我们将使用C语言编写程序,通过系统调用和相关库函数实现进程的创建、调度和执行等操作。

同时,我们还将使用一些工具和命令来监测和评估进程的执行情况,以及对实验结果进行分析和比较。

实验步骤1. 实验准备:在开始实验之前,我们需要对实验环境进行一些准备工作。

首先,我们需要安装和配置必要的软件和工具,如编译器、调试器和性能监测工具等。

其次,我们需要了解和熟悉实验所需的进程调度算法和相关知识,为后续的实验操作做好准备。

2. 实验设计:在实验设计阶段,我们需要根据实验要求和目的,选择适合的进程调度算法,并设计实验方案。

实验方案包括进程创建和调度的具体步骤,以及实验中所需的测试数据和指标等。

在设计实验方案时,我们需要考虑实验的可行性和有效性,以及实验结果的可靠性和可重复性。

3. 实验实施:在实验实施阶段,我们将按照实验方案的要求,编写和调试相应的程序代码。

在编写代码时,我们需要遵循良好的编程规范和风格,保证代码的可读性和可维护性。

在调试过程中,我们需要使用调试器和日志输出等工具,对程序的执行过程进行跟踪和分析,以及对错误和异常进行定位和修复。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

操作系统实验报告
班级物联网1302班
学号
姓名
实验4 进程的管道通信
1. 实验目的
1)加深对进程概念的理解,明确进程和程序的区别。

2)进一步认识并发执行的实质。

3)分析进程争用资源的现象,学习解决进程互斥的方法。

4)学习解决进程同步的方法。

5)了解Linux系统中进程通信的基本原理。

进程是操作系统中最重要的概念,贯穿始终,也是学习现代操作系统的关键。

通过本次实验,要求理解进程的实质和进程管理的机制。

在Linux系统下实现进程从创建到终止的全过程,从中体会进程的创建过程、父进程和子进程之间的关系、进程状态的变化、进程之间的互斥、同步机制、进程调度的原理和以管道为代表的进程间的通信方式的实现。

2. 内容及要求:
这是一个设计型实验,要求自行编制程序。

使用系统调用pipe()建立一条管道,两个子进程分别向管道写一句话:
Child process1 is sending a message!
Child process2 is sending a message!
父进程从管道读出来自两个子进程的信息,显示在屏幕上。

要求:
1)父进程先接收子进程1发来的消息,然后再接收子进程2发来的消息。

2)实现管道的互斥使用,当一个子进程正在对管道进行写操作时,另一子进程必须等待。

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

3)实现父子进程的同步,当子进程把数据写入管道后,便去睡眠等待;当父进程试图从一空管道中读取数据时,也应等待,直到子进程将数据写入管道后,才将其唤醒。

3.相关的系统调用
1) fork() 用于创一个子进程。

格式:int fork();
返回值:在子进程中返回0;在父进程中返回所创建的子进程的ID值;当返回-1时,创建失败。

2) wait() 常用来控制父进程与子进程的同步。

在父进程中调用wait(),则父进程被阻塞,进入等待队列,等待子进程结束。

当子进程结束时,父进程从wait()返回继续执行原来的程序。

返回值:大于0时,为子进程的ID值;等于-1时,调用失败。

3) exit() 是进程结束时最常调用的。

格式:void exit( int status); 其中,status为进程结束状态。

4) pipe() 用于创建一个管道
格式:pipe(int fd);
其中fd是一个由两个数组元素fd[0]和fd[1]组成的整型数组,fd[0]是管道的读端口,用于从管道读出数据,fd[1] 是管道的写端口,用于向管道写入数据。

返回值:0 调用成功;-1 调用失败。

5) sleep() 调用进程睡眠若干时间,之后唤醒。

格式:sleep(int t); 其中t为睡眠时间。

6) lockf() 用于对互斥资源加锁和解锁。

在本实验中,该调用的格式为:lockf(fd[1],1,0);/* 表示对管道的写入端口加锁。

lockf(fd[1],0,0);/* 表示对管道的写入端口解锁。

7) write(fd[1],String,Length) 将字符串String的内容写入管道的写入口。

8) read(fd[0],String,Length) 从管道的读入口读出信息放入字符串String 中。

4.程序流程
父进程:
1)创建管道;
2)创建子进程1;
3)创建子进程2;
4)等待从管道中读出子进程1写入的数据,并显示在屏幕上;
5)等待从管道中读出子进程2写入的数据,并显示在屏幕上;
6)退出。

子进程:
1)将管道的写入口加锁;
2)将信息“Child process n is sending message!”输入到变量OutPipe中,n=1,2;
3)将OutPipe中信息写入管道;
4)睡眠等待;
5)将管道的写入口解锁;
6)退出。

5.预习报告要求:
1)题目,目的,要求
2)初步的程序流程图
3)初步的程序源代码、文档注释及必要的文字说明
4)预期的程序运行结果
6.实验报告要求:
1)题目,目的,内容,要求
2)程序流程图
3)程序源代码、文档注释及文字说明
4)运行结果及其说明
5)回答以下问题:
①指出父进程与两个子进程并发执行的顺序,并说明原因。

②若不对管道加以互斥控制,会有什么后果?
③说明你是如何实现父子进程之间的同步的。

7.流程图
开始
初始化
创建管道
创建子进程1创建子进程2创建子进程3
锁定管道写入端
fd[1]锁定管道写入端
fd[1]
锁定管道写入端
fd[1]
向写入端写入数据向写入端写入数据向写入端写入数据
解除写入端fd[1]锁
定解除写入端fd[1]锁

解除写入端fd[1]锁

从管道读入端读出
消息
依次终止子进程
1,2,3
结束
等待父进程从管道读取消息等待父进程从管道
读取消息
等待父进程从管道
读取消息
8.源程序
#include<stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <error.h>
#include <wait.h>
#include <unistd.h>
int main()
{
pid_t pid1,pid2,pid3; int fd[2];
char buf[100];
pipe(fd);
pid1=fork();
if(pid1 == 0)
{
pid2=fork(); if(pid2 == 0) {
pid3 = fork();
if(pid3 == 0)
{
lockf(1,1,0);
write(fd[1],"come from process3\n",50);
//cout<<"process3"<<endl;
lockf(0,1,0);
exit(0);
}
else
{
int status;
wait(&status);
read(fd[0],buf,100);
printf("%s",buf);
write(fd[1],"come from process2\n",50);
}
exit(0);
}
else
{
int status;
wait(&status);
read(fd[0],buf,100);
printf("%s",buf);
write(fd[1],"come from process1\n",50); exit(0);
}
}
else
{
int status;
wait(&status);
read(fd[0],buf,100);
printf("%s",buf);
}
return 0;
}
八.程序运行结果。

相关文档
最新文档