实验五-进程间通信实验(二)
- 格式:doc
- 大小:94.00 KB
- 文档页数:15
一、实验目的本次实验旨在通过Linux操作系统的实践操作,加深对进程控制概念的理解。
通过学习进程的创建、调度、同步、通信等基本操作,掌握进程控制的基本方法,并了解进程间通信的机制。
二、实验环境1. 硬件环境:Intel(R) Core(TM) i5-3210M CPU2.50GHz,4.00GB内存。
2. 软件环境:64位Linux操作系统。
三、实验内容1. 进程的创建与终止2. 进程的调度与优先级3. 进程同步与互斥4. 进程间通信四、实验步骤1. 进程的创建与终止(1)使用`fork()`函数创建子进程,通过比较返回值判断创建是否成功。
```cpid_t pid = fork();if (pid < 0) {perror("fork failed");exit(1);}```(2)使用`exit()`函数终止进程。
```cexit(0);```2. 进程的调度与优先级(1)使用`nice()`函数调整进程优先级。
```cnice(10); // 降低进程优先级```(2)使用`priority_seta()`函数设置进程优先级。
```cstruct sched_param param;param.sched_priority = 10;if (sched_setscheduler(pid, SCHED_RR, ¶m) == -1) { perror("sched_setscheduler failed");exit(1);}```3. 进程同步与互斥(1)使用`semaphore_t`类型的信号量实现进程同步。
```csemaphore_t sem;sem_init(&sem, 0, 1);sem_wait(&sem);// 执行临界区代码sem_post(&sem);sem_destroy(&sem);```(2)使用`mutex_t`类型的互斥锁实现进程互斥。
操作系统实验二实验报告一、实验目的本次操作系统实验二的主要目的是深入理解和掌握进程管理的相关概念和技术,包括进程的创建、执行、同步和通信。
通过实际编程和实验操作,提高对操作系统原理的认识,培养解决实际问题的能力。
二、实验环境本次实验使用的操作系统为 Windows 10,编程环境为 Visual Studio 2019。
三、实验内容及步骤(一)进程创建实验1、首先,创建一个新的 C++项目。
2、在项目中,使用 Windows API 函数`CreateProcess`来创建一个新的进程。
3、为新进程指定可执行文件的路径、命令行参数、进程属性等。
4、编写代码来等待新进程的结束,并获取其退出代码。
(二)进程同步实验1、设计一个生产者消费者问题的模型。
2、使用信号量来实现生产者和消费者进程之间的同步。
3、生产者进程不断生成数据并放入共享缓冲区,当缓冲区已满时等待。
4、消费者进程从共享缓冲区中取出数据进行处理,当缓冲区为空时等待。
(三)进程通信实验1、选择使用管道来实现进程之间的通信。
2、创建一个匿名管道,父进程和子进程分别读写管道的两端。
3、父进程向管道写入数据,子进程从管道读取数据并进行处理。
四、实验结果及分析(一)进程创建实验结果成功创建了新的进程,并能够获取到其退出代码。
通过观察进程的创建和执行过程,加深了对进程概念的理解。
(二)进程同步实验结果通过使用信号量,生产者和消费者进程能够正确地进行同步,避免了缓冲区的溢出和数据的丢失。
分析结果表明,信号量机制有效地解决了进程之间的资源竞争和协调问题。
(三)进程通信实验结果通过管道实现了父进程和子进程之间的数据通信。
数据能够准确地在进程之间传递,验证了管道通信的有效性。
五、遇到的问题及解决方法(一)在进程创建实验中,遇到了参数设置不正确导致进程创建失败的问题。
通过仔细查阅文档和调试,最终正确设置了参数,成功创建了进程。
(二)在进程同步实验中,出现了信号量使用不当导致死锁的情况。
篇一:操作系统实验报告完全版《计算机操作系统》实验报告班级:姓名:学号:实验一进程控制与描述一、实验目的通过对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() 方法。
其中有四个由实际的低级入口点传递来的参数。
操作系统实验报告6一、实验目的本次操作系统实验的主要目的是深入了解和掌握操作系统中进程管理、内存管理、文件系统等核心概念和相关技术,通过实际操作和观察,增强对操作系统工作原理的理解,并提高解决实际问题的能力。
二、实验环境本次实验使用的操作系统为 Windows 10,实验工具包括 Visual Studio 2019 等。
三、实验内容(一)进程管理实验1、创建多个进程,并观察它们的运行状态和资源占用情况。
通过编写简单的C++程序,使用Windows API 函数创建多个进程。
在程序中,设置不同的进程优先级和执行时间,观察操作系统如何调度这些进程,以及它们对 CPU 使用率和内存的影响。
2、进程间通信实现了进程间的管道通信和消息传递。
通过创建管道,让两个进程能够相互交换数据。
同时,还使用了 Windows 的消息机制,使进程之间能够发送和接收特定的消息。
(二)内存管理实验1、内存分配与释放使用 C++的动态内存分配函数(如`malloc` 和`free`),在程序运行时动态申请和释放内存。
观察内存使用情况,了解内存碎片的产生和处理。
2、虚拟内存管理研究了 Windows 操作系统的虚拟内存机制,通过查看系统的性能监视器,观察虚拟内存的使用情况,包括页面文件的大小和读写次数。
(三)文件系统实验1、文件操作进行了文件的创建、读取、写入、删除等基本操作。
通过编写程序,对不同类型的文件(如文本文件、二进制文件)进行处理,了解文件系统的工作原理。
2、目录操作实现了目录的创建、删除、遍历等功能。
了解了目录结构在文件系统中的组织方式和管理方法。
四、实验步骤(一)进程管理实验步骤1、打开 Visual Studio 2019,创建一个新的 C++控制台项目。
2、在项目中编写代码,使用`CreateProcess` 函数创建多个进程,并设置它们的优先级和执行时间。
3、编译并运行程序,通过任务管理器观察进程的运行状态和资源占用情况。
电大操作系统实验报告3_ 进程管理实验电大操作系统实验报告 3 进程管理实验一、实验目的进程管理是操作系统的核心功能之一,本次实验的目的是通过实际操作和观察,深入理解进程的概念、状态转换、进程调度以及进程间的通信机制,掌握操作系统中进程管理的基本原理和方法,提高对操作系统的整体认识和实践能力。
二、实验环境本次实验使用的操作系统为 Windows 10,编程语言为 C 语言,开发工具为 Visual Studio 2019。
三、实验内容及步骤(一)进程的创建与终止1、编写一个 C 程序,使用系统调用创建一个子进程。
2、在父进程和子进程中分别输出各自的进程 ID 和父进程 ID。
3、子进程执行一段简单的计算任务,父进程等待子进程结束后输出结束信息。
以下是实现上述功能的 C 程序代码:```cinclude <stdioh>include <stdlibh>include <unistdh>int main(){pid_t pid;pid = fork();if (pid < 0) {printf("创建子进程失败\n");return 1;} else if (pid == 0) {printf("子进程:我的进程 ID 是%d,父进程 ID 是%d\n",getpid(), getppid());int result = 2 + 3;printf("子进程计算结果:2 + 3 =%d\n", result);exit(0);} else {printf("父进程:我的进程 ID 是%d,子进程 ID 是%d\n",getpid(), pid);wait(NULL);printf("子进程已结束\n");}return 0;}```编译并运行上述程序,可以观察到父进程和子进程的输出信息,验证了进程的创建和终止过程。
(二)进程的状态转换1、编写一个 C 程序,创建一个子进程,子进程进入睡眠状态一段时间,然后被唤醒并输出状态转换信息。
进程通信课程设计一、课程目标知识目标:1. 让学生掌握进程通信的基本概念,了解进程与线程的区别及通信机制。
2. 学会使用至少一种进程通信方法,如管道、消息队列、共享内存、信号量等,并理解其工作原理。
3. 掌握进程同步与互斥的概念,了解常见同步互斥机制。
技能目标:1. 培养学生运用进程通信方法解决实际问题的能力,能编写简单的进程通信程序。
2. 提高学生分析进程通信场景,选择合适通信机制的能力。
情感态度价值观目标:1. 培养学生对计算机操作系统及进程通信的兴趣,激发学生主动探索精神。
2. 培养学生具备团队协作意识,能够与同学共同完成进程通信相关的项目任务。
3. 引导学生认识到进程通信在计算机系统中的重要性,增强学生的专业认同感。
课程性质分析:本课程为计算机科学与技术专业课程,旨在让学生深入了解操作系统中进程通信的相关知识。
学生特点分析:学生已具备一定的编程基础和操作系统知识,具有较强的学习能力和动手能力。
教学要求:1. 注重理论与实践相结合,通过实例分析,让学生更好地理解和掌握进程通信技术。
2. 鼓励学生参与课堂讨论,培养学生主动思考和解决问题的能力。
3. 强化实践环节,让学生在实际操作中掌握进程通信技术,提高编程技能。
二、教学内容1. 进程通信基本概念:进程与线程的对比,进程间通信的必要性及常见通信方式。
教材章节:第二章 进程管理,第三节 进程同步与通信2. 进程通信机制:管道、消息队列、共享内存、信号量、信号等。
教材章节:第二章 进程管理,第四节 进程通信机制3. 进程同步与互斥:互斥锁、条件变量、读写锁等同步互斥机制。
教材章节:第二章 进程管理,第五节 进程同步与互斥4. 进程通信实例分析:分析具体场景,选择合适的通信机制,进行实例讲解。
教材章节:第二章 进程管理,第六节 进程通信实例5. 实践环节:编写简单的进程通信程序,加深对进程通信机制的理解。
教材章节:实验教程,实验五 进程通信编程教学进度安排:1. 基本概念与通信机制(2课时)2. 同步互斥机制(2课时)3. 实例分析(2课时)4. 实践环节(4课时)教学内容确保科学性和系统性,结合教材章节,从理论到实践,使学生全面掌握进程通信的相关知识。
第1篇一、实验背景进程管理是操作系统中的一个重要组成部分,它负责管理计算机系统中所有进程的创建、调度、同步、通信和终止等操作。
为了加深对进程管理的理解,我们进行了一系列实验,以下是对实验的分析和总结。
二、实验目的1. 加深对进程概念的理解,明确进程和程序的区别。
2. 进一步认识并发执行的实质。
3. 分析进程争用资源的现象,学习解决进程互斥的方法。
4. 了解Linux系统中进程通信的基本原理。
三、实验内容1. 使用系统调用fork()创建两个子进程,父进程和子进程分别显示不同的字符。
2. 修改程序,使每个进程循环显示一句话。
3. 使用signal()捕捉键盘中断信号,并通过kill()向子进程发送信号,实现进程的终止。
4. 分析利用软中断通信实现进程同步的机理。
四、实验结果与分析1. 实验一:父进程和子进程分别显示不同的字符在实验一中,我们使用fork()创建了一个父进程和两个子进程。
在父进程中,我们打印了字符'a',而在两个子进程中,我们分别打印了字符'b'和字符'c'。
实验结果显示,父进程和子进程的打印顺序是不确定的,这是因为进程的并发执行。
2. 实验二:每个进程循环显示一句话在实验二中,我们修改了程序,使每个进程循环显示一句话。
实验结果显示,父进程和子进程的打印顺序仍然是随机的。
这是因为并发执行的进程可能会同时占用CPU,导致打印顺序的不确定性。
3. 实验三:使用signal()捕捉键盘中断信号,并通过kill()向子进程发送信号在实验三中,我们使用signal()捕捉键盘中断信号(按c键),然后通过kill()向两个子进程发送信号,实现进程的终止。
实验结果显示,当按下c键时,两个子进程被终止,而父进程继续执行。
这表明signal()和kill()在进程控制方面具有重要作用。
4. 实验四:分析利用软中断通信实现进程同步的机理在实验四中,我们分析了利用软中断通信实现进程同步的机理。
一、实验目的1. 理解进程通信的概念和作用。
2. 掌握进程通信的常用方法,包括管道、消息队列、信号量等。
3. 通过编程实践,加深对进程通信机制的理解和应用。
二、实验环境操作系统:Linux开发环境:gcc三、实验内容1. 管道通信2. 消息队列通信3. 信号量通信四、实验步骤及分析1. 管道通信(1)实验步骤1)创建一个父进程和一个子进程;2)在父进程中创建一个管道,并将管道的读端和写端分别赋给父进程和子进程;3)在父进程中,通过管道的写端发送数据给子进程;4)在子进程中,通过管道的读端接收父进程发送的数据;5)关闭管道的读端和写端;6)结束进程。
(2)实验分析通过管道通信,实现了父进程和子进程之间的数据传递。
管道是半双工通信,数据只能单向流动。
在本实验中,父进程向子进程发送数据,子进程接收数据。
2. 消息队列通信(1)实验步骤1)创建一个消息队列;2)在父进程中,向消息队列中发送消息;3)在子进程中,从消息队列中接收消息;4)删除消息队列;5)结束进程。
(2)实验分析消息队列是一种进程间通信机制,允许不同进程之间传递消息。
消息队列的创建、发送、接收和删除等操作都是通过系统调用实现的。
在本实验中,父进程向消息队列发送消息,子进程从消息队列接收消息,实现了进程间的消息传递。
3. 信号量通信(1)实验步骤1)创建一个信号量;2)在父进程中,对信号量执行P操作,请求资源;3)在子进程中,对信号量执行V操作,释放资源;4)结束进程。
(2)实验分析信号量是一种用于实现进程同步的机制。
在进程通信中,信号量可以用来协调多个进程对共享资源的访问。
在本实验中,父进程和子进程通过信号量实现了对共享资源的同步访问。
五、实验结果1. 管道通信实验结果:父进程成功向子进程发送数据,子进程成功接收数据。
2. 消息队列通信实验结果:父进程成功向消息队列发送消息,子进程成功从消息队列接收消息。
3. 信号量通信实验结果:父进程成功获取资源,子进程成功释放资源。
第1篇一、实验目的1. 理解进程通信的概念和原理;2. 掌握进程通信的常用机制和方法;3. 能够使用进程通信机制实现进程间的数据交换和同步;4. 增强对操作系统进程管理模块的理解。
二、实验环境1. 操作系统:Linux2. 编程语言:C3. 开发环境:GCC三、实验内容1. 进程间通信的管道机制2. 进程间通信的信号量机制3. 进程间通信的共享内存机制4. 进程间通信的消息队列机制四、实验步骤1. 管道机制(1)创建管道:使用pipe()函数创建管道,将管道文件描述符存储在两个变量中,分别用于读和写。
(2)创建进程:使用fork()函数创建子进程,实现父子进程间的通信。
(3)管道读写:在父进程中,使用read()函数读取子进程写入的数据;在子进程中,使用write()函数将数据写入管道。
(4)关闭管道:在管道读写结束后,关闭对应的管道文件描述符。
2. 信号量机制(1)创建信号量:使用sem_open()函数创建信号量,并初始化为1。
(2)获取信号量:使用sem_wait()函数获取信号量,实现进程同步。
(3)释放信号量:使用sem_post()函数释放信号量,实现进程同步。
(4)关闭信号量:使用sem_close()函数关闭信号量。
3. 共享内存机制(1)创建共享内存:使用mmap()函数创建共享内存区域,并初始化数据。
(2)映射共享内存:在父进程和子进程中,使用mmap()函数映射共享内存区域。
(3)读写共享内存:在父进程和子进程中,通过指针访问共享内存区域,实现数据交换。
(4)解除映射:在管道读写结束后,使用munmap()函数解除映射。
4. 消息队列机制(1)创建消息队列:使用msgget()函数创建消息队列,并初始化消息队列属性。
(2)发送消息:使用msgsnd()函数向消息队列发送消息。
(3)接收消息:使用msgrcv()函数从消息队列接收消息。
(4)删除消息队列:使用msgctl()函数删除消息队列。
进程控制与进程通信程序实验报告一、引言进程是计算机系统中最基本的概念之一,是操作系统中最小的资源管理单位。
进程控制与进程通信是操作系统中重要的内容,涉及到进程的创建、调度和终止,以及进程间的信息传递和同步管理。
本实验旨在通过编写进程控制与进程通信程序,加深对操作系统中进程管理和通信机制的理解。
二、实验目的1. 理解进程的概念和特点,掌握进程的创建、调度和终止方法。
2. 掌握进程通信的基本原理和方法,包括共享内存、管道、消息队列和信号量等。
3. 能够编写简单的进程控制和进程通信程序。
三、实验内容1. 进程控制实验:编写一个程序,实现进程的创建、调度和终止。
通过调用系统调用函数,创建多个子进程,并通过进程控制函数实现父子进程的协作与同步。
2. 进程通信实验:编写一个程序,实现进程间的信息传递和同步管理。
通过共享内存、管道、消息队列或信号量等机制,实现不同进程之间的数据交换和共享。
四、实验步骤1. 进程控制实验:(1)创建父进程和子进程:使用fork()函数创建子进程,并通过判断返回值来区分父子进程。
(2)调度子进程:使用wait()函数等待子进程的结束,以实现父子进程的同步。
(3)终止子进程:使用exit()函数终止子进程的运行。
2. 进程通信实验:(1)共享内存:使用shmget()函数创建共享内存段,使用shmat()函数映射共享内存到进程的地址空间,实现共享数据的读写。
(2)管道:使用pipe()函数创建管道,使用fork()函数创建子进程,通过读写管道实现进程间的数据传输。
(3)消息队列:使用msgget()函数创建消息队列,使用msgsnd()函数向消息队列发送消息,使用msgrcv()函数从消息队列接收消息,实现进程间的消息传递。
(4)信号量:使用semget()函数创建信号量,使用semop()函数对信号量进行P操作和V操作,实现进程间的同步和互斥。
五、实验结果通过实验,我们成功实现了进程的创建、调度和终止,以及进程间的信息传递和同步管理。
一、实验目的1. 理解进程的基本概念和进程状态转换过程。
2. 掌握进程创建、进程同步和进程通信的方法。
3. 了解进程调度算法的基本原理和实现方法。
4. 通过实验加深对进程管理的理解,提高操作系统实践能力。
二、实验环境1. 操作系统:Linux2. 编程语言:C/C++3. 开发工具:GCC三、实验内容1. 进程创建与状态转换(1)使用fork()函数创建一个子进程,并观察父进程和子进程的进程ID。
(2)使用exec()函数替换子进程的映像,实现进程的创建。
(3)观察进程状态转换过程,如创建、运行、阻塞、就绪、终止等。
2. 进程同步(1)使用互斥锁(mutex)实现进程的互斥访问共享资源。
(2)使用信号量(semaphore)实现进程的同步,如生产者-消费者问题。
(3)观察进程同步的效果,确保进程安全执行。
3. 进程通信(1)使用管道(pipe)实现进程间的单向通信。
(2)使用消息队列(message queue)实现进程间的双向通信。
(3)使用共享内存(shared memory)实现进程间的快速通信。
(4)观察进程通信的效果,确保数据正确传递。
(1)实现基于优先级的进程调度算法,如先来先服务(FCFS)和最高优先级优先(HPF)。
(2)实现基于时间片的轮转调度算法(RR)。
(3)观察进程调度算法的效果,分析不同算法的优缺点。
四、实验步骤1. 编写程序实现进程创建与状态转换,使用fork()和exec()函数。
2. 编写程序实现进程同步,使用互斥锁和信号量。
3. 编写程序实现进程通信,使用管道、消息队列和共享内存。
4. 编写程序实现进程调度,使用优先级调度和时间片轮转调度。
5. 编译并运行程序,观察实验结果,分析实验现象。
五、实验结果与分析1. 进程创建与状态转换通过实验,我们成功创建了父进程和子进程,并观察到进程ID的变化。
在进程创建过程中,父进程的进程ID与子进程的进程ID不同,说明子进程是独立于父进程的实体。
实验报告实验题目姓名:学号:课程名称:操作系统实验所在学院:信息科学与工程学院专业班级:计算机任课教师:实验项目名称进程通信——共享存储区和信号量一、实验目的与要求:1、了解和熟悉共享存储机制2、了解和熟悉信号量机制3、熟悉信号量机制中使用的数据结构和信号量机制的操作以及控制。
4、了解共享主存段机制,学会对共享主存段的系统调用。
二、实验设备及软件:1、PC机一台2、Linux操作系统三、实验方法(原理、流程图)一、共享存储区1、共享存储区机制的概念共享存储区(Share Memory)是 UNIX 系统中通信速度最高的一种通信机制。
该机制可使若干进程共享主存中的某一个区域,且使该区域出现(映射)在多个进程的虚地址空间中。
另一方面,一个进程的虚地址空间中又可连接多个共享存储区,每个共享存储区都有自己的名字。
当进程间欲利用共享存储区进行通信时,必须先在主存中建立一共享存储区,然后将它附接到自己的虚地址空间上。
此后,进程对该区的访问操作,与对其虚地址空间的其它部分的操作完全相同。
进程之间便可通过对共享存储区中数据的读、写来进行直接通信。
图示列出二个进程通过共享一个共享存储区来进行通信的例子。
其中,进程 A 将建立的共享存储区附接到自己的 AA’区域,进程 B 将它附接到自己的 BB’区域。
应当指出,共享存储区机制只为进程提供了用于实现通信的共享存储区和对共享存储区进行操作的手段,然而并未提供对该区进行互斥访问及进程同步的措施。
因而当用户需要使用该机制时,必须自己设置同步和互斥措施才能保证实现正确的通信。
二、涉及的系统调用1、shmget( )创建、获得一个共享存储区。
系统调用格式: shmid=shmget(key,size,flag)参数定义: int shmget(key,size,flag);key_t key;int size,flag;其中,key是共享存储区的名字;size是其大小(以字节计);flag是用户设置的标志,如IPC_CREAT。
《操作系统》实验二一、实验目的本实验旨在加深对操作系统基本概念和原理的理解,通过实际操作,提高对操作系统设计和实现的认知。
通过实验二,我们将重点掌握进程管理、线程调度、内存管理和文件系统的基本原理和实现方法。
二、实验内容1、进程管理a.实现进程创建、撤销、阻塞、唤醒等基本操作。
b.设计一个简单的进程调度算法,如轮转法或优先级调度法。
c.实现进程间的通信机制,如共享内存或消息队列。
2、线程调度a.实现线程的创建、撤销和调度。
b.实现一个简单的线程调度算法,如协同多任务(cooperative multitasking)。
3、内存管理a.设计一个简单的分页内存管理系统。
b.实现内存的分配和回收。
c.实现一个简单的内存保护机制。
4、文件系统a.设计一个简单的文件系统,包括文件的创建、读取、写入和删除。
b.实现文件的存储和检索。
c.实现文件的备份和恢复。
三、实验步骤1、进程管理a.首先,设计一个进程类,包含进程的基本属性(如进程ID、状态、优先级等)和操作方法(如创建、撤销、阻塞、唤醒等)。
b.然后,实现一个进程调度器,根据不同的调度算法对进程进行调度。
可以使用模拟的方法,不需要真实的硬件环境。
c.最后,实现进程间的通信机制,可以通过模拟共享内存或消息队列来实现。
2、线程调度a.首先,设计一个线程类,包含线程的基本属性(如线程ID、状态等)和操作方法(如创建、撤销等)。
b.然后,实现一个线程调度器,根据不同的调度算法对线程进行调度。
同样可以使用模拟的方法。
3、内存管理a.首先,设计一个内存页框类,包含页框的基本属性(如页框号、状态等)和操作方法(如分配、回收等)。
b.然后,实现一个内存管理器,根据不同的内存保护机制对内存进行保护。
可以使用模拟的方法。
4、文件系统a.首先,设计一个文件类,包含文件的基本属性(如文件名、大小等)和操作方法(如创建、读取、写入、删除等)。
b.然后,实现一个文件系统管理器,包括文件的存储和检索功能。
实验二进程管理(一)实验目的或实验原理1.加深对进程概念的理解,明确进程和程序的区别。
2.进一步认识并发执行的实质。
3.分析进程竞争资源现象,学习解决进程互斥的方法。
4.了解Linux系统中进程通信的基本原理。
(二)实验内容1.进程的创建。
2.进程的控制。
3.①编写一段程序,使其现实进程的软中断通信。
要求:使用系统调用fork()创建两个子进程,再用系统调用signal()让父进程捕捉键盘上来的中断信号(即按DEL键);当捕捉到中断信号后,父进程用系统调用Kill()向两个子进程发出信号,子进程捕捉到信号后分别输出下列信息后终止:Child Processll is Killed by Parent!Child Processl2 is Killed by Parent!父进程等待两个子进程终止后,输出如下的信息后终止Parent Process is Killed!②在上面的程序中增加语句signal (SIGNAL, SIG-IGN) 和signal (SIGQUIT,SIG-IGN), 观察执行结果,并分析原因。
4.进程的管道通信。
编制一段程序,实现进程的管理通信。
使用系统调用pipe()建立一条管道线;两个子进程P1和P2分别向管道中写一句话:Child 1 is sending a message!Child 2 is sending a message!而父进程则从管道中读出来自于两个子进程的信息,显示在屏幕上。
要求父进程先接收子进程P1发来的消息,然后再接收子进程P2发来的消息。
实验2 指导[实验内容]1.进程的创建〈任务〉编写一段程序,使用系统调用fork( )创建两个子进程。
当此程序运行时,在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示一个字符;父进程显示字符“a”,子进程分别显示字符“b”和“c”。
试观察记录屏幕上的显示结果,并分析原因。
〈程序〉#include<stdio.h>main(){int p1,p2;if(p1=fork()) /*子进程创建成功*/putchar('b');else{if(p2=fork()) /*子进程创建成功*/putchar('c');else putchar('a'); /*父进程执行*/}}<运行结果>bca(有时会出现abc的任意的排列)分析:从进程执行并发来看,输出abc的排列都是有可能的。
实验五 Linux 进程间通信1. 实验目的1)熟悉在C 语言源程序中使用Linux 所提供的系统调用界面的方法;2)掌握Linux 中子进程的创建方法以及调度执行情况,理解进程与程序的区别; 3)掌握软中断信号的使用,了解使用软中断通信实现异步事件的方法;4)掌握父子进程使用管道进行通信的方法,了解管道通信的特点和上的限制。
2. 实验内容1) 父进程创建子进程(1) 实现父进程创建一个子进程,返回后父子进程都分别循环输出字符串“I am parent.”或“I am child.”5次,每输出1次后使用sleep(1)延时1秒,然后再进入下一循环。
(2) 在源程序中连续使用4个fork(),而不用if()进行返回值的判断,在4个fork()语言后面输出字符“A ”,观察并分析该程序编译连接执行后的输出结果。
(3) 由父进程创建一个子进程,子进程的功能史输出26个英文字母,使用execl()加载子进程的程序。
(1)(2)结果:(3)2)软中断的使用(1)编写一个程序循环显示“How are you?”,当键盘输入Ctrl+C的组合键后中断循环显示,执行软中断程序,软中断程序的功能是修改循环变量的值终止循环,然后输出“Byebye”。
输出显示结果:3)管道的使用:(1)编写一个程序,实现:父进程使用系统调用pipe()创建一个无名管道;(2)创建2个子进程,分别向管道各发下面中1条信息后结束:Child 1 is sending a message to parent!Child 2 is sending a message to parent!(1)结果:(2)输出结果:3.实验思考1)如果连续创建多个子进程而不使用条件进行各自空间的分隔,会出现什么情况?2)对实验内容2)进行改进,先输出10次“How are you?”,在此过程中使用Ctrl+C不能中断循环显示,10次以后使用Ctrl+C可以中断循环,应该做那些修改?3)管道通信与软中断通信在信息量的大小上有何区别?4)共享同一个管道进行通信的读写进程之间必须满足什么关系,为什么?。
操作系统实验指导书主编:杜俊俐计算机学院操作系统课程组2010年2月 20日前言操作系统是计算机系统中的核心系统软件,负责控制和管理整个系统的资源并组织用户协调使用这些资源,是计算机高效的工作。
操作系统课程是计算机科学与技术专业核心课程。
由于操作系统是最优秀、最复杂和最庞大的软件之一,所以,真正领会操作系统课程所介绍的感念、原理、方法和技巧等,是十分困难的。
经验表明,学习尤其是真正体会和掌握操作系统的最好方式是对它进行充分的实验。
为此,培养计划中为操作系统课程安排了16学时实验。
为了更好地发挥实验深入理解课程知识的学习作用及知识应用的实践方法,将课程中重要知识点设计成七个实验。
通过这些实验有助于学生全面、透彻的理解操作系统原理中的核心知识。
目录第一章、概述 (4)第二章、实验要求及注意事项 (5)第三章、实验项目 (6)实验一:进程创建与撤消 (6)实验二:进程调度 (7)实验三:进程通信 (8)实验四:分区式储器管理 (9)实验五:请求页式存储管理 (10)实验六:磁盘调度算法 (11)实验七:磁盘文件操作 (12)第四章、参考文献 (13)附录A:实验报告规范 (14)第一章、概述操作系统课程是计算机科学与技术专业核心课程。
《高级语言程序设计》、《数据结构》等课程为其前趋课程。
该课程理论性强,难以理解。
通过课程的实验,能帮助学生深透理解并真正领会操作系统课程所介绍的感念、原理、方法和技巧等。
实验学时为16,共分七个实验分别进行。
实验一:进程创建与撤消、实验二:进程调度、实验三:进程通信、实验四:分区式储器管理、实验五:请求页式存储管理、实验六:磁盘调度算法、实验七:磁盘文件操作。
其中实验五需4学时,其余均为2学时。
这七个实验对操作系统原理中的进程管理、存储器管理、文件系统等重要知识进行训练。
实现语言为Visual C++ 6.0,系统平台为Windows。
第二章、实验要求及注意事项实验环境要求:硬件:普通PC386以上微机;软件:windows操作系统;开发语言:Visual C++ 6.0;实验前应复习实验中所涉及的理论知识和算法,针对实验要求完成基本代码编写并完成预习报告、实验中认真调试所编代码并进行必要的测试、记录并分析实验结果,实验后认真书写符合规范格式的实验报告(参见附录A),并要求用正规的实验报告纸和封面装订整齐,按时上交。
实验报告班级 011291 班学生姓名学号实验成绩一、实验题目:实现最简单实用的通信程序socket.二、实验目的:通过对socket的编写,了解socket通信的原理.了解TCP通信的整个过程.以及Linux下C语言的socket函数.三、实验设备及环境:1. 硬件设备:PC机一台2. 软件环境:安装Linux操作系统,并安装相关的程序开发环境,如C \C++\tsh\bsh等编程语言环境。
四、实验内容及要求:用C语言编程实现linux简单的聊天室功能。
⏹用户程序命名为2.c;服务器程序命名为1.c⏹要求client可以通过socket连接server⏹Client与server可以相互通信,实现交互五.代码(针对实验1,2,请将最终源代码粘贴至此;正式报告中将下面例子删除)服务端:#include <stdio.h>#include <sys/types.h>#include <sys/socket.h>#include <sys/un.h>#define UNIX_DOMAIN "/tmp/UNIX.domain"int main(void){socklen_t clt_addr_len;int listen_fd;int com_fd;int ret;int i;char recv_buf[1024];char send_buf[1024];int len;struct sockaddr_un clt_addr;struct sockaddr_un srv_addr;listen_fd=socket(PF_UNIX,SOCK_STREAM,0);if(listen_fd<0){perror("cannot create communication socket");return 1;}//set server addr_paramsrv_addr.sun_family=AF_UNIX;strncpy(srv_addr.sun_path,UNIX_DOMAIN,sizeof(srv_addr.sun_path)-1 );unlink(UNIX_DOMAIN);//bind sockfd & addrret=bind(listen_fd,(struct sockaddr*)&srv_addr,sizeof(srv_addr));if(ret==-1){perror("cannot bind server socket");close(listen_fd);unlink(UNIX_DOMAIN);return 1;}//listen sockfdret=listen(listen_fd,1);if(ret==-1){perror("cannot listen the client connect request");close(listen_fd);unlink(UNIX_DOMAIN);return 1;}//have connect request use acceptlen=sizeof(clt_addr);com_fd=accept(listen_fd,(struct sockaddr*)&clt_addr,&len); if(com_fd<0){perror("cannot accept client connect request");close(listen_fd);unlink(UNIX_DOMAIN);return 1;}//read and printf sent client infoprintf("\n=====info=====\n");for(i=0;i<4;i++){memset(recv_buf,0,1024);int num=read(com_fd,recv_buf,sizeof(recv_buf));printf("client (%d)) :%s \n",num,recv_buf);write(listen_fd,send_buf,sizeof(send_buf));}close(com_fd);close(listen_fd);unlink(UNIX_DOMAIN);return 0;}客户端:#include <stdio.h>#include <sys/types.h>#include <sys/socket.h>#include <sys/un.h>#define UNIX_DOMAIN "/tmp/UNIX.domain"int main(void){int connect_fd;int ret;char snd_buf[1024],recv_buf[1024];int i;static struct sockaddr_un srv_addr;//creat unix socketconnect_fd=socket(PF_UNIX,SOCK_STREAM,0);if(connect_fd<0){perror("cannot create communication socket");return 1;srv_addr.sun_family=AF_UNIX;strcpy(srv_addr.sun_path,UNIX_DOMAIN);//connect serverret=connect(connect_fd,(structsockaddr*)&srv_addr,sizeof(srv_addr));if(ret==-1){perror("cannot connect to the server");close(connect_fd);return 1;}memset(snd_buf,0,1024);strcpy(snd_buf,"message from client");//send info serverfor(i=0;i<4;i++){gets(snd_buf);write(connect_fd,snd_buf,sizeof(snd_buf));memset(recv_buf,0,1024);int num=read(ret,recv_buf,sizeof(recv_buf));printf("server (%d)) :%s \n",num,recv_buf);}close(connect_fd);return 0;}七、实验结果(请将最终实验结果截图粘贴至此,实验2示例已给出,正式报告中请删除)在linux条件下编译:输入cd work11,进入文件work11(本机程序1.c和2.c放在文件work11中)。
实验五-进程间通信实验(二)实验五进程间通信实验(二)实验目的:1.通过基础实验,基本掌握无名管道、有名管道的程序设计。
2.通过编写程序,使读者掌握信号处理程序设计方法。
实验内容:1.无名管道程序设计:在父进程中创建一个无名管道,并创建子进程;在父进程中写该管道,并用子进程将内容读出。
2.有名管道程序设计:创建两个进程,在A进程中创建一个有名管道,并向其写入数据,通过B进程从有名管道中读出数据。
3.信号处理程序设计:在进程中为SIGBUS注册处理函数,并向该进程发送SIGBUS信号来触发信号处理函数。
实验过程:(一)无名管道程序设计实验代码:/* pipe.c */#include <unistd.h>#include <sys/types.h>#include <errno.h>#include <stdio.h>#include <stdlib.h>#include <string.h>#define MAX_DATA_LEN 256#define DELAY_TIME 1int main(){pid_t pid;int pipe_fd[2];char buf[MAX_DATA_LEN];const char data[] = "Pipe Test Program"; int real_read, real_write;memset((void*)buf, 0, sizeof(buf));/* 创建管道*/if (pipe(pipe_fd) < 0){printf("pipe create error\n");exit(1);}/* 创建一子进程*/if ((pid = fork()) == 0){/* 子进程关闭写描述符,并通过使子进程暂停1秒等待父进程已关闭相应的读描述符*/ close(pipe_fd[1]);sleep(DELAY_TIME * 3);/* 子进程读取管道内容*/if ((real_read = read(pipe_fd[0], buf, MAX_DATA_LEN)) > 0){printf("%d bytes read from the pipe is '%s'\n", real_read, buf);}/* 关闭子进程读描述符*/close(pipe_fd[0]);exit(0);}else if (pid > 0){/* 父进程关闭读描述符,并通过使父进程暂停1秒等待子进程已关闭相应的写描述符*/close(pipe_fd[0]);sleep(DELAY_TIME);/* 父进程向管道中写入字符串*/ if((real_write = write(pipe_fd[1], data, strlen((const char*)data))) != -1){printf("Parent wrote %d bytes : '%s'\n", real_write, data);}/*关闭父进程写描述符*/close(pipe_fd[1]);/*收集子进程退出信息*/waitpid(pid, NULL, 0);exit(0);}}将该程序编译,运行。
#./pipe……(二)有名管道程序设计1.编写一个应用程序,包含两个程序,一个用于读管道,一个用于写管道。
其中在读管道的程序里创建管道,并且作为main()函数里的参数由用户输入要写入的内容。
读管道的程序会读出用户写入到管道的内容,这两个程序采用的是阻塞式读写管道模式。
实验代码:(1)写管道的程序/* fifo_write.c */#include <sys/types.h>#include <sys/stat.h>#include <errno.h>#include <fcntl.h>#include <stdio.h>#include <stdlib.h>#include <limits.h>#define MYFIFO "/tmp/myfifo" /* 有名管道文件名*/#define MAX_BUFFER_SIZE PIPE_BUF /*定义在于limits.h中*/int main(int argc, char * argv[]) /*参数为即将写入的字符串*/{int fd;char buff[MAX_BUFFER_SIZE];int nwrite;if(argc <= 1){printf("Usage: ./fifo_write string\n");exit(1);}sscanf(argv[1], "%s", buff);/* 以只写阻塞方式打开FIFO管道*/fd = open(MYFIFO, O_WRONLY);if (fd == -1){printf("Open fifo file error\n");exit(1);}/*向管道中写入字符串*/if ((nwrite = write(fd, buff, MAX_BUFFER_SIZE)) > 0){printf("Write '%s' to FIFO\n", buff);}close(fd);exit(0);}(2)读管道的程序/* fifo_read.c */#include <sys/types.h>#include <sys/stat.h>#include <errno.h>#include <fcntl.h>#include <stdio.h>#include <stdlib.h>#include <string.h>#include <limits.h>#define MYFIFO "/tmp/myfifo"#define MAX_BUFFER_SIZE PIPE_BUF /*定义在于limits.h中*/int main(){char buff[MAX_BUFFER_SIZE];int fd;int nread;/* 判断有名管道是否已存在,若尚未创建,则以相应的权限创建*/if (access(MYFIFO, F_OK) == -1){if ((mkfifo(MYFIFO, 0666) < 0) && (errno != EEXIST)){printf("Cannot create fifo file\n");exit(1);}}/* 以只读阻塞方式打开有名管道*/fd = open(MYFIFO, O_RDONLY);if (fd == -1){printf("Open fifo file error\n");exit(1);}while (1){memset(buff, 0, sizeof(buff));if ((nread = read(fd, buff, MAX_BUFFER_SIZE)) > 0){printf("Read '%s' from FIFO\n", buff);}}close(fd);exit(0);}为了能够较好地观察运行结果,需要把这两个程序分别在两个终端里运行,首先启动读管道程序。
读管道进程在建立管道之后就开始循环地从管道里读出内容,如果没有数据可读,则一直阻塞到写管道进程向管道写入数据。
在启动了写管道程序后,读进程能够从管道里读出用户的输入内容。
# ./fifo_read……终端二#./fifo_write FIFO……#./fifo_write Test……#./fifo_write Program……(三)信号处理程序设计实验要求:编写一个应用程序,用signal 注册信号处理函数,并用kill发送相应信号触发信号处理。
❝信号概念。
信号是一种进程间的通信机制,它为应用程序提供一种异步的软件中断,使应用程序有机会接收其它程序或终端发送的命令(即信号)。
应用程序收到信号后,有三种处理方式:忽略、默认和捕捉。
进程收到一个信号后,会检查对该信号的处理机制。
如果是SIG_IGN,就忽略该信号;如果SIG_DFT,则采用系统默认的处理动作,通常是终止进程或忽略该信号;如果为该信号指定了一个处理函数(捕捉),则会中断当前进程正在执行的任务,转而去执行该信号的处理函数,返回后再继续执行被中断的任务。
❝常用信号说明:通过kill –l命令可以查看到Linux支持的信号列表。
实验代码及步骤:功能描述:在进程中为SIGBUS注册处理函数,并向该进程发送SIGBUS信号来触发信号处理函数。
/*sig_bus.c*/#include<signal.h>#include<stdio.h>#include<stdlib.h>/*自定义的信号处理函数*/void my_func(int sign_no){if(sign_no==SIGBUS){printf("I have get SIGBUS\n");}}int main(){printf("Waiting for signal SIGBUS\n");/*注册信号处理函数*/signal(SIGBUS,my_func);pause(); //将进程挂起,直到捕捉到信号为止exit(0);}1)对程序进行编辑和编译2)在一个终端中运行sig_bus,会看到进程挂起,等待信号。
3)在另一个终端,查找到运行sig_bus的进程号,通过kill命令发送SIGBUS信号给这个进程。
4)信号触发了处理函数。
这时可以看到前面挂起的进程在接收到这个信号后的处理,用自定义的信号处理函数my_func里处理,因此打印出“I have get SIGBUS”。