下载文档原格式
操作系统实验报告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、编译并运行程序，通过任务管理器观察进程的运行状态和资源占用情况。
《操作系统》课程实验报告专业：软件工程班级：软件二班学号： 2220111350 姓名：韩培培序号： 14目录：实验一、进程的创建实验二、进程控制实验三、进程的管道通信实验四、消息通信实验五、进程调度实验六、FIFO页面调度实验七、LRU页面置换算法实验一进程的创建一．实验目的：进程的创建二．实验内容：编写一段程序，使用系统调用 FORK( )创建两个子进程。
当此程序运行时，在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示一个字符：父进程显示字符“A”子进程分别显示字符“B”和“C”。
试观察记录屏幕上的显示结果，并分析原因。
三．实验代码：#include ＜stdio.h＞Main(){ int p1,p2；While((p1=fork())==-1)；If (p1==0)Putchar(ˊbˊ)；else{While((p2=fork())==-1)；If(p2==0)Putchar(ˊcˊ)；else putchar(ˊaˊ)；}}四．实验运行结果五．分析原因程序首先调用Fork（）函数创建一个子进程1.当创建进程不成功，循环创建进程，直至进程创建成功。
如果Fork（）返回值为0，表示当前进程是子进程1，显示字符B。
如果Fork（）返回值大于0，则表示当前进程是父进程，表示当前的程序代码是父进程所要执行的。
父进程调用Fork（）创建子进程2。
当创建进程不成功时，循环创建进程直至成功。
如果Fork（）返回值为0，则表示当前进程是子进程2，显示字符C。
如果Fork（）返回值大于0，则表示当前进程是父进程，输出字符A。
实验二：进程控制一．实验目的：进程控制二．实验内容：修改已编写的程序，将每个进程的输出由单个字符改为一个字符串，再观察程序的执行时屏幕上出现的现象，并分析原因三．实验代码：# include＜stdio.h＞Main(){ int p1,p2,i;While((p1=fork())== -1);If (p1 == 0)For (i=0;i<500;i++)Printf(＂child %d/n＂,i);else{While((p2 =fork()) == -1);if(p2 == 0)for (i= 0;i<500;i++)printf(＂son%d\n＂,i)elsefor(i = 0;i<500;i++)printf(＂daughter%d\n＂,i);}}四．分析原因：由于函数Printf()输出的字符串之间不会被中断，因此，字符串内部的字符顺序输出时不变。
一、实验目的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)`函数销毁进程。
实验四：进程同步实验一、实验任务：1、熟悉操作系统进程通信原理2、设计程序，实现共享内存、管道通信、消息通信二、实验原理：1、进程间通信的几种方法简介（1）消息队列：消息队列是消息的链接表，包括Posix消息队列systemV消息队列。
有足够权限的进程可以向队列中添加消息，被赋予读权限的进程则可以读走队列中的消息。
（2）共享内存：使得多个进程可以访问同一块内存空间，是最快的可用IPC形式。
是针对其他通信机制运行效率较低而设计的。
往往与其它通信机制，如信号量结合使用，来达到进程间的同步及互斥。
（3）无名管道（Pipe）及有名管道（named pipe）：有名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信；无名管道可用于有亲缘关系的进程之间彼此的通信，进行通信时候必须有一定的机制保证对管道写和读的互斥：即在读是要关闭写的端口，而在写的时候也要保证读的一端是关闭的。
2、进程通信函数（1）消息队列有关系统调用函数a.创建消息队列使用msgget()函数：#include <sys/types.h>#include <sys/ipc.h>#include <sys/msg.h>int msgget(key_t key, int flag) ;该函数成功调用返回消息队列标识符。
其中的key是关键字，可以由ftok()函数得到：key=ftok(“.”,’a’);其中”.”可以是任何目录，’a’是任意字符，即所有群组标识。
flag是标识，IPC_CREAT位表示创建，一般由服务器程序创建消息队列时使用。
如果是客户程序，必须打开现存的消息队列，必须不使用IPC_CREAT。
发送和接收的消息都必须使用一个类似msgbuf的结构表示，msgbuf结构定义如下：struct msgbuf{long mtype;char mtext[1];}上面的定义，消息内容只有一个字节，是不实用的，一般我们需要重新定义一个结构：struct amsgbuf{long mtype;char mtext[200];}其中的mtype都是消息类型。
第1篇一、实验目的1. 理解通信管道的概念和作用。
2. 掌握管道的创建、使用和销毁方法。
3. 学习管道在进程间通信中的应用。
4. 熟悉管道的同步机制。
二、实验原理管道（Pipe）是UNIX系统中实现进程间通信（IPC）的一种古老且常用的方法。
它允许一个进程向另一个进程发送数据。
管道通常由两个端点组成：一个用于写入数据，另一个用于读取数据。
管道可以用于父子进程之间的通信，也可以用于兄弟进程之间的通信。
三、实验内容1. 创建管道：使用`pipe()`系统调用创建管道。
2. 写入数据：使用`write()`系统调用向管道写入数据。
3. 读取数据：使用`read()`系统调用从管道读取数据。
4. 管道的同步：使用`select()`或`poll()`等系统调用来实现管道的同步。
5. 管道的销毁：使用`close()`系统调用销毁管道。
四、实验步骤1. 创建管道：```cint pipefd[2];if (pipe(pipefd) == -1) {perror("pipe");exit(EXIT_FAILURE);}```2. 创建子进程：```cpid_t pid = fork();if (pid == -1) {perror("fork");exit(EXIT_FAILURE);}```3. 在子进程中写入数据：```cif (pid == 0) {close(pipefd[0]); // 关闭读端write(pipefd[1], "Hello, world!\n", 14); close(pipefd[1]); // 关闭写端exit(EXIT_SUCCESS);}```4. 在父进程中读取数据：```cclose(pipefd[1]); // 关闭写端char buffer[1024];read(pipefd[0], buffer, sizeof(buffer));printf("Received: %s\n", buffer);close(pipefd[0]); // 关闭读端```5. 同步管道：```cfd_set readfds;FD_ZERO(&readfds);FD_SET(pipefd[0], &readfds);select(pipefd[0] + 1, &readfds, NULL, NULL, NULL);```6. 销毁管道：```cclose(pipefd[0]);close(pipefd[1]);```五、实验结果1. 创建管道成功。
一、实验目的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. 理解进程的基本概念和进程控制块（PCB）的作用。
2. 掌握进程创建、调度、同步和通信的基本方法。
3. 熟悉进程状态转换及进程同步机制。
4. 提高编程能力，加深对操作系统进程管理的理解。
二、实验环境1. 操作系统：Windows 102. 编程语言：C/C++3. 开发环境：Visual Studio 2019三、实验内容1. 进程创建与销毁2. 进程调度3. 进程同步4. 进程通信四、实验步骤1. 进程创建与销毁（1）定义进程结构体```ctypedef struct {int pid; // 进程IDchar name[50]; // 进程名int status; // 进程状态struct PCB next; // 指向下一个进程的指针} PCB;```（2）创建进程```cPCB createProcess(char name) {PCB newProcess = (PCB )malloc(sizeof(PCB)); newProcess->pid = ...; // 分配进程IDstrcpy(newProcess->name, name);newProcess->status = ...; // 初始化进程状态 newProcess->next = NULL;// ... 其他初始化操作return newProcess;}```（3）销毁进程```cvoid destroyProcess(PCB process) {free(process);}```2. 进程调度（1）定义进程队列```ctypedef struct {PCB head; // 队列头指针PCB tail; // 队列尾指针} ProcessQueue;```（2）初始化进程队列```cvoid initProcessQueue(ProcessQueue queue) {queue->head = NULL;queue->tail = NULL;}```（3）入队```cvoid enqueue(ProcessQueue queue, PCB process) { if (queue->head == NULL) {queue->head = process;queue->tail = process;} else {queue->tail->next = process;queue->tail = process;}}（4）出队```cPCB dequeue(ProcessQueue queue) {if (queue->head == NULL) {return NULL;}PCB process = queue->head;queue->head = queue->head->next; if (queue->head == NULL) {queue->tail = NULL;}return process;}```3. 进程同步（1）互斥锁```ctypedef struct {int locked; // 锁的状态} Mutex;void initMutex(Mutex mutex) {mutex->locked = 0;void lock(Mutex mutex) {while (mutex->locked) {// 等待锁释放}mutex->locked = 1;}void unlock(Mutex mutex) {mutex->locked = 0;}```（2）信号量```ctypedef struct {int count; // 信号量值Mutex mutex; // 互斥锁} Semaphore;void initSemaphore(Semaphore semaphore, int count) { semaphore->count = count;initMutex(&semaphore->mutex);}void P(Semaphore semaphore) {lock(&semaphore->mutex);while (semaphore->count <= 0) {// 等待信号量}semaphore->count--;unlock(&semaphore->mutex);}void V(Semaphore semaphore) {lock(&semaphore->mutex);semaphore->count++;unlock(&semaphore->mutex);}```4. 进程通信（1）管道通信```cint pipe(int pipefd[2]) {// 创建管道}void writePipe(int pipefd[2], const void buf, size_t nbyte) { // 向管道写入数据}void readPipe(int pipefd[2], void buf, size_t nbyte) {// 从管道读取数据}```（2）消息队列通信```cint msgget(key_t key, int msgflg) {// 创建消息队列}void msgsnd(int msqid, const void msgp, size_t msgsz, int msgflg) {// 向消息队列发送消息}void msgrcv(int msqid, void msgp, size_t msgsz, long msgtype, int msgflg) {// 从消息队列接收消息}```五、实验结果与分析1. 进程创建与销毁：通过创建和销毁进程，验证了进程结构体的正确性。
进程的管道通信实验报告一、实验目的本实验旨在通过实际操作，深入理解进程间通信（IPC）的原理，掌握管道通信的实现方法，提高对操作系统进程管理的理解。
二、实验环境实验环境为Linux操作系统，使用Shell脚本进行进程的管道通信实验。
三、实验内容1. 创建两个Shell脚本文件，分别命名为sender.sh和receiver.sh。
2. 在sender.sh中，编写一个简单的程序，用于向管道中写入数据。
程序包括一个无限循环，每次循环中随机生成一个数字并写入管道。
3. 在receiver.sh中，编写一个简单的程序，用于从管道中读取数据。
程序同样包括一个无限循环，每次循环中从管道中读取一个数字并输出。
4. 使用Shell命令将sender.sh和receiver.sh链接起来，实现进程间的管道通信。
四、实验过程1. 打开两个终端窗口，分别用于运行sender.sh和receiver.sh。
2. 在第一个终端窗口中，输入命令“bash sender.sh”运行sender.sh脚本。
该脚本将创建一个无限循环，每次循环中随机生成一个数字并写入管道。
3. 在第二个终端窗口中，输入命令“bash receiver.sh”运行receiver.sh脚本。
该脚本将创建一个无限循环，每次循环中从管道中读取一个数字并输出。
4. 观察两个终端窗口的输出，可以看到sender.sh进程向管道中写入的数字被receiver.sh进程读取并输出。
五、实验总结通过本次实验，我们成功实现了进程间的管道通信。
在实验过程中，我们深入了解了进程间通信的原理和实现方法，掌握了管道通信的基本操作。
通过实际操作，我们更好地理解了操作系统中进程管理、进程间通信的相关知识。
同时，我们也发现了一些不足之处，例如在程序中没有添加异常处理机制等。
在今后的学习中，我们将继续深入探索进程间通信的相关知识，提高自己的编程技能和系统设计能力。
