实验一进程管理实验

合集下载

操作系统实验实验报告

操作系统实验实验报告

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

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

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

操作系统原理实验

操作系统原理实验

操作系统原理实验一、实验目的本实验旨在通过实际操作,加深对操作系统原理的理解,掌握操作系统的基本功能和调度算法。

二、实验环境1. 操作系统:Windows 102. 虚拟机软件:VirtualBox3. 实验工具:C语言编译器(如gcc)、汇编语言编译器(如nasm)、调试器(如gdb)三、实验内容1. 实验一:进程管理在这个实验中,我们将学习如何创建和管理进程。

具体步骤如下:a) 创建一个C语言程序,实现一个简单的计算器功能。

该计算器能够进行基本的加减乘除运算。

b) 使用fork()系统调用创建一个子进程,并在子进程中执行计算器程序。

c) 使用wait()系统调用等待子进程的结束,并获取子进程的退出状态。

2. 实验二:内存管理在这个实验中,我们将学习如何进行内存管理。

具体步骤如下:a) 创建一个C语言程序,模拟内存分配和释放的过程。

该程序能够动态地分配和释放内存块。

b) 使用malloc()函数分配一块内存,并将其用于存储数据。

c) 使用free()函数释放已分配的内存块。

3. 实验三:文件系统在这个实验中,我们将学习如何进行文件系统的管理。

具体步骤如下:a) 创建一个C语言程序,实现一个简单的文件系统。

该文件系统能够进行文件的创建、读取、写入和删除操作。

b) 使用open()系统调用打开一个文件,并进行读取和写入操作。

c) 使用unlink()系统调用删除一个文件。

四、实验步骤1. 安装虚拟机软件VirtualBox,并创建一个虚拟机。

2. 在虚拟机中安装操作系统Windows 10。

3. 在Windows 10中安装C语言编译器、汇编语言编译器和调试器。

4. 根据实验内容,编写相应的C语言程序并保存。

5. 在命令行中使用gcc编译C语言程序,并生成可执行文件。

6. 运行可执行文件,观察程序的执行结果。

7. 根据实验要求,进行相应的操作和测试。

8. 完成实验后,整理实验报告,包括实验目的、实验环境、实验内容、实验步骤和实验结果等。

实验1:进程管理

实验1:进程管理

实验1:进程管理要求:编写程序,模拟实现创建新的进程;查看运行进程;换出某个进程;撤销某个进程。

提示:1、进程状态简单处理为:0为不在内存,1为在内存,2为阻塞,3为挂起。

2、撤销进程指将进程的状态从运行变为阻塞。

3、程序的结构可以处理为在主函数中用switch语句调用各种表示进程管理功能的函数。

源程序代码:#include <iostream>#include <fstream>#include <string>#include <windows.h>#include <iomanip>using namespace std;const Max=100;int Tread[3][Max];//[号码][大小][状态]int n=-1;int mem=64;int a;void T(){cout<<"**********************************"<<endl;cout<<"* 进程演示系统*"<<endl;cout<<"**********************************"<<endl;cout<<"* 1.创建进程*"<<endl;cout<<"* 2.调入内存*"<<endl;cout<<"* 3.杀死进程*"<<endl;cout<<"* 4.查看进程*"<<endl;cout<<"----------------------------------"<<endl;cout<<"< 提示:状态0为不在内存,1为在内存,2为阻塞,3为挂起。

操作系统-进程管理实验报告

操作系统-进程管理实验报告

操作系统-进程管理实验报告实验一进程管理1.实验目的:(1)加深对进程概念的理解,明确进程和程序的区别;(2)进一步认识并发执行的实质;(3)分析进程争用资源的现象,研究解决进程互斥的方法;(4)了解Linux系统中进程通信的基本原理。

2.实验预备内容(1)阅读Linux的sched.h源码文件,加深对进程管理概念的理解;(2)阅读Linux的fork()源码文件,分析进程的创建过程。

3.实验内容(1)进程的创建:编写一段程序,使用系统调用fork()创建两个子进程。

当此程序运行时,在系统中有一个父进程和两个子进程活动。

让每一个进程在屏幕上显示一个字符:父进程显示字符“a”,子进程分别显示字符“b”和“c”。

试观察记录屏幕上的显示结果,并分析原因。

源代码如下:#include<XXX>#include<XXX>#include<unistd.h>#include <XXX>#include <XXX>int main(int argc,char* argv[]){pid_t pid1,pid2;pid1 = fork();if(pid1<0){fprintf(stderr,"childprocess1 failed");exit(-1);}else if(pid1 == 0){printf("b\n");}else{pid2 = fork();if(pid2<0){fprintf(stderr,"childprocess1 failed"); exit(-1);}else if(pid2 == 0){printf("c\n");}else{printf("a\n");sleep(2);exit(0);}}return 0;}结果如下:分析原因:pid=fork();操纵体系创建一个新的历程(子历程),而且在历程表中相应为它建立一个新的表项。

进程管理实验报告_共10篇 .doc

进程管理实验报告_共10篇 .doc

★进程管理实验报告_共10篇范文一:_进程管理实验报告进程管理实验报告一、进程与线程1.实验目的:1.通过本实验学习Linux中创建进程的方法。

2.学习系统调用fork的使用方法。

3.学习系统调用exec族调用的使用方法。

2.实验准备1.进程的创建创建一个进程的系统调用很简单,只要调用fork函数就可以了。

#includepid_tfork();当一个进程调用了fork以后,系统会创建一个子进程,这个子进程和父进程是不同的地方只有它的进程ID和父进程ID,其他的都一样,就像父进程克隆(clone)自己一样,当然创建两个一模一样的进程是没有意义的,为了区分父进程和子进程,我们必须跟踪fork调用返回值。

当fork调用失败的时候(内存不足或者是用户的最大进程数已到)fork返回—1,否则fork的返回值有重要的作用。

对于父进程fork返回子进程ID,而对于fork 子进程返回0,我们就是根据这个返回值来区分父子进程的。

2.关于fork的说明使用该函数时,该函数被调用一次,但返回两次,两次返回的区别是子进程的返回值是0,而父进程的返回值则是新子进程的进程ID。

将子进程ID返回给父进程的理由是:因为一个进程的子进程可以多于一个,所以没有一个函数可以是一个子进程获得其所有子进程的进程ID。

而fork函数使子进程得到的返回值是0的理由是:一个子进程只会有一个父进程,所以子进程总是可以调用函数getpid获得其父进程的进程ID。

3.系统调用exec族调用的说明父进程创建子进程后,子进程一般要执行不同的程序。

为了调用系统程序,我们可以使用系统调用exec族调用。

Exec族调用有以下五个函数:intexecl(constchar*path,constchar*arg,?);intexeclp(constchar*file,constchar*arg,?);intexecle(constchar*path,constchar*arg,?);intexecv(constchar*path,constchar*argv[]);intexecvp(constchar*file,constchar*argv[]);exec族调用可以执行给定程序。

进程管理实验报告分析(3篇)

进程管理实验报告分析(3篇)

第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. 实验四:分析利用软中断通信实现进程同步的机理在实验四中,我们分析了利用软中断通信实现进程同步的机理。

实验一进程控制与描述

实验一进程控制与描述

死锁检测
死锁检测是通过检测系统状态是否满足死锁条件来确定系 统是否处于死锁状态。
死锁解除
死锁解除是当系统检测到死锁状态时采取措施来解除死锁 的过程。
资源有序分配法
资源有序分配法是一种预防死锁的方法,通过为每个资源 分配一个唯一的序号,并要求进程按照序号递增的顺序请 求资源来避免产生循环等待条件。
03 进程描述
实验一:进程控制与描述
目录
• 进程控制概述 • 进程控制机制 • 进程描述 • 实验步骤与操作 • 实验结果与分析
01 进程控制概述
进程的定义与特性
总结词
进程是程序的一次执行,具有动态性、 并发性、制约性、独立性和制约性等特 性。
VS
详细描述
进程是程序在计算机上的一次执行过程, 它具有动态性,即进程的状态可以在运行 过程中改变;并发性,即进程可以同时存 在于多个状态;制约性,即进程间的相互 制约关系;独立性,即进程是独立的,不 受其他进程的影响;制约性,即进程间的 相互制约关系。
04 实验步骤与操作
实验环境搭建
准备实验所需的操作 系统环境,如Linux 或Windows。
配置网络连接,确保 实验过程中能够访问 外部资源。
安装必要的软件工具, 如任务管理器、终端 等。
进程创建与终止实验
01 打开任务管理器或终端,
查看当前运行的进程。
观察并记录进程的创建 过程和结果,包括进程
PCB中包含了进程标识符、进 程状态、内存指针、文件描述 符表等信息。
通过PCB,操作系统可以对进 程进行创建、切换、终止等操 作,实现对进程的统一管理。
进程状态信息
1
进程状态信息是指描述进程当前状态的变量和数 据结构。

操作系统实验报告----进程管理

操作系统实验报告----进程管理

实验内容:进程管理一、实验目的1、掌握Linux中进程的创建方法及执行情况;2、加深对进程、进程树等概念的理解;3、掌握Linux中如何加载子进程自己的程序;4、掌握父进程通过创建子进程完成某项任务的方法;5.、掌握系统调用exit()和_exit()调用的使用。

6、分析进程竞争资源的现象,学习解决进程互斥的方法;进一步认识并发执行的实质二、实验内容(一)进程的创建1、编写一段程序,使用系统调用fork( )创建两个子进程。

当此程序运行时,在系统中有一个父进程和两个子进程活动。

让每一个进程在屏幕上显示一个字符。

#include<stdio.h>main(){int p,x;p=fork();if(p>0){x=fork();if(x>0)printf("father\n");elseprintf("child2");}elseprintf("child1");}输出结果:child1child2father2、运行以下程序,分析程序执行过程中产生的进程情况。

#include <stdio.h>main(){int p,x;p=fork();if (p>0)fork();else{fork();fork();}sleep(15);}实验步骤:编译连接gcc –o forktree forktree.c后台运行./forktree &使用pstree –h 查看进程树运行结果:├─gnom e-terminal─┬─bash─┬─forktree─┬─forktree─┬─forkt ree───forktree││││└─forktree│││└─forktree││└─pstree 分析:程序运行,系统首先创建一个进程forktree,执行到p=fork()创建一个子进程forktree,子进程获得处理机优先执行,父进程等待;执行else,当执行到第一个fork()函数时,子进程创建了一个进程forktree,称之为孙进程,孙进程获得处理机往下执行,子进程等待;执行到第二个fork()函数时,孙进程又创建一个进程forktree,称之为重孙进程,重孙进程很快执行完,将处理机还给孙进程,孙进程很快执行完,将处理机还给子进程;子进程继续往下执行,执行到第二个fork()函数,又创建一个进程forktree,称之为第二孙进程,并获得处理机执行,此进程很快执行完,将处理机还给子进程,子进程也很快执行完,将处理机还给父进程,父进程P>0执行if语句,运行fork()函数,又创建一个进程forktree,称之为第二子进程,此进程获得处理机执行很快运行完,将处理机还给父进程,父进程运行sleep(15)语句,休眠15秒,用pstree命令查询进程树。

进程的管理实验报告结论

进程的管理实验报告结论

一、实验背景及目的进程是操作系统中基本的活动单位,进程管理是操作系统核心功能之一。

为了深入理解进程的概念、进程状态转换、进程同步与互斥等知识,我们进行了进程管理实验。

本次实验旨在通过编写程序,模拟进程的创建、调度、同步与互斥等操作,加深对进程管理的理解。

二、实验内容及方法1. 进程创建与状态转换(1)使用系统调用fork()创建子进程,观察父进程和子进程的状态转换过程。

(2)使用系统调用exec()替换子进程的内容,观察子进程状态变化。

2. 进程调度(1)编写进程调度程序,实现最高优先数优先调度算法和先来先服务调度算法。

(2)模拟进程就绪队列,观察调度算法对进程执行顺序的影响。

3. 进程同步与互斥(1)使用信号量实现进程同步,观察进程同步效果。

(2)使用互斥锁实现进程互斥,观察进程互斥效果。

4. 进程通信(1)使用管道实现进程间通信,观察通信效果。

(2)使用共享内存实现进程间通信,观察通信效果。

三、实验结果与分析1. 进程创建与状态转换实验结果显示,使用fork()创建子进程后,父进程和子进程的状态均为运行态。

当父进程调用exec()替换子进程内容后,子进程状态变为僵尸态,父进程状态变为运行态。

这说明进程在创建和替换过程中,其状态发生了相应的变化。

2. 进程调度实验结果显示,最高优先数优先调度算法和先来先服务调度算法均能正确执行。

最高优先数优先调度算法下,优先级高的进程先执行;先来先服务调度算法下,先到达的进程先执行。

这说明两种调度算法均能实现进程的合理调度。

3. 进程同步与互斥实验结果显示,使用信号量实现进程同步时,进程能正确地按照规定的顺序执行;使用互斥锁实现进程互斥时,进程能正确地实现互斥访问共享资源。

这说明信号量和互斥锁在进程同步与互斥方面具有重要作用。

4. 进程通信实验结果显示,使用管道实现进程间通信时,进程能正确地接收和发送数据;使用共享内存实现进程间通信时,进程能正确地访问共享内存中的数据。

实验一操作系统Windows“任务管理器”的进程管理

实验一操作系统Windows“任务管理器”的进程管理

3.1 Windows“任务管理器”的进程管理(实验估计时间:60分钟)➢➢背景知识➢➢实验目的➢➢工具/准备工作➢➢实验内容与步骤背景知识Windows 2000的任务管理器提供了用户计算机上正在运行的程序和进程的相关信息,也显示了最常用的度量进程性能的单位。

使用任务管理器,可以打开监视计算机性能的关键指示器,快速查看正在运行的程序的状态,或者终止已停止响应的程序。

也可以使用多个参数评估正在运行的进程的活动,以及查看CPU 和内存使用情况的图形和数据。

其中:1) “应用程序”选项卡显示正在运行程序的状态,用户能够结束、切换或者启动程序。

2) “进程”选项卡显示正在运行的进程信息。

例如,可以显示关于CPU 和内存使用情况、页面错误、句柄计数以及许多其他参数的信息。

3) “性能”选项卡显示计算机动态性能,包括CPU 和内存使用情况的图表,正在运行的句柄、线程和进程的总数,物理、核心和认可的内存总数(KB) 等。

实验目的通过在Windows 任务管理器中对程序进程进行响应的管理操作,熟悉操作系统进程管理的概念,学习观察操作系统运行的动态性能。

工具/准备工作在开始本实验之前,请回顾教科书的相关内容。

需要准备一台运行Windows 2000 Professional操作系统的计算机。

实验内容与步骤1. 使用任务管理器终止进程2. 显示其他进程计数器3. 更改正在运行的程序的优先级启动并进入Windows环境,单击Ctrl + Alt + Del键,或者右键单击任务栏,在快捷菜单中单击“任务管理器”命令,打开“任务管理器”窗口。

在本次实验中,你使用的操作系统版本是:_windowsXP当前机器中由你打开,正在运行的应用程序有:1)实验一-microsoft word2)操作系统电子书3) Microsoft word_4) _ftp://172.16.20.168/_5) __百度搜索—-qq空间-windows internet__Windows“任务管理器”的窗口由__4___个选项卡组成,分别是:1) 应用程序__2) __进程_____3) __性能4)联网当前“进程”选项卡显示的栏目分别是(可移动窗口下方的游标/箭头,或使窗口最大化进行观察) :1) ___SGTool.exe_____________________________________________________2) __SogouCloud.exe__________________________________________________3) ___taskmgr.exe______________________________________________4) ____alg.exe_____________________________________________________5) _____ass.exe_______________________________________________________6) ________comine.exe________________________________________________7) ___jqs.exe_________________________________________________________8) ______LMS.exe____________________________________________________1. 使用任务管理器终止进程步骤1:单击“进程”选项卡,一共显示了__40____个进程。

《操作系统》课程实验报告

《操作系统》课程实验报告

《操作系统》课程实验报告一、实验目的本次《操作系统》课程实验的主要目的是通过实际操作和观察,深入理解操作系统的工作原理、进程管理、内存管理、文件系统等核心概念,并掌握相关的操作技能和分析方法。

二、实验环境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)观察并分析在不同的并发情况下,系统的运行结果和资源竞争情况。

进程管理实验报告

进程管理实验报告

进程管理实验报告进程管理实验报告引言:进程管理是操作系统中的重要概念,它负责调度和控制计算机系统中的各个进程,确保它们能够有序地执行。

本实验旨在通过实际操作和观察,深入了解进程管理的原理和方法,并通过实验结果分析其影响因素和优化策略。

实验一:进程创建与终止在本实验中,我们首先进行了进程的创建和终止实验。

通过编写简单的程序,我们能够观察到进程的创建和终止过程,并了解到进程控制块(PCB)在其中的作用。

实验结果显示,当一个进程被创建时,操作系统会为其分配一个唯一的进程ID,并为其分配必要的资源,如内存空间、文件描述符等。

同时,操作系统还会为该进程创建一个PCB,用于存储该进程的相关信息,如进程状态、程序计数器等。

当我们手动终止一个进程时,操作系统会释放该进程所占用的资源,并将其PCB从系统中删除。

这样,其他进程便可以继续使用这些资源,提高系统的效率和资源利用率。

实验二:进程调度算法进程调度算法是决定进程执行顺序的重要因素。

在本实验中,我们通过模拟不同的进程调度算法,比较它们在不同场景下的表现和效果。

我们选择了三种常见的进程调度算法:先来先服务(FCFS)、最短作业优先(SJF)和轮转调度(RR)。

通过设置不同的进程执行时间和优先级,我们观察到不同调度算法对系统吞吐量和响应时间的影响。

实验结果显示,FCFS算法适用于执行时间较短的进程,能够保证公平性,但在执行时间较长的进程出现时,会导致等待时间过长,影响系统的响应速度。

SJF 算法在执行时间较长的进程时表现出色,但对于执行时间较短的进程,可能会导致饥饿现象。

RR算法能够在一定程度上平衡各个进程的执行时间,但对于执行时间过长的进程,仍然会影响系统的响应速度。

实验三:进程同步与互斥在多进程环境中,进程之间的同步和互斥是必不可少的。

在本实验中,我们通过模拟进程间的竞争和互斥关系,观察进程同步与互斥的实现方式和效果。

我们选择了信号量机制和互斥锁机制作为实现进程同步和互斥的方法。

操作系统实验之进程管理实验报告

操作系统实验之进程管理实验报告

操作系统实验之进程管理实验报告一、实验目的本次操作系统实验的主要目的是深入理解进程管理的概念和原理,通过实际操作和观察,掌握进程的创建、调度、同步与互斥等关键机制。

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

三、实验内容1、进程创建使用系统提供的 API 函数创建新的进程。

观察新进程的资源使用情况和运行状态。

2、进程调度编写程序模拟不同的进程调度算法,如先来先服务(FCFS)、短作业优先(SJF)和时间片轮转(RR)。

比较不同调度算法下的平均周转时间、平均等待时间等性能指标。

3、进程同步与互斥利用信号量、互斥锁等机制实现进程之间的同步与互斥。

设计并发程序,解决生产者消费者问题、读写者问题等经典同步问题。

四、实验步骤1、进程创建实验首先,包含所需的头文件,如`<windowsh>`。

然后,定义创建进程的函数,使用`CreateProcess` 函数创建新进程,并获取进程的相关信息,如进程标识符、线程标识符等。

最后,通过查看任务管理器或其他系统工具,观察新创建进程的资源占用情况。

2、进程调度实验设计不同的调度算法函数,如`FCFSSchedule`、`SJFSchedule` 和`RRSchedule`。

在每个调度算法函数中,模拟进程的到达时间、服务时间等参数,并按照相应的算法进行进程调度。

计算每个进程的周转时间和等待时间,并求出平均周转时间和平均等待时间。

3、进程同步与互斥实验定义信号量或互斥锁变量。

在生产者消费者问题中,生产者在生产产品时获取互斥锁,生产完成后释放互斥锁并通知消费者;消费者在消费产品时获取互斥锁,消费完成后释放互斥锁。

在读写者问题中,读者在读取数据时获取共享锁,读完后释放共享锁;写者在写入数据时获取独占锁,写入完成后释放独占锁。

五、实验结果与分析1、进程创建实验结果成功创建新的进程,并能够获取到进程的相关信息。

实验一操作系统Windows“任务管理器”的进程管理

实验一操作系统Windows“任务管理器”的进程管理

3.1 Windows“任务管理器”的进程管理(实验估计时间:60分钟)➢➢背景知识➢➢实验目的➢➢工具/准备工作➢➢实验内容与步骤背景知识Windows 2000的任务管理器提供了用户计算机上正在运行的程序和进程的相关信息,也显示了最常用的度量进程性能的单位。

使用任务管理器,可以打开监视计算机性能的关键指示器,快速查看正在运行的程序的状态,或者终止已停止响应的程序。

也可以使用多个参数评估正在运行的进程的活动,以及查看CPU 和内存使用情况的图形和数据。

其中:1) “应用程序”选项卡显示正在运行程序的状态,用户能够结束、切换或者启动程序。

2) “进程”选项卡显示正在运行的进程信息。

例如,可以显示关于CPU 和内存使用情况、页面错误、句柄计数以及许多其他参数的信息。

3) “性能”选项卡显示计算机动态性能,包括CPU 和内存使用情况的图表,正在运行的句柄、线程和进程的总数,物理、核心和认可的内存总数(KB) 等。

实验目的通过在Windows 任务管理器中对程序进程进行响应的管理操作,熟悉操作系统进程管理的概念,学习观察操作系统运行的动态性能。

工具/准备工作在开始本实验之前,请回顾教科书的相关内容。

需要准备一台运行Windows 2000 Professional操作系统的计算机。

实验内容与步骤1. 使用任务管理器终止进程2. 显示其他进程计数器3. 更改正在运行的程序的优先级启动并进入Windows环境,单击Ctrl + Alt + Del键,或者右键单击任务栏,在快捷菜单中单击“任务管理器”命令,打开“任务管理器”窗口。

在本次实验中,你使用的操作系统版本是:_windowsXP当前机器中由你打开,正在运行的应用程序有:1)实验一-microsoft word2)操作系统电子书3) Microsoft word_4) _ftp://172.16.20.168/_5) __百度搜索—-qq空间-windows internet__Windows“任务管理器”的窗口由__4___个选项卡组成,分别是:1) 应用程序__2) __进程_____3) __性能4)联网当前“进程”选项卡显示的栏目分别是(可移动窗口下方的游标/箭头,或使窗口最大化进行观察) :1) ___SGTool.exe_____________________________________________________2) __SogouCloud.exe__________________________________________________3) ___taskmgr.exe______________________________________________4) ____alg.exe_____________________________________________________5) _____ass.exe_______________________________________________________6) ________comine.exe________________________________________________7) ___jqs.exe_________________________________________________________8) ______LMS.exe____________________________________________________1. 使用任务管理器终止进程步骤1:单击“进程”选项卡,一共显示了__40____个进程。

操作系统实验(模拟进程管理)

操作系统实验(模拟进程管理)

操作系统实验————(1)模拟进程管理专业:信息管理与信息系统班级:信管082姓名:温静实验一进程管理1.目的和要求通过实验理解进程的概念,进程的组成(PCB结构),进程的并发执行和操作系统进行进程管理的相关原语(主要是进程的创建、执行、撤消)。

2.实验内容用C语言编程模拟进程管理,至少要有:创建新的进程;查看运行进程;换出某个进程;杀死运行进程以及进程之间通信等功能。

3.主体程序#include <conio.h>#include <stdio.h>#include <stdlib.h>struct PCB_type{ int pid;int priority;int cputime;int state;int shumu=0,pid_l;struct PCB_type neicun[20];struct PCB_type hc[10];int max=0;int number=0;void create();void run();void huanchu();void kill();/* 创建新进程*/void create(){if(shumu>=20){printf("\n内存已满,请先结束或换出进程\n");}else{shumu++;printf("\n请输入新进程的程序名\n");scanf("%d",&neicun[shumu-1].pid);printf("\n请输入新进程的优先级\n");scanf("%d",&neicun[shumu-1].priority);printf("\n请输入新进程的运行时间\n");scanf("%d",&neicun[shumu-1].cputime);printf("\n创建进程时令其状态为就绪\n");neicun[shumu-1].state=2;}printf("\n创建进程成功!\n");}/* 查看当前运行进程*/void run(){int max=0;for(int i=0;i<shumu;i++){if((neicun[i].state==1)&&(neicun[i].priority>=neicun[max].priority)) max=i;}neicun[max].state=3;printf("当前运行进程程序名:\n%d",neicun[max].pid);printf("\n该进程的优先级:\n%d",neicun[max].priority);printf("\n该进程的运行时间:\n%d",neicun[max].cputime);printf("\n该进程的状态:\n%d",neicun[max].state);}/* 换出*/void huanchu(){int k;printf("请输入要换出程序的程序名:");scanf("%d",&k);for(int j=0;j<shumu;j++){if(neicun[j].state==1){hc[number].pid=neicun[j].pid;hc[number].state=neicun[j].state;hc[number].priority=neicun[j].priority;hc[number].cputime=neicun[j].cputime;number++;neicun[j].pid=0;neicun[j].state=0;neicun[j].priority=0;neicun[j].cputime=0;pid_1++;}else printf("进程%d无法换出的pid:%d\n",j.neicun[j].pid);if(number!=0)for(int i=0;i<number;i++){printf("当前运行进程程序名:\n%d",hc[i].pid);printf("\n该进程的优先级:\n%d",hc[i].priority);printf("\n该进程的运行时间:\n%d",hc[i].cputime);printf("\n该进程的状态:\n%d",hc[i].state);}}PCB_type temp=neicun[0];for(k=0;k<=shumu;k++){if(neicun[k].priority>temp.priority)tmpe=neicun[k];}neicun[k].state=1;}/* 杀死进程*/void kill(){neicun[max].pid=0;neicun[max].priority=0;neicun[max].cputime=0;neicun[max].state=0;if(max==(shumu-1))shumu--;else{for(int j=max+1;j<shumu;j++){neicun[j-1].pid=neicun[j].pid;neicun[j-1].priority=neicun[j].priority;neicun[j-1].cputime=neicun[j].cputime;neicun[j-1].state=neicun[j].state;}shumu--;}max=0;run();}/* int k=0;printf("请输入要杀死程序的进程名:");scanf("%d",&k);if(neicun[k].state=1)neicun[k].state=2;neicun[k].cputime=0;neicun[k].pid=0;neicun[k].priority=0;neicun[k].state=0;if(k==(shumu-1))shumu--;else{for(int j=k+1;j<shumu;j++){neicun[j-1].pid=neicun[j].pid;neicun[j-1].priority=neicun[j].priority;neicun[j-1].cputime=neicun[j].cputime;neicun[j-1].state=neicun[j].state;}shumu--;}printf("进程%d已被杀死!,k");}*/int main(){int n,a;n=1;while(n==1){system("cls");printf("\n**********************************************");printf("\n* 进程演示系统*");printf("\n**********************************************");printf("\n 1.创建新的进程 2.查看运行进程");printf("\n 3.换出某个进程 4.杀死运行进程");printf("\n 5.退出系统");printf("\n**********************************************");printf("\n请选择(1~5):");scanf("%d",&a);switch(a){ case 1:create( );printf("\npress anykey to go on~");getch();break;case 2 :run();printf("\npress anykey to go on~");getch();break;case 3 :huanchu();printf("\npress anykey to go on~");getch();break;case 4 :kill();printf("\npress anykey to go on~");getch();break;case 5 :exit(0);default:n=0;break;}}}5.感想与心得体会做了两周的实验,问了很多同学,可程序还是有很多问题。

实验进程管理实验报告

实验进程管理实验报告

一、实验目的1. 加深对进程概念的理解,明确进程和程序的区别。

2. 进一步认识并发执行的实质,理解进程的创建、调度、同步与通信。

3. 学习使用Linux系统中的进程管理命令,掌握进程的监控、控制与优化。

二、实验环境操作系统:Linux Ubuntu 20.04实验工具:终端(Terminal)、shell命令三、实验内容1. 进程的基本概念与特性2. 进程的创建与调度3. 进程同步与通信4. 进程的监控与优化四、实验步骤1. 进程的基本概念与特性(1)通过阅读相关资料,了解进程的概念、特性和生命周期。

(2)使用shell命令查看当前系统中进程的状态,如ps、top、htop等。

2. 进程的创建与调度(1)使用fork()函数创建进程,观察父子进程之间的关系。

(2)使用exec()函数替换子进程的映像,实现进程的创建。

(3)使用wait()、waitpid()等函数等待子进程结束,控制进程执行顺序。

(4)通过修改进程优先级,观察进程调度策略的变化。

3. 进程同步与通信(1)使用互斥锁(mutex)实现进程同步,防止数据竞争。

(2)使用条件变量(condition variable)实现进程间的条件同步。

(3)使用信号量(semaphore)实现进程间的同步与通信。

(4)通过管道(pipe)、消息队列(message queue)、共享内存(shared memory)等机制实现进程间的通信。

4. 进程的监控与优化(1)使用ps、top、htop等命令监控进程的运行状态。

(2)通过调整进程优先级,优化进程的执行顺序。

(3)使用renice命令调整进程的实时性。

(4)使用nice命令调整进程的调度策略。

五、实验结果与分析1. 进程的基本概念与特性通过实验,我们了解到进程是具有一定独立功能的程序关于某个数据集合的一次运行活动,具有并发性、动态性、独立性、异步性和结构特征等特性。

2. 进程的创建与调度实验过程中,我们成功创建了多个进程,并通过修改进程优先级,观察到调度策略的变化。

操作系统实验报告 实验一 进程管理

操作系统实验报告  实验一  进程管理

实验一进程管理一、目的进程调度是处理机管理的核心内容..本实验要求编写和调试一个简单的进程调度程序..通过本实验加深理解有关进程控制块、进程队列的概念;并体会和了解进程调度算法的具体实施办法..二、实验内容及要求1、设计进程控制块PCB的结构PCB结构通常包括以下信息:进程名进程ID、进程优先数、轮转时间片、进程所占用的CPU时间、进程的状态、当前队列指针等..可根据实验的不同;PCB结构的内容可以作适当的增删..为了便于处理;程序中的某进程运行时间以时间片为单位计算..各进程的轮转时间数以及进程需运行的时间片数的初始值均由用户给定..2、系统资源r1…r w;共有w类;每类数目为r1…r w..随机产生n进程P i id;s j;k;t;0<=i<=n;0<=j<=m;0<=k<=dt为总运行时间;在运行过程中;会随机申请新的资源..3、每个进程可有三个状态即就绪状态W、运行状态R、等待或阻塞状态B;并假设初始状态为就绪状态..建立进程就绪队列..4、编制进程调度算法:时间片轮转调度算法本程序用该算法对n个进程进行调度;进程每执行一次;CPU时间片数加1;进程还需要的时间片数减1..在调度算法中;采用固定时间片即:每执行一次进程;该进程的执行时间片数为已执行了1个单位;这时;CPU时间片数加1;进程还需要的时间片数减1;并排列到就绪队列的尾上..三、实验环境操作系统环境:Windows系统..编程语言:C..四、实验思路和设计1、程序流程图2、主要程序代码//PCB结构体struct pcb{public int id; //进程IDpublic int ra; //所需资源A的数量public int rb; //所需资源B的数量public int rc; //所需资源C的数量public int ntime; //所需的时间片个数public int rtime; //已经运行的时间片个数public char state; //进程状态;W等待、R运行、B阻塞//public int next;}ArrayList hready = new ArrayList;ArrayList hblock = new ArrayList;Random random = new Random;//ArrayList p = new ArrayList;int m; n; r; a;a1; b;b1; c;c1; h = 0; i = 1; time1Inteval;//m为要模拟的进程个数;n为初始化进程个数//r为可随机产生的进程数r=m-n//a;b;c分别为A;B;C三类资源的总量//i为进城计数;i=1…n//h为运行的时间片次数;time1Inteval为时间片大小毫秒//对进程进行初始化;建立就绪数组、阻塞数组..public void input//对进程进行初始化;建立就绪队列、阻塞队列{m = int.ParsetextBox4.Text;n = int.ParsetextBox5.Text;a = int.ParsetextBox6.Text;b = int.ParsetextBox7.Text;c = int.ParsetextBox8.Text;a1 = a;b1 = b;c1 = c;r = m - n;time1Inteval = int.ParsetextBox9.Text;timer1.Interval = time1Inteval;for i = 1; i <= n; i++{pcb jincheng = new pcb;jincheng.id = i;jincheng.ra = random.Nexta + 1;jincheng.rb = random.Nextb + 1;jincheng.rc = random.Nextc + 1;jincheng.ntime = random.Next1; 5;listBox1.Items.Add"产生进程ID:" + jincheng.id;listBox1.Items.Add"所需A资源数目:" + jincheng.ra;listBox1.Items.Add"所需B资源数目:" + jincheng.rb;listBox1.Items.Add"所需C资源数目:" + jincheng.rc;listBox1.Items.Add"所需时间片数:" + jincheng.ntime;if a - jincheng.ra >= 0 && b - jincheng.rb >= 0 && c - jincheng.rc >= 0{a = a - jincheng.ra;b = b - jincheng.rb;c = c - jincheng.rc;jincheng.state = 'W';hready.Addjincheng;//加入就绪队列}else{jincheng.state = 'B';hblock.Addjincheng;//加入阻塞队列}listBox1.Items.Add"当前进程状态:" + jincheng.state;}}//从数组起始地址开始输出该数组的内容public void dispArrayList list{ArrayList list1 = new ArrayList;list1 = list;if list1.Count > 0{for int j = 0; j < list1.Count; j++{pcb p = pcblist1j;listBox1.Items.Add" " + p.id.ToString + " " + p.state.ToString + " " + p.ra.ToString + " " + p.rb.ToString + " " + p.rc.ToString+" " + p.ntime.ToString + " " + p.rtime.ToString + " \r\n";}}else{listBox1.Items.Add"\r\n\t 该队列中没有进程\r\n";}}//输出就绪数组和阻塞数组的信息public void outputall{listBox1.Items.Add"当前就绪队列的信息";listBox1.Items.Add"进程ID 进程状态A资源数B资源数C资源数所需时间片已运行时间片";disphready;listBox1.Items.Add"当前就阻塞列的信息";listBox1.Items.Add"进程ID 进程状态A资源数B资源数C资源所需时间片已运行时间片";disphblock;}//运行就绪数组的头进程;运行一个时间片;轮转一个时间片;时间片轮转调度算法public void running{ArrayList hready1 = new ArrayList;hready1 = hready;pcb p1 = new pcb;p1=pcbhready10;p1.state='R';p1.rtime= p1.rtime + 1;h=h+1;listBox1.Items.Add"\r\n~~~~~~~当前正在运行进程ID是:" +p1.id + "~~~~~~~~\r\n";listBox1.Items.Add"\r\n进程ID 进程状态A资源数B资源数C资源数所需时间片已运行时间片\r\n";listBox1.Items.Addp1.id + " " +p1.state+ " " + p1.ra + " " + p1.rb + " " + p1.rc + " " + p1.ntime + " " + p1.rtime;if p1.ntime==p1.rtime{listBox1.Items.Addp1.id.ToString+"的进程已经完成\r\n";a = a + p1.ra;b = b + p1.rb;c = c + p1.rc;hready.RemoveAt0;}else{p1.state='W';hready1.Addp1;hready.RemoveAt0;}}//检测当前资源数目是否满足阻塞数组里进程的需求public void testblock{ArrayList hblock1 = new ArrayList;hblock1 = hblock;for int m = 0; m < hblock1.Count; m++{p1 = pcbhblock1m;if a - p1.ra >= 0 && b - p1.rb >= 0 && c - p1.rc >= 0{p1.state='W';hready.Addp1;a = a - p1.ra;b = b - p1.rb;c = c - p1.rc;listBox1.Items.Add"ID号为:"+p1.id + "的进程由阻塞队列转入就绪队列~~\r\n";hblock.RemoveAtm;m--;}}}//检测是否有新的进程产生;随机产生新进程public void testnew{int t;if r>0//r为随机产生的进程数目{t = random.Next9 + 1;if t <= 7{listBox1.Items.Add"\r\n有新的进程申请加入:~~";pcb jincheng = new pcb;jincheng.id = i++;jincheng.ra = random.Nexta + 1;jincheng.rb = random.Nextb + 1;jincheng.rc = random.Nextc + 1;jincheng.ntime = random.Next1; 5;jincheng.rtime = 0;listBox1.Items.Add"产生进程ID:" + jincheng.id;listBox1.Items.Add"所需A资源数目:" + jincheng.ra;listBox1.Items.Add"所需B资源数目:" + jincheng.rb;listBox1.Items.Add"所需C资源数目:" + jincheng.rc;listBox1.Items.Add"所需时间片数:" + jincheng.ntime;if a - jincheng.ra >= 0 && b - jincheng.rb >= 0 && c - jincheng.rc >= 0{a = a - jincheng.ra;b = b - jincheng.rb;c = c - jincheng.rc;jincheng.state = 'W';listBox1.Items.Add"进程状态为:" + jincheng.state;hready.Addjincheng;//加入就绪队列listBox1.Items.Add"资源满足新进程请求;该进程进入就绪队列~~\r\n";else{jincheng.state = 'B';hblock.Addjincheng;//加入阻塞队列listBox1.Items.Add"进程状态为:" + jincheng.state;listBox1.Items.Add"资源不满足新进程请求;该进程进入阻塞队列~~\r\n";}}}r = r - 1;}//系统三类资源变化情况的显示public void rescore//系统三类资源变化情况的显示{if a > a1 { textBox1.Text = a1.ToString; }if a < 0 { textBox1.Text = "0"; }if a >= 0 && a < a1 { textBox1.Text = a.ToString; }if b > b1 { textBox2.Text = b1.ToString; }if b < 0 { textBox2.Text = "0"; }if b >= 0 && b <= b1 { textBox2.Text = b.ToString; }if c > c1 { textBox3.Text = c1.ToString; }if c < 0 { textBox3.Text = "0"; }if c >= 0 && c <= c1 { textBox3.Text = c.ToString; }}//时间片轮转调度算法先来先服务FCFS算法public void runFcfs{if hready.Count>0{outputall;running;testblock;testnew;rescore;}else{timer1.Enabled = false;textBox1.Text = a1.ToString;textBox2.Text = b1.ToString;textBox3.Text = c1.ToString;listBox1.Items.Add"\r\n<<<<<<<<所有进程都已经运行结束>>>>>>>~\r\n";}//计时器触发时间片轮转调度算法private void timer1_Tickobject sender; EventArgs erunFcfs;}//开始模拟按钮单击执行函数private void button1_Clickobject sender; EventArgs e {runmain;button1.Enabled = false;textBox1.Enabled = false;textBox2.Enabled = false;textBox3.Enabled = false;textBox4.Enabled = false;textBox5.Enabled = false;textBox6.Enabled = false;textBox7.Enabled = false;textBox8.Enabled = false;textBox9.Enabled = false;}//清除屏幕按钮单击执行函数private void button2_Clickobject sender; EventArgs e {textBox1.Text = "";textBox2.Text = "";textBox3.Text = "";textBox4.Text = "";textBox5.Text = "";textBox6.Text = "";textBox7.Text = "";textBox8.Text = "";textBox9.Text = "";listBox1.Items.Clear;textBox4.Enabled = true;textBox5.Enabled = true;textBox6.Enabled = true;textBox7.Enabled = true;textBox8.Enabled = true;textBox9.Enabled = true;button1.Enabled = true;}//运行的主函数public void runmain{input;imer1.Enabled = true;3、运行界面和运行结果界面中;可以任意设定需要模拟的进程总数如5;初始化进程个数如3;还有A、B、C三类资源的总数如10、10、10..为了方便显示;还可以设定时间片的长度如500毫秒..除此之外;在运行过程中;所有的资源都是随机生成的;并且其中新进程的产生也是随机的;但是产生的进程总数不会多于开始设定的模拟的进程总数;以防止不断产生新进程;程序不断运行..在显示窗口的上方;还会实时显示资源的变化情况;方便对运行的观察..当运行结束后;可以通过工具栏中的显示选项中的保存结果按钮;将结果保存成txt文件格式;方便运行后的结果分析..五、心得体会本次实验;我的任务是设计一个允许n个进程并发运行的进程管理模拟系统..该系统包括有简单的进程控制、同步与通讯机构;系统在运行过程中能显示各进程的状态及有关参数的变化情况;从而观察诸进程的运行过程及系统的管理过程;我是用C写的;在我的电脑能够运行通过;虽不能尽善尽美;但也基本能实现老师的要求..两个星期的实验;虽然时间有点短;但我也收获不少;这次实验;加深了我对进程概念及进程管理的理解;比较熟悉进程管理中主要数据结构的设计及进程调度算法、进程控制机构、同步机构及通讯机构的实施..也让我认识到自己的不足;操作系统的有些知识;我知道的还不多;没有掌握好;还需要多多学学;不断提升自己的能力..实验中;我们小组分工合作;共同学习;虽然在实验中遇到了一些问题;但在老师和同学的细心指导和热心帮助下解决了..同时;了解到团队精神的重要性;也为以后的学习和工作打下了坚实的基础;同时积累了宝贵的经验..。

操作系统原理实验

操作系统原理实验

操作系统原理实验操作系统是计算机系统中最核心的部分之一,它负责管理和控制计算机的硬件和软件资源,为用户提供一个良好的工作环境。

操作系统原理实验是计算机相关专业的学生必修课程之一,通过实验学习,可以更深入地理解操作系统的原理和工作机制,提高对操作系统的理解和应用能力。

实验一,进程管理。

进程是操作系统中最基本的概念之一,它是程序执行的基本单位。

在进程管理实验中,我们可以学习到进程的创建、调度、同步和通信等内容。

通过编写程序模拟进程的创建和调度过程,可以更直观地理解操作系统是如何管理进程的。

实验二,内存管理。

内存管理是操作系统中的重要内容之一,它负责管理计算机的内存资源,包括内存的分配与回收、内存的保护和共享等。

在内存管理实验中,我们可以学习到内存分配算法、地址转换技术以及虚拟内存的实现原理。

通过编写程序模拟内存分配和回收的过程,可以更好地理解操作系统是如何管理内存的。

实验三,文件系统。

文件系统是操作系统中负责管理存储设备上的文件和目录的部分,它提供了对文件的读写和管理功能。

在文件系统实验中,我们可以学习到文件的组织结构、文件的存储管理和文件的访问控制等内容。

通过编写程序模拟文件的创建、读写和删除过程,可以更深入地理解操作系统是如何管理文件系统的。

实验四,设备管理。

设备管理是操作系统中负责管理计算机硬件设备的部分,它包括对设备的初始化、分配和释放等功能。

在设备管理实验中,我们可以学习到设备的管理方法、设备的中断处理和设备的驱动程序设计等内容。

通过编写程序模拟设备的初始化和中断处理过程,可以更好地理解操作系统是如何管理设备的。

总结。

通过操作系统原理实验的学习,我们可以更深入地理解操作系统的原理和工作机制,提高对操作系统的理解和应用能力。

同时,实验还可以培养我们的动手能力和解决问题的能力,为今后从事计算机相关工作打下坚实的基础。

希望大家能够认真对待操作系统原理实验,取得更好的学习成绩,为将来的发展打下坚实的基础。

进程管理_实验报告

进程管理_实验报告

一、实验目的1. 理解Linux操作系统中进程的概念,明确进程与程序的区别。

2. 掌握Linux下进程的创建、调度、同步与通信等基本操作。

3. 学会使用Linux命令查看和管理进程。

二、实验环境1. 操作系统:Linux2. 编程语言:C/C++3. 开发工具:gcc、gdb三、实验内容1. 进程创建与调度2. 进程同步与互斥3. 进程通信4. 进程控制四、实验步骤1. 进程创建与调度(1)编写一个C程序,创建一个子进程,并在父进程中打印出子进程的进程标识符(PID)。

```c#include <stdio.h>#include <unistd.h>#include <sys/types.h>int main() {pid_t pid;pid = fork(); // 创建子进程if (pid == 0) { // 子进程printf("子进程的PID:%d\n", getpid());} else if (pid > 0) { // 父进程printf("父进程的PID:%d,子进程的PID:%d\n", getpid(), pid); } else {printf("创建子进程失败\n");}return 0;}```(2)编译并运行程序,观察结果。

2. 进程同步与互斥(1)编写一个C程序,使用互斥锁(mutex)实现两个进程的同步。

```c#include <stdio.h>#include <stdlib.h>#include <pthread.h>pthread_mutex_t mutex;void thread_func(void arg) {pthread_mutex_lock(&mutex); // 获取互斥锁printf("线程 %ld 获取了互斥锁\n", pthread_self());sleep(1);pthread_mutex_unlock(&mutex); // 释放互斥锁return NULL;}int main() {pthread_t thread1, thread2;pthread_mutex_init(&mutex, NULL); // 初始化互斥锁pthread_create(&thread1, NULL, thread_func, (void )1);pthread_create(&thread2, NULL, thread_func, (void )2);pthread_join(thread1, NULL);pthread_join(thread2, NULL);pthread_mutex_destroy(&mutex); // 销毁互斥锁return 0;}```(2)编译并运行程序,观察结果。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验一
【实验目的】
1、加深对进程概念的理解,明确进程和程序的区别;
2、进一步认识并发执行的实质;
3、分析进程争用资源的现象,学习解决进程互斥的方法;
【实验环境】
编程环境:
操作系统软件:
【准备知识】
1.
1、进程的概念;进程与程序的区别。
2、并发执行的概念。
3、进程互斥的概念。
2.
系统调用是一种进入系统空间的办法。通常,在OS的核心中都设置了一组用于实现各
着执行的不同而发生变化。这与打印单字符的结果相同。
2.
修改已编写的程序,将每个进程输出一个字符改为每个进程输出一句话,在观察程序执行
时屏幕上岀现的现象,并分析原因。)
编写一段程序,使用系统调用fork()来创建两个子进程,并由父进程重复显示字符串:
“pare nt:”和自己的标识数,而子进程则重复显示字符串“child: ”和自己的标识数。
结束状态。
其调用格式为:#in elude<>
void exit(i nt status);
其中status为进程结束状态。
4
\kill()函数用于删除执行中的程序或者任务。
其调用格式为:kill(i nt PID,i nt IID);
其中:PID是要被杀死的进程号,IID为向将被杀死的进程发送的中断号。
#in clude<>
#in clude<>
main ()
{\
int p1,p2;
while((p 1=fork())==-1);
if(p1==0)
printf("child's pid=%d \n",getppid());
else
{
\while((p2=fork())==-1);
if(p2==0)
pare nt's pid=3224
[root@localh ost ~]# child 2's pid=1 ./lsj
统调用与之不同的是Linux由于内核代码完全公开,所以可以细致的分析出其系统调用的机 制。
3.
1
fork()函数创建一个新进程。
其调用格式为:int fork();
其中返回int取值意义如下:
正确返回: 等于0:创建子进程,从子进程返回的ID值;
大于0:从父进程返回的子进程的进程ID值。
11
错误返回:等于一1创建失败。
关于Linux下的C语言编程
1)编辑器可使用vi
2)编译器使用gee
格式:gee optio n file name
例如:gee -o main
主要的option
-o指定输出文件名(不指定则生成默认文件)
其它的参数见帮助(man gee)
【实验内容和步骤】
1
编写一段程序,使用系统调用fork()创建两个子进程。当此程序运行时,在系统
printf("child's pid=%d \n",getppid());
else printf("parent's pid=%d \n”,getppid());
}
}
结果:
[root@localhost ~]# gcc -o lsj
[root@localhost ~]# ./lsj
child 1's pid=4852
中有一个父进程和两个子进程活动。让每个进程在屏幕上显示一个字符,父显示"a",
子进程分别显示“b”和“c”,观察记录显示结果,并分析原因。
#in clude<>
main()
{
in t p1,p2;
while((p 1=fork())= =-1);
if(p1==0)
putchar('b');
else
{
while((p2=fork())==-1);
if(p2= =0)
putchar('c');
else putchar('a');
}
}
运行
运行结果:root@localhost ~]# gcc -o lsj
[root@localhost ~]# ./lsj
bca[root@localhost ~]# ./lsj
child 2's pid=4852
pare nt's pid=3224
[root@localhost ~]# ./lsj
child1's pid=4903
child 2's pid=4903
pare nt's pid=3224
[root@localhost ~]# ./Isj/
child 1's pid=4918
ca[root@localhost ~]# b
分析原因:①从进程并发执行来看,各种情况都有可能。上面的三个进程没有同步措施,
所以父进程与子进程的输出内容会叠加在一起。输出次序带有随机性。
②由于函数printf()在输出字符串时不会被中断,因此,字符串内部字符顺序输出不变。
但由于进程并发执行的调度顺序和父子进程抢占处理机问题,输出字符串的顺序和先后随
bca[root@localhost ~]# ./lsj
bca[root@localhost ~]# ./lsj
ba[root@localhost Nhomakorabea~]# c./lsj/
bca[root@localhost ~]# ./lsj
bca[root@localhost ~]# ./lsj
bca[root@localhost ~]# ./lsj
2
wait()函数常用来控制父进程与子进程的同步。在父进程中调用wait()函数,则
父进程被阻塞,进入等待队列,等待子进程结束。当子进程结束时,会产生一个终止 状态字,系统会向父进程发出SIGCHLD言号。当接到信号后,父进程提取子进程的终
止状态字,从wait()函数返回继续执行原程序。
其调用格式为:#i nclude <sys/>
#i nclude <sys/>
/(pid_t) wait(i nt *statloc);
正确返回:大于0:子进程的进程ID值;
/等于0:其它。
错误返回:等于一1调用失败。
3
exit()函数是进程结束最常调用的函数,在main()函数中调用return,最终也
是调用exit()函数。这些都是进程的正常终止。在正常终止时,exit()函数返回进程
种系统功能的子程序,并将它们提供给程序员调用。程序员在需要OS提供某种服务的时候, 便可以调用一条系统调用命令,去实现希望的功能,这就是系统调用。因此,系统调用就像
一个黑箱子一样,对用户屏蔽了操作系统的具体动作而只是控制程序的执行速度等。各个不
同的操作系统有各自的系统调用,女口windows API,便是windows的系统调用,Linux的系
相关文档
最新文档