操作系统实验报告16487
操作系统实验报告
实验名称:操作系统进程管理实验实验目的:1. 理解操作系统进程管理的概念和原理。
2. 掌握进程的创建、调度、同步和通信机制。
3. 通过实验加深对进程管理算法的理解和应用。
实验环境:1. 操作系统:Windows 102. 编程语言:C/C++3. 开发环境:Visual Studio实验内容:一、实验一:进程的创建与终止1. 实验目的了解进程的创建和终止机制,掌握进程控制块(PCB)的结构和功能。
2. 实验步骤(1)创建一个进程,使用系统调用创建子进程;(2)设置子进程的属性,如优先级、名字等;(3)终止子进程,释放资源;(4)查看进程信息,确认进程创建和终止过程。
3. 实验代码```c#include <stdio.h>#include <sys/types.h>#include <unistd.h>int main() {pid_t pid;printf("Parent process: %d\n", getpid());pid = fork(); // 创建子进程if (pid == 0) {printf("Child process: %d\n", getpid());printf("Child process is running...\n");sleep(5); // 子进程延时5秒exit(0);} else {printf("Child process created: %d\n", pid);wait(NULL); // 等待子进程结束printf("Child process terminated.\n");}return 0;}```4. 实验结果在运行实验代码后,首先输出父进程的进程号,然后输出子进程的进程号,子进程运行5秒后结束,父进程输出子进程终止信息。
操作系统实验实验报告
操作系统实验实验报告一、实验目的操作系统是计算机系统中最为关键的核心软件,它管理着计算机的硬件资源和软件资源,为用户提供了一个方便、高效、稳定的工作环境。
本次操作系统实验的目的在于通过实际操作和实践,深入理解操作系统的基本原理和核心概念,掌握操作系统的基本功能和操作方法,提高对操作系统的认识和应用能力。
二、实验环境本次实验使用的操作系统为 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 等进行文件的创建、读取和写入操作。
《操作系统》实验报告
《操作系统》实验报告一、实验目的操作系统是计算机系统中最为关键的组成部分之一,本次实验的主要目的是深入理解操作系统的基本原理和功能,通过实际操作和观察,熟悉操作系统的核心概念,包括进程管理、内存管理、文件系统和设备管理等,提高对操作系统的实际应用能力和问题解决能力。
二、实验环境本次实验在以下环境中进行:操作系统:Windows 10开发工具:Visual Studio 2019编程语言:C++三、实验内容1、进程管理实验进程是操作系统中最基本的执行单元。
在这个实验中,我们使用C++编写程序来创建和管理进程。
通过观察进程的创建、执行和结束过程,理解进程的状态转换和资源分配。
首先,我们编写了一个简单的程序,创建了多个子进程,并通过进程标识符(PID)来跟踪它们的运行状态。
然后,使用等待函数来等待子进程的结束,并获取其返回值。
在实验过程中,我们发现进程的创建和销毁需要消耗一定的系统资源,而且进程之间的同步和通信需要谨慎处理,以避免出现死锁和竞争条件等问题。
2、内存管理实验内存管理是操作系统的核心功能之一,它直接影响系统的性能和稳定性。
在这个实验中,我们研究了动态内存分配和释放的机制。
使用 C++中的 new 和 delete 操作符来分配和释放内存。
通过观察内存使用情况和内存泄漏检测工具,了解了内存分配的效率和可能出现的内存泄漏问题。
同时,我们还探讨了内存分页和分段的概念,以及虚拟内存的工作原理。
通过模拟内存访问过程,理解了页表的作用和地址转换的过程。
3、文件系统实验文件系统是操作系统用于管理文件和目录的机制。
在这个实验中,我们对文件的创建、读写和删除进行了操作。
使用 C++的文件流操作来实现对文件的读写。
通过创建不同类型的文件(文本文件和二进制文件),并对其进行读写操作,熟悉了文件的打开模式和读写方式。
此外,还研究了文件的权限设置和目录的管理,了解了如何保护文件的安全性和组织文件的结构。
4、设备管理实验设备管理是操作系统与外部设备进行交互的桥梁。
《操作系统》实验报告
一、实验目的1. 理解进程的概念及其在操作系统中的作用。
2. 掌握进程的创建、调度、同步和通信机制。
3. 学习使用进程管理工具进行进程操作。
4. 提高对操作系统进程管理的理解和应用能力。
二、实验环境1. 操作系统:Windows 102. 软件环境:Visual Studio 20193. 实验工具:C++语言、进程管理工具(如Task Manager)三、实验内容1. 进程的创建与销毁2. 进程的调度策略3. 进程的同步与互斥4. 进程的通信机制四、实验步骤1. 进程的创建与销毁(1)创建进程使用C++语言编写一个简单的程序,创建一个新的进程。
程序如下:```cpp#include <iostream>#include <windows.h>int main() {// 创建进程STARTUPINFO si;PROCESS_INFORMATION pi;ZeroMemory(&si, sizeof(si));si.cb = sizeof(si);ZeroMemory(&pi, sizeof(pi));// 创建进程if (!CreateProcess(NULL, "notepad.exe", NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) {std::cout << "创建进程失败" << std::endl;return 1;}std::cout << "进程创建成功" << std::endl;// 等待进程结束WaitForSingleObject(pi.hProcess, INFINITE);// 销毁进程CloseHandle(pi.hProcess);CloseHandle(pi.hThread);return 0;}```(2)销毁进程在上面的程序中,通过调用`WaitForSingleObject(pi.hProcess, INFINITE)`函数等待进程结束,然后使用`CloseHandle(pi.hProcess)`和`CloseHandle(pi.hThread)`函数销毁进程。
《操作系统》课内实验报告
《操作系统》课内实验报告一、实验目的本次《操作系统》课内实验的主要目的是通过实际操作和观察,深入理解操作系统的基本原理和功能,掌握常见操作系统命令的使用,提高对操作系统的实际应用能力和问题解决能力。
二、实验环境本次实验在计算机实验室进行,使用的操作系统为 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)通过“结束任务”按钮可以结束指定的进程,但要注意不要随意结束系统关键进程,以免导致系统不稳定。
操作系统课程实验报告
一、实验概述实验名称:操作系统课程实验实验目的:1. 理解操作系统基本概念、原理及功能;2. 掌握操作系统的基本操作和应用;3. 提高实际操作能力和分析问题、解决问题的能力。
实验内容:1. 操作系统基本概念及原理的学习;2. 操作系统基本操作的应用;3. 实验项目:文件读写、多进程、多线程。
二、实验环境操作系统:Windows 10编译器:Visual Studio语言:C/C++实验平台:Windows 10系统下的虚拟机三、实验过程1. 操作系统基本概念及原理的学习操作系统是计算机系统中最基本的系统软件,负责管理计算机硬件资源、提供用户接口以及执行各种应用程序。
在实验过程中,我们学习了以下基本概念及原理:(1)进程管理:进程是操作系统能够进行运算处理的独立单位,具有动态性、并发性、异步性和独立性等特点。
进程管理主要包括进程的创建、调度、同步、通信和终止等。
(2)内存管理:内存管理是操作系统核心功能之一,主要负责分配、回收、保护和管理内存资源。
内存管理方式有分页、分段、段页式等。
(3)文件系统:文件系统是操作系统用于存储、检索和管理文件的机制。
文件系统主要包括目录结构、文件属性、文件操作等。
(4)设备管理:设备管理负责管理计算机系统中的各种外部设备,包括输入、输出和存储设备。
设备管理主要包括设备分配、设备驱动程序、缓冲区管理等。
2. 操作系统基本操作的应用在实验过程中,我们应用以下基本操作:(1)进程管理:创建、调度、同步、通信和终止进程。
(2)内存管理:分配、回收、保护和管理内存资源。
(3)文件系统:创建、删除、读写文件,实现目录结构的管理。
(4)设备管理:分配、回收、控制和管理设备。
3. 实验项目:文件读写、多进程、多线程(1)文件读写实验实验目的:掌握文件的基本操作,实现文件的创建、打开、读取、写入和关闭。
实验步骤:① 创建一个文件,命名为“test.txt”。
② 打开文件,以读写模式。
国开(电大)操作系统课程实验报告1
国开(电大)操作系统课程实验报告1
概要
该实验报告旨在记录国开(电大)操作系统课程实验1的过程和
结果。
本次实验的主要目标是熟悉操作系统的基本概念和任务管理。
实验过程
1. 阅读实验指南:仔细阅读了实验指南,了解了实验要求和流程。
2. 环境搭建:安装了虚拟机软件并创建了一个虚拟机,用于实
验的操作系统。
3. 实验步骤:
- 步骤1:启动虚拟机并登录操作系统。
- 步骤2:查看当前系统的任务列表。
- 步骤3:创建一个新的任务,并添加一些测试内容。
- 步骤4:查看更新后的任务列表,确认新任务的添加成功。
4. 实验结果:
- 成功完成了所有实验步骤。
- 通过查看任务列表,确认新任务的添加成功。
总结
通过本次实验,我进一步了解了操作系统的基本概念和任务管理。
实践操作系统的相关操作,加深了对操作系统的理解和熟悉度。
在实验过程中,我遵循实验指南,按照步骤进行操作,并取得了预
期的实验结果。
改进建议
对于下次实验,建议在实验过程中记录更多的细节和操作步骤,便于后续复和总结。
同时,对于实验中遇到的问题,可以记录下来
并尝试寻找解决方案,以便在以后的实验中更好地应对类似问题。
《操作系统》课内实验报告
《操作系统》课内实验报告一、实验目的操作系统是计算机系统的核心组成部分,本次《操作系统》课内实验旨在通过实际操作和观察,深入理解操作系统的基本原理、功能和运行机制。
具体目的包括: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)观察并分析在不同的并发情况下,系统的运行结果和资源竞争情况。
操作系统实验报告
操作系统实验报告引言:操作系统是计算机系统中的重要组成部分,它负责管理计算机的硬件资源,控制和协调软件运行。
在操作系统的设计和开发过程中,实验是锻炼学生理论与实践能力的重要方式。
本篇报告将介绍我们在操作系统实验中进行的研究和实践,以及所取得的成果和体会。
一、实验背景在操作系统实验课程中,我们的任务是设计和实现一个简单的操作系统。
通过这个实验,我们能够深入理解操作系统的内部机制,学习操作系统的设计原则和实现技术。
二、实验内容1. 系统引导(Boot)过程在操作系统启动过程中,首先需要进行系统引导。
我们设计了一个引导程序,该程序将在计算机开机时加载到内存中,并负责引导操作系统的加载和初始化。
这个过程需要对计算机硬件的特性有一定的了解,并通过编程来实现。
2. 进程管理操作系统的一个核心功能是管理进程。
我们实现了一个简单的进程管理系统,包括进程的创建、终止、调度等功能。
通过实现这些功能,我们加深了对操作系统进程管理的理解,也锻炼了编程和调试的能力。
3. 内存管理操作系统需要管理计算机的内存资源,以便为进程提供必要的内存空间。
我们设计了一个简单的内存管理系统,能够分配和回收内存空间,并实现了内存保护和虚拟内存等功能。
通过这个实验,我们了解了内存管理的基本原理和技术。
4. 文件系统文件系统是操作系统的另一个重要组成部分。
我们实现了一个简单的文件系统,能够对文件进行读写操作,并支持文件的创建、删除、重命名等功能。
这个实验使我们熟悉了文件系统的组织结构和操作接口。
三、实验成果通过实验,我们成功地设计并实现了一个简单的操作系统。
该系统具有基本的引导过程、进程管理、内存管理和文件系统功能。
我们对系统的稳定性和性能进行了测试,并得到了令人满意的结果。
在实验过程中,我们不仅学到了操作系统的知识,还培养了团队合作和解决问题的能力。
每位成员都充分发挥自己的优势,共同完成了这个实验项目。
四、实验体会通过这个操作系统实验,我们深入了解了操作系统的工作原理和设计方法。
操作系统实验报告
操作系统实验报告本次操作系统实验我们使用了Linux操作系统,对实验平台进行相关操作,有了更直观的理解和掌握对操作系统的认识。
实验一:基础命令的运用在实验一中,我们使用了一些基础命令进行文件操作。
通过输入ls命令可以查看当前目录下的所有文件和文件夹,并通过输入cd命令进入指定的目录,使用pwd命令查看当前所在的目录路径。
同时,我们也学会了文件的创建,复制,删除等操作,使用touch命令可以创建新文件,使用cp和mv可以进行复制和移动文件等操作,使用rm命令可以删除指定的文件或文件夹。
实验二:进程的管理在实验二中,我们学习了进程的管理与调度。
通过命令ps -aux可以查看当前正在运行的所有进程,top命令可以即时查看当前的系统状态并了解CPU和内存的使用情况,kill命令可以终止指定的进程,nice可以改变进程的优先级。
同时,我们还学会了后台进程的管理,使用&符号可以将进程放入后台运行,使用jobs命令可以查看后台进程的状态,使用fg 命令可以将后台进程切换到前台。
实验三:文件系统的管理在实验三中,我们学习了对文件系统的管理。
使用df命令可以查看磁盘空间的使用情况,使用mkfs.ext4可以创建格式化后的磁盘分区,使用mount命令可以将指定的文件系统挂载到指定的挂载点。
同时,我们还学会了对文件和目录权限的管理,使用chmod命令可以改变文件和目录的权限,使用chown命令可以改变文件和目录的所有者,使用chgrp命令可以改变文件和目录的所属组。
实验四:进程间通信在实验四中,我们学习了进程间通信的方式。
使用管道可以实现进程间的数据传输,使用信号可以实现进程间的相互通信,使用共享内存可以实现进程间的共享数据。
同时,我们还学习了线程的创建和管理,使用pthread_create命令可以创建一个新的线程,使用pthread_join命令可以控制线程的结束,使用pthread_exit命令可以结束一个线程。
操作系统课程实验报告
操作系统课程实验报告操作系统课程实验报告一、引言操作系统是计算机系统中最基础的软件之一,扮演着管理计算机硬件和软件资源的重要角色。
为了更好地理解操作系统的工作原理和实践操作系统的相关技术,我们在本学期的操作系统课程中进行了一系列的实验。
二、实验一:进程管理在本实验中,我们学习了进程管理的基本概念和实现方法。
通过编写代码,我们实现了一个简单的进程管理系统。
在这个系统中,我们可以创建、销毁和调度进程,并且实现了进程间的通信和同步机制。
通过这个实验,我们深入了解了进程的创建、调度和通信机制,以及进程的状态转换和资源管理。
三、实验二:内存管理内存管理是操作系统中非常重要的一部分。
在这个实验中,我们学习了内存管理的基本原理和实现方法。
通过编写代码,我们实现了一个简单的内存管理系统。
在这个系统中,我们可以分配和释放内存块,并且实现了虚拟内存和页面置换算法。
通过这个实验,我们深入了解了内存的分配和释放机制,以及虚拟内存的概念和实现。
四、实验三:文件系统文件系统是计算机系统中用于管理和组织文件的一种机制。
在这个实验中,我们学习了文件系统的基本概念和实现方法。
通过编写代码,我们实现了一个简单的文件系统。
在这个系统中,我们可以创建、读取和写入文件,并且实现了文件的目录结构和权限控制。
通过这个实验,我们深入了解了文件的组织和管理机制,以及文件的访问和保护机制。
五、实验四:设备管理设备管理是操作系统中负责管理计算机硬件设备的一部分。
在这个实验中,我们学习了设备管理的基本原理和实现方法。
通过编写代码,我们实现了一个简单的设备管理系统。
在这个系统中,我们可以管理设备的分配和释放,并且实现了设备的互斥和同步机制。
通过这个实验,我们深入了解了设备的管理和调度机制,以及设备的并发和互斥机制。
六、实验总结通过这一系列的实验,我们对操作系统的工作原理和实践操作系统的相关技术有了更深入的了解。
我们学习了进程管理、内存管理、文件系统和设备管理的基本概念和实现方法,并且通过编写代码实现了简单的操作系统功能。
操纵系统实验报告
一、实验目的1. 了解操作系统的基本概念、功能及分类。
2. 掌握操作系统的主要组成部分及其作用。
3. 熟悉操作系统的基本操作,如进程管理、内存管理、文件系统等。
4. 深入理解操作系统的调度策略、同步机制及死锁问题。
二、实验环境1. 操作系统:Windows 102. 编程语言:C/C++3. 开发工具:Visual Studio三、实验内容及步骤1. 进程管理实验(1)实验目的:了解进程的基本概念、进程状态及进程调度。
(2)实验步骤:① 编写一个C/C++程序,创建多个进程,观察进程状态变化。
② 实现进程的创建、回收、切换等功能。
③ 分析进程调度算法(如先来先服务、短作业优先、时间片轮转等)对系统性能的影响。
2. 内存管理实验(1)实验目的:了解内存管理的基本概念、分配策略及碎片问题。
(2)实验步骤:① 编写一个C/C++程序,模拟内存分配过程,观察内存碎片现象。
② 实现内存的分配、回收、扩展等功能。
③ 分析内存分配策略(如固定分区、可变分区、分页、分段等)对系统性能的影响。
3. 文件系统实验(1)实验目的:了解文件系统的基本概念、目录结构及文件操作。
(2)实验步骤:① 编写一个C/C++程序,实现文件系统的创建、删除、读写等操作。
② 实现目录结构的创建、修改、删除等功能。
③ 分析文件系统性能(如访问速度、存储空间利用率等)的影响因素。
4. 调度策略实验(1)实验目的:了解操作系统的调度策略,分析不同调度算法对系统性能的影响。
(2)实验步骤:① 编写一个C/C++程序,模拟进程调度过程,观察不同调度算法的效果。
② 实现先来先服务、短作业优先、时间片轮转等调度算法。
③ 分析不同调度算法的优缺点及适用场景。
5. 同步机制实验(1)实验目的:了解操作系统的同步机制,解决进程竞争资源问题。
(2)实验步骤:① 编写一个C/C++程序,模拟进程竞争资源场景,观察进程同步问题。
② 实现互斥锁、信号量等同步机制。
操作系统实验
操作系统实验报告(一)Linux基本操作与编程(验证性 2学时)1、实验目(de):1)熟悉Linux操作系统(de)环境和使用.2)了解LINUX系统(de)安装过程.(注:表示可选择)3)掌握Linux环境下(de)命令操作.2、实验内容:(1)完成LINUX系统(de)登录,启动终端.进行下列操作并记录结果(要求:结果以屏幕截图表示).1)运行pwd命令,确定你当前(de)工作目录.2)利用以下命令显示当前工作目录(de)内容: ls –l3)运行以下命令: ls –al4)使用mkdir命令建立一个子目录subdir.5)使用cd命令,将工作目录改到根目录(/)上.6)使用ls-l命令列出/dev(de)内容.7)使用不带参数(de)命令cd改变目录,然后用pwd命令确定你当前(de)工作目录是哪里8)使用命令cd ../..,你将工作目录移到什么地方(2)在LINUX下查看你(de)文件.1)利用cd命令,将工作目录改到你(de)主目录上.2)将工作目录改到你(de)子目录subdir,然后运行命令: date > file1 将当前日期和时间存放到新建文件file1中.3)使用cat命令查看file1文件(de)内容.4)利用man命令显示date命令(de)用法: man date5)将date命令(de)用法附加到文件file1(de)后面:man date >> file16)利用cat命令显示文件file1(de)内容.7)利用ls -l file1命令列出文件file1(de)较详细(de)信息.运行ls -l/bin 命令显示目录(de)内容.8)利用ls -l/bin|more命令行分屏显示/bin目录(de)内容.9)利用cp file1 fa命令生成文件file1(de)副本.然后利用ls -l命令查看工作目录(de)内容.10)用cd命令返回你(de)主目录,输入命令ls –l后,解释屏幕显示(de)第一列内容(de)含义.(3)编写能输出“Hello world”问候语(de)C程序,并在终端中编译、执行.要求记录所使用(de)命令及结果.操作步骤:1)在文本编辑器中,编写C程序如下:include ""main(){ printf("hello"); }2) 在终端中,用gcc命令进行编译,生成可执行文件a.gcc –o a3) 在终端中执行a (de)命令如下:./a(4)编写一个程序:显示信息“Time for Play”,并能在后台运行一段时间(自定义)后,弹出信息提醒用户.要求记录所使用(de)命令及结果.(提示:使用sleep(s)函数)3、实验结果分析:(对上述实验内容中(de)各题结果,进行分析讨论.并回答下列问题)(1)进程包括哪些特征间断性, 失去封闭性, 不可再现性, 动态性, 并发性, 独立性(2)在Linux中,如何设置前、后台命令和程序(de)执行命令后直接加 & ,这个命令就在后台执行;正在运行(de)命令,使用Ctrl+z ,就挂起; jobs命令,可以现实后台,包括挂起(de)命令;使用 bg %作业号就可以把挂起(de)命令在后台执行;使用 fg %作业号就可以把后台命令调到前台(3)你所使用(de)Linux系统(de)内核版本是多少用什么命令查看内核版本目前你所了解(de)各发行版本(de)情况如何Linux version (gcc version (Red Hat (GCC) ) 1 SMP Tue Jan 2911:48:01 EST 2013(4)你对Linux系统有什么认识linux是一款开放性(de)操作系统,也可以说成是开放(de)源代码系统,这些代码可以完全自由(de)修改可以再任何(de)计算机上去运行它,也就是“可移植性”,其次大家都知道,linux是由UNIX(de)概念所开发出来(de),所以它也继承了UNIX(de)稳定和效率(de)特点4、总结:你对本次实验有什么体会或看法.操作系统实验报告(二)文件访问权限设置与输入输出重定向(2学时)一、实验目(de)1、掌握linux(de)文件访问权限设置.2、熟悉输入输出重定向和管道操作.二、实验内容1、启动进入红帽linux系统2、设置文件权限:在用户主目录下创建目录test,进入test目录,用vi 创建文件file1,并输入任意(de)文字内容.用ls -l显示文件信息,注意文件(de)权限和所属用户和组.对文件file1设置权限,使其他用户可以对此文件进行写操作:chmod o+w file1.用ls -l查看设置结果.取消同组用户对此文件(de)读取权限:chmod g-r file1.查看设置结果.用数字形式来为文件file1设置权限,所有者可读、可写、可执行;其他用户和所属组用户只有读和执行(de)权限:chmod 755 file1.设置完成后查看设置结果.3、输入、输出重定向和管道(1) 输出重定向用ls命令显示当前目录中(de)文件列表:ls –l.使用输出重定向,把ls命令在终端上显示(de)当前目录中(de)文件列表重定向到文件list中:ls –l > list.查看文件list中(de)内容,注意在列表中会多出一个文件list,其长度为0. 这说明shell是首先创建了一个空文件,然后再运行ls命令:cat list.再次使用输出重定向,把ls命令在终端上显示(de)当前目录中(de)文件列表重定向到文件list中.这次使用追加符号>>进行重定向:ls –l >> list.查看文件list(de)内容,可以看到用>>进行重定向是把新(de)输出内容附加在文件(de)末尾,注意其中两行list文件(de)信息中文件大小(de)区别:cat list.重复命令ls –l > list.再次查看文件list中(de)内容,和前两次(de)结果相比较,注意list文件大小和创建时间(de)区别.(2) 管道who |grep root命令(de)结果是命令ls –l |wc –l结果是4、退出linux系统操作步骤:在主菜单上选择“注销” ->关闭计算机.三、实验结果与讨论(根据实验结果回答下列问题)1. 文件(de)权限如下:-rw-r—r-- 1 root root 19274 Jul 14 11:00回答:-rw-r—r-- (de)含义是什么答:是LINUX/FTP(de)简易权限表示法:对应于本用户-所在组-其他人(de)权限,每一个用执行(x)-读取(r)-写入(w)如本题若是说自己可以读取写入不可以执行,所在组和其他人只能读取.2、文件(de)所有者添加执行权限(de)命令是答:chmod u+x 、赋予所有用户读和写文件权限(de)命令是四、答:chmod a+w,a+r 个人体会(你对本次实验有什么体会或看法)操作系统实验报告(三)文件和目录管理一、实验目(de)1) 掌握在Linux系统下(de)文件和文件系统(de)概念及命令;2) 掌握Linux系统下(de)目录操作.二、实验内容1. 进入linux终端后,用命令(de)操作结果回答下列问题:1)vi(de)三种工作模式是其中不能进行直接转换(de)是什么模式到什么模式命令模式、文本输入模式、末行模式命令模式不能直接到末行模式2)在vi中退出时,保存并退出(de)操作步骤是Ese:wq3)用vi 创建myfile1文件,并在其中输入任意文字一行,创建myfile2文件,任意输入文字3行.请问执行命令:cat <myfile1 >myfile2 后,myfile2中还有几行内容该命令(de)作用是用命令操作验证你(de)回答.myfile2中还有1行内容该命令(de)作用是替换myfile(de)内容4)请用至少两种不同(de)命令创建一个文本文件(),在其中写入“我是2014级学生,我正在使用Linux系统.”,记录命令及执行结果.1、Vi创建2、5)用___pwd________命令可查看所创建文件(de)绝对路径,写出它(de)绝对路径__/root_________;用___ls -l________命令查看该文件(de)类型及访问权限,其访问权限(数字和字母)分别是多少__-rw- r- - r- - 6 4 4______________.6)若将该文件(de)访问权限修改为:所有者有读写权限;其他用户只读;同组用户可读写,请写出命令,并记录结果.7)查找my开头(de)所有文件,可___find my_________命令,写出命令并记录结果8)在/home下创建子目录user,并在其中创建2个文件,名为file1和file2,file1(de)内容是/root目录(de)详细信息;file2(de)内容任意,最后将这两个文件合并为file3文件,请先写出命令序列,并在终端中验证,记录结果.2. 文件及目录操作,写出操作所使用(de)命令,并记录结果.在终端中完成下列命令操作,并记录结果在root用户主目录下创建一个mydir子目录和一个myfile文件,再在mydir下建立d1和d2两个子目录.查看mydir和myfile(de)默认权限查看当前myfile和mydir(de)权限值是多少将myfile文件分别复制到root 和dd1(de)主目录中将root主目录中(de)myfile改为yourfile通过从键盘产生一个新文件并输入I am a student查找文件是否包含student字符串三、实验结果与分析,回答下列问题:1、能够创建文件(de)命令有哪些vi 和cat>name2、能够查看当前目录(de)绝对路径(de)命令是pwd3、Linux中按用户属性将用户分成哪些类型根据文件(de)访问权限,用户又被分成哪些类型能够查看文件访问权限(de)命令是用户同组其他可读可写可执行 cat f1四、小结(本次实验(de)体会或小结)操作系统实验报告(四)作业调度算法模拟(验证性2学时)1、实验目(de):1)掌握作业调度(de)主要功能及算法.2)通过模拟作业调度算法(de)设计加深对作业管理基本原理(de)理解.3)熟悉Linux环境下应用程序(de)编程方法.2、实验内容:(1)作业调度算法(FCFS)编程模拟:编制一段程序,对所输入(de)若干作业,输入、输出数据样例如下表所示.按FCFS算法模拟调度,观察、记录并分析调度(de)输出结果情况.输入输出样例1:FCFS算法include <>include <>define SIZE 5struct Job_type{char no[2]; o,&job[i].tb,&job[i].tr);printf("输入作业顺序:\n");for(i=0;i<SIZE;i++)printf("\t%s\t%d\t%d\n",job[i].no,job[i].tb,job[i].tr);}void fcfs(){ int i,j,t=0,tw=0,tt=0;for(i=0;i<SIZE-1;i++)for(j=i+1;j<SIZE;j++)if(job[i].tb>job[j].tb){x=job[i];job[i]=job[j];job[j]=x;}printf("FCFS调度结果:\n");printf("开始时间作业号到达时间运行时间完成时间等待时间周转时间\n");for(i=0;i<SIZE;i++){printf(" %d",t);t=t+job[i].tr;tw=t-job[i].tb-job[i].tr; b; o,job[i].tb,job[i].tr,t,tw,tt);}}void main(){load();fcfs();}(2)作业调度算法(SJF)编程模拟:编程实现由短作业优先算法,分别用下面两组输入、输出数据样例进行模拟,观察分析运行结果.输入输出样例2:SJF算法输入输出A 0 4B 0 3C 0 5D 0 2E 0 1A 0 6 10 10B 0 3 6 6C 0 10 15 15D 0 1 3 3E 0 0 1 1include <>include <>define SIZE 5struct Job_type{char no[2]; o,&job[i].tb,&job[i].tr);printf("输入作业顺序:\n");for(i=0;i<SIZE;i++)printf("\t%s\t%d\t%d\n",job[i].no,job[i].tb,job[i].tr);}void sjf()n=i; pl[i].pfn=ERR;}for(i=1;i<total;i++){ pfc[i-1].next=&pfc[i];pfc[i-1].pfn=i-1;}pfc[total-1].next=NULL;pfc[total-1].pfn=total-1;freepf_head=&pfc[0];}void FIFO(int total){ int i,j;pfc_type p,t;initialize(total);busypf_head=busypf_tail=NULL;for(i=0;i<page_len;i++){if(pl[page[i]].pfn==ERR){ diseffect+=1;if(freepf_head==NULL){p=busypf_head->next;pl[busypf_head->pn].pfn=ERR; freepf_head=busypf_head;freepf_head->next=NULL;busypf_head=p;}p=freepf_head->next;freepf_head->next=NULL;freepf_head->pn=page[i];pl[page[i]].pfn=freepf_head->pfn;if(busypf_tail==NULL)busypf_head=busypf_tail=freepf_head; else{ busypf_tail->next=freepf_head;busypf_tail=freepf_head;}freepf_head=p;}}printf("FIFO:%d",diseffect);}main(){ int i; int k;printf(“请输入页(de)引用序列:\n”); for(k=0;k<page_len;k++)scanf("%d",&page[k]);for(i=4;i<=7;i++){printf("%2d page frames ",i);FIFO(i);}参考程序LRU算法,略三、实验结果分析:(对上述实验各题所使用(de)原始数据、调试数据与状态(包括出错)及最终结果进行记录并分析.)随着块数(de)增加,缺页数目也减少,4个实验中3个实验(de)块数增加到了5以后,即使块数再增加,缺页数目也是保持不变.只有实验4,块数增加到7以后,缺页数目又再次减少了四、总结:你对本次实验有什么体会或看法.。
操作系统实验报告
操作系统实验报告一、实验目的本次操作系统实验的主要目的是深入了解操作系统的基本原理和功能,通过实际操作和观察,增强对进程管理、内存管理、文件系统等核心概念的理解和掌握。
同时,培养解决实际问题的能力,提高编程和调试技能,为今后学习和工作中更好地应用操作系统知识打下坚实的基础。
二、实验环境本次实验在_____操作系统环境下进行,使用的编程语言为_____,开发工具为_____。
三、实验内容(一)进程管理实验1、进程创建与终止通过编程实现创建新进程,并观察进程的创建过程和资源分配情况。
同时,实现进程的正常终止和异常终止,了解进程终止时的资源回收机制。
2、进程调度算法模拟模拟实现先来先服务(FCFS)、短作业优先(SJF)、时间片轮转(RR)等进程调度算法。
通过对不同调度算法的模拟,分析其性能特点,如平均周转时间、平均等待时间等。
(二)内存管理实验1、分区存储管理实现固定分区和动态分区存储管理方式,观察内存的分配和回收过程,分析不同分区策略下的内存利用率和碎片情况。
2、页面置换算法模拟模拟实现先进先出(FIFO)、最近最少使用(LRU)、最佳置换(OPT)等页面置换算法。
通过对不同页面置换算法的模拟,分析其对缺页率的影响。
(三)文件系统实验1、文件的创建、删除与读写通过编程实现文件的创建、删除操作,并对文件进行读写操作,观察文件系统的工作过程。
2、文件目录结构的实现实现简单的文件目录结构,如单级目录、两级目录和树形目录结构,了解文件目录的组织和管理方式。
四、实验步骤(一)进程管理实验1、进程创建与终止(1)使用系统提供的进程创建函数创建新进程,并在新进程中执行特定的任务。
(2)在父进程中等待子进程的结束,并获取子进程的返回状态。
(3)通过设置不同的条件,实现进程的正常终止和异常终止,并观察操作系统对终止进程的处理。
2、进程调度算法模拟(1)设计数据结构来表示进程的信息,如进程 ID、到达时间、服务时间等。
操作系统实验报告
操作系统实验报告一、实验目的本次操作系统实验的主要目的是通过实际操作和观察,深入理解操作系统的工作原理和关键机制,包括进程管理、内存管理、文件系统以及设备管理等方面。
同时,培养我们解决实际问题的能力,提高对操作系统相关知识的综合运用水平。
二、实验环境本次实验使用的操作系统为 Windows 10 和 Linux(Ubuntu 2004 LTS),实验所使用的编程工具包括 Visual Studio Code、gcc 编译器等。
三、实验内容及步骤(一)进程管理实验1、进程创建与终止在 Windows 系统中,使用 C++语言编写程序,通过调用系统 API函数创建新的进程,并观察进程的创建和终止过程。
在 Linux 系统中,使用 C 语言编写程序,通过 fork()系统调用创建子进程,并通过 wait()函数等待子进程的终止。
2、进程调度观察Windows 和Linux 系统中进程的调度策略,包括时间片轮转、优先级调度等。
通过编写程序模拟进程的执行,设置不同的优先级和执行时间,观察系统的调度效果。
(二)内存管理实验1、内存分配与释放在 Windows 系统中,使用 C++语言的 new 和 delete 操作符进行内存的动态分配和释放,并观察内存使用情况。
在 Linux 系统中,使用 C 语言的 malloc()和 free()函数进行内存的分配和释放,通过查看系统的内存使用信息来验证内存管理的效果。
2、虚拟内存管理研究 Windows 和 Linux 系统中的虚拟内存机制,包括页表、地址转换等。
通过编写程序访问虚拟内存地址,观察系统的处理方式和内存映射情况。
(三)文件系统实验1、文件操作在 Windows 和 Linux 系统中,使用编程语言对文件进行创建、读取、写入、删除等操作。
观察文件的属性、权限设置以及文件在磁盘上的存储方式。
2、目录操作实现对目录的创建、删除、遍历等操作。
研究目录结构和文件路径的表示方法。
操作系统实验报告1
操作系统实验报告1实验一进程控制与描述一、实验目的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)文件属性操作获取文件的属性信息,如文件大小、创建时间、修改时间等,并进行相应的操作和显示。
操作系统实验报告
操作系统实验报告操作系统是计算机科学中十分重要的一门课程,本次实验是关于操作系统的,通过实验,我们可以更深入地了解操作系统的相关知识和操作。
本篇文章将着重介绍本次操作系统实验的内容和实验过程中的收获。
一、实验内容本次实验内容主要涉及操作系统的进程、线程和进程同步三部分。
具体内容包括: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()函数释放进程或线程。
为了更好地理解信号量的工作原理,我们将代码分为生产者和消费者两部分,其中生产者用于向缓冲区添加数据,消费者则用于删除数据。
在这个过程中,我们需要使用信号量控制生产者和消费者的数量,避免出现生产过多或消费过多的情况。
操作系统实验报告
操作系统实验报告
一、实验目的
1. 学习操作系统中进程管理的相关知识和技术,并掌握多进程并发执行的原理与方法;
2. 掌握多进程之间的同步与通信技术;
3. 进一步理解操作系统中进程的各个状态变化过程。
二、实验内容
1. 编写一个简单的多进程模拟系统,实现多个进程在同一时间并发执行;
2. 实现进程之间的同步,避免进程之间的竞态条件;
3. 实现进程之间的通信,可以通过管道等方式进行。
三、实验步骤
1. 设计进程模型,分析进程的状态转换图,确定各个状态的处理方式;
2. 编写进程控制块(PCB)类,定义进程的各种属性和处理方法;
3. 实现进程状态的转换和进程之间的同步机制;
4. 实现进程之间的通信的方式和机制;
5. 设计并执行多个进程并发执行的测试用例;
6. 分析测试结果并进行优化和改进。
四、实验结果
本次实验编写了一个简单的模拟多进程操作系统,实现了多个进程并发执行、进程之间的同步和通信等功能。
通过编写不同的测试用例对系统进行了测试,验证了系统的正确性和可靠性,测试结果证明了系统能够有效地解决进程之间的竞态条件问题,并实现良好的并发执行效果。
五、实验感想
本次实验让我更加深入地了解了操作系统中进程管理的相关知识和技术,学习了多进程并发执行的原理与方法,并掌握了进程之间的同步与通信技术。
通过实验,我进一步理解了操作系统中进程的各个状态变化过程,在实践中深入掌握了进程控制块的定义和处理方法,也收获了许多编程技巧和思维方式。
通过不断调试和改进进程模型,我不断提高了自己的实践能力和解决问题的能力。
总之,本次实验让我得到了很大的启示和帮助,增强了自己的实践经验和能力。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
西安邮电大学(计算机学院)课实验报告实验名称:进程管理专业名称:计算机科学与技术班级:学生:学号(8位):指导教师:实验日期:*****年**月**日一. 实验目的及实验环境目的:(1)加深对进程概念的理解,明确进程和程序的区别。
(2)进一步认识并发执行的实质。
(3)分析进程竞争资源现象,学习解决进程互斥的方法。
(4)了解Linux系统中进程通信的基本原理。
环境:Linux操作系统环境:二. 实验容(1)阅读Linux的sched.h源文件,加深对进程管理概念的理解。
(2)阅读Linux的fork.c源文件,分析进程的创建过程。
三.方案设计(1)进程的创建编写一段源程序,使系统调用fork()创建两个子进程,当此程序运行时,在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示一个字符:父进程显示字符“a”;子进程分别显示字符“b”和字符“c”。
试观察纪录屏幕上的显示结果,并分析原因。
(2)进程的控制修改已编写的程序,将每个进程输出一个字符改为每个进程输出一句话,在观察程序执行时屏幕出现的现象,并分析原因。
如果在程序中使用调用lockf()来给每一个子进程加锁,可以实现进程之间的互斥,观察并分析出现的现象。
(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发来的消息。
四.测试数据及运行结果1.创建进程,显示结果bca,这是因为程序执行时,先执行fork()创建进程所需的时间多于输出一个字符的时间,因此在主进程创建进程2的同时,进程1就输出了“b”,而进程2和主程序的输出次序是有随机性的,2.进程的控制3.软中断通信A.B.因为没有了中断与退出信号,程序一直是阻塞状态而无法退出。
关键代码:main(){int p1,p2;if(p1=fork()) /*创建子进程p1*/{if(p2=fork()) /*创建子进程p2*/{wait_mark=1;signal(SIGINT,stop); /*接收到^c信号,转stop*/waiting();kill(p1,16); /*向p1发软中断信号16*/kill(p2,17); /*向p2发软中断信号17*/wait(0); /*同步*/wait(0);printf("parent process is killed!\n");exit(0);}else{wait_mark=1;signal(SIGINT,stop);waiting();lockf(1,0,0);printf("child process2 is killed by parent!\n");lockf(1,0,0);exit(0);}}else{wait_mark=1;signal(SIGINT,stop);waiting();lockf(1,0,0);printf("child process1 is killed by parent!\n");lockf(1,0,0);exit(0);}}4.进程的管道通信五.总结1.在软中断通信中,调用函数signal()都放在一段程序的前面位置,而不是在其接受信号处,这是因为signal()的执行只是为指定信号量16和17的作用,以及分配相应的与stop()过程的指针。
从而signal()函数必须在程序前面部分执行。
2.通过这次实验,加深了对进程管理的认识。
这次实验更需要耐心观察,一步一步执行调试,不能操之过急。
做实验是对课本知识的巩固,更是对自己动手能力的锻炼。
六.附录:源代码(电子版)1.创建进程:#include<stdio.h>main(){int p1,p2;if(p1=fork()) /*子进程创建成功*/p utchar('b');else{if(p2=fork()) /*子进程创建成功*/putchar('c');else putchar('a'); /*父进程执行*/}}2.进程的控制〈程序1〉.#include<stdio.h>main(){int p1,p2,i;if(p1=fork())for(i=0;i<500;i++)printf("child %d\n",i);else{i f(p2=fork())for(i=0;i<500;i++)printf("son %d\n",i);e lsefor(i=0;i<500;i++)printf("daughter %d\n",i);}}〈程序2〉#include<stdio.h>main(){int p1,p2,i;if(p1=fork()){lockf(1,1,0);for(i=0;i<500;i++)printf("child %d\n",i);lockf(1,1,0);}else{if(p2=fork()){lockf(1,1,0);for(i=0;i<500;i++) printf("son %d\n",i);lockf(1,1,0);}else{lockf(1,1,0);for(i=0;i<500;i++) printf("daughter %d\n",i);lockf(1,0,0);}}}3.软中断通信〈程序1〉#include<stdio.h>#include<signal.h>#include<unistd.h>void waiting(),stop();int wait_mark;main(){int p1,p2;if(p1=fork()) /*创建子进程p1*/{if(p2=fork()) /*创建子进程p2*/{wait_mark=1;signal(SIGINT,stop); /*接收到^c信号,转stop*/waiting();kill(p1,16); /*向p1发软中断信号16*/kill(p2,17); /*向p2发软中断信号17*/wait(0); /*同步*/wait(0);printf("parent process is killed!\n");exit(0);}else{wait_mark=1;signal(SIGINT,stop);waiting();lockf(1,0,0);printf("child process2 is killed by parent!\n");lockf(1,0,0);exit(0);}}else{wait_mark=1;signal(SIGINT,stop);waiting();lockf(1,0,0);printf("child process1 is killed by parent!\n");lockf(1,0,0);exit(0);}}void waiting(){while (wait_mark!=0);}void stop(){wait_mark=0;}<程序2>#include<stdio.h>#include<signal.h>#include<unistd.h>int pid1,pid2;int EndFlag=0;int pf1=0;int pf2=0;void IntDelete(){kill(pid1,16);kill(pid2,17);EndFlag=1;}void Int1(){printf("child process 1 is killed !by parent\n");exit(0);}void Int2(){printf("child process 2 is killed !by parent\n");exit(0);}main(){int exitpid;signal(SIGINT,SIG_IGN);signal(SIGQUIT,SIG_IGN);if(pid1=fork()){signal(SIGUSR1,Int1);signal(SIGINT,SIG_IGN);pause();exit(0);}else{if(pid2=fork()){signal(SIGUSR1,Int1);signal(SIGINT,SIG_IGN);pause();exit(0);}else{signal(SIGINT,IntDelete);waitpid(-1,&exitpid,0);printf("parent process is killed\n");exit(0);}}}4.进程的管道通信〈程序〉#include <unistd.h>#include <signal.h>#include <stdio.h>int pid1,pid2;main( ){int fd[2];char outpipe[100],inpipe[100];pipe(fd); /*创建一个管道*/while ((pid1=fork( ))==-1);if(pid1==0){lockf(fd[1],1,0);sprintf(outpipe,"child 1 process is sending message!");/*把串放入数组outpipe中*/write(fd[1],outpipe,50); /*向管道写长为50字节的串*/sleep(5); /*自我阻塞5秒*/lockf(fd[1],0,0);exit(0);}else{while((pid2=fork( ))==-1);if(pid2==0){ lockf(fd[1],1,0); /*互斥*/sprintf(outpipe,"child 2 process is sending message!");write(fd[1],outpipe,50);sleep(5);lockf(fd[1],0,0);exit(0);}else{ wait(0); /*同步*/read(fd[0],inpipe,50); /*从管道中读长为50字节的串*/printf("%s\n",inpipe);wait(0);read(fd[0],inpipe,50);printf("%s\n",inpipe);exit(0);}}}。