实验一二--进程管理

合集下载

进程管理实验报告

实验名称: 进程管理实验要求:阅读后面的C语言实例，修改程序，使其优先数在运行期间可以变化(动态优先数)。

例如，当某进程被时间片中断次数增加到一定数目时，提高其优先权。

关键问题:读懂源程序代码，了解进程管理的方式，并设计一个算法使程序能在运行过程中修改进程优先级。

设计思路:在进程控制块中定义一个记录进程中断次数的变量，在block函数中设置跟踪并记录进程中断次数，在调度函数schedule中设置算法，在进程中断3次后将该进程的优先级提升至最高。

改动后的代码:#include <stdio.h>#define TRUE 1#define FALSE 0#define MAXPRI 100#define NIL -1//进程控制块struct {int id; //进程号char status; //进程状态，'e'-执行态'r'-高就绪态't'-低就绪态'w'-等待态'c'-完成态int nextwr; //等待链指针，指示在同一信号量上等待的下一个等待进程的进程号。

int priority; //进程优先数，值越小，优先级越高。

int c;//进程中断次数}pcb[3];//共3个进程//s1、s2为三个进程共享的变量；seed为随机值；registeri模拟寄存器值,存放计算的重复次数。

int registeri,s1,s2,seed,exe=NIL;//exe为当前运行（占有cpu）的进程号//2个信号量sem[0]、sem[1],分别与共享变量s1、s2相联系。

//对应信号量sem[0]、sem[1]分别有两个阻塞队列，队列首由sem[].firstwr指定，队列链指针是pcb[].nextwrstruct{int value;//信号量值int firstwr;//等待该信号量的阻塞队列的首个进程号}sem[2];//三个进程的现场保留区，其中savearea[][0]为寄存器内容，savearea[][1]为下一条指令地址。

进程管理实验实验报告

一、实验目的1. 理解进程的基本概念，掌握进程的结构和生命周期。

2. 掌握进程的创建、终止、同步和通信的方法。

3. 熟悉进程调度算法和进程同步机制。

4. 通过实验加深对操作系统进程管理的理解。

二、实验环境1. 操作系统：Linux2. 编程语言：C/C++3. 实验工具：gcc、make、xterm三、实验内容1. 进程的创建与终止（1）使用fork()系统调用创建进程编写一个C程序，通过fork()系统调用创建一个子进程。

父进程和子进程分别执行不同的任务，并输出各自的信息。

```c#include <stdio.h>#include <sys/types.h>#include <unistd.h>int main() {pid_t pid;pid = fork();if (pid == -1) {printf("Fork failed!\n");return 1;printf("This is child process, PID: %d\n", getpid()); // 子进程执行的任务} else {printf("This is parent process, PID: %d\n", getpid()); // 父进程执行的任务}return 0;}```（2）使用exec()系统调用替换子进程内容在父进程中，使用exec()系统调用替换子进程的内容，执行新的程序。

```c#include <stdio.h>#include <sys/types.h>#include <sys/wait.h>#include <unistd.h>int main() {pid_t pid;pid = fork();if (pid == -1) {printf("Fork failed!\n");return 1;execlp("ls", "ls", "-l", (char )NULL);printf("Exec failed!\n");return 1;} else {wait(NULL);}return 0;}```2. 进程同步与通信（1）使用管道实现进程通信编写一个C程序，使用管道实现父进程和子进程之间的通信。

进程管理实验报告源代码(3篇)

第1篇---进程管理实验报告一、实验目的1. 理解进程的概念和进程管理的基本原理。

2. 掌握进程的创建、调度、同步和通信等操作。

3. 通过编程实现简单的进程管理功能。

二、实验环境1. 操作系统：Windows/Linux2. 编程语言：C/C++3. 开发环境：Visual Studio/Code::Blocks三、实验内容1. 进程的创建与终止2. 进程的同步与互斥3. 进程的通信4. 进程调度算法四、实验步骤1. 进程的创建与终止```cinclude <stdio.h>include <sys/types.h>include <unistd.h>int main() {pid_t pid;// 创建子进程pid = fork();if (pid < 0) {// 创建进程失败perror("fork failed");return 1;} else if (pid == 0) {// 子进程printf("Child process, PID: %d\n", getpid()); // 执行子进程的任务...sleep(5); // 子进程暂停5秒_exit(0); // 子进程退出} else {// 父进程printf("Parent process, PID: %d\n", getpid()); wait(NULL); // 等待子进程结束printf("Child process has terminated.\n");}return 0;}```2. 进程的同步与互斥```cinclude <stdio.h>include <pthread.h>pthread_mutex_t mutex;void thread_func(void arg) {pthread_mutex_lock(&mutex); // 加锁printf("Thread %ld is running\n", (long)arg);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;}```3. 进程的通信```cinclude <stdio.h>include <stdlib.h>include <sys/ipc.h>include <sys/shm.h>int main() {key_t key;int shmid;int data;// 生成共享内存标识符key = ftok("shmfile", 65);// 创建共享内存段shmid = shmget(key, sizeof(int), 0666 | IPC_CREAT); if (shmid == -1) {perror("shmget failed");exit(1);}// 连接到共享内存段data = (int )shmat(shmid, (void )0, 0);if (data == (int )(-1)) {perror("shmat failed");exit(1);}// 使用共享内存data = 100;printf("Data in shared memory: %d\n", data); // 分离共享内存段if (shmdt(data) == -1) {perror("shmdt failed");exit(1);}// 删除共享内存段if (shmctl(shmid, IPC_RMID, NULL) == -1) { perror("shmctl failed");exit(1);}return 0;}```4. 进程调度算法```cinclude <stdio.h>include <stdlib.h>include <sys/time.h>typedef struct {int pid;int arrival_time;int burst_time;int waiting_time;int turnaround_time;} Process;int main() {Process processes[] = {{1, 0, 5, 0, 0},{2, 1, 3, 0, 0},{3, 4, 8, 0, 0}};int n = sizeof(processes) / sizeof(processes[0]);// 计算等待时间和周转时间int total_waiting_time = 0, total_turnaround_time = 0;for (int i = 0; i < n; i++) {if (i == 0) {processes[i].waiting_time = 0;} else {processes[i].waiting_time = processes[i - 1].turnaround_time;}processes[i].turnaround_time = processes[i].burst_time + processes[i].waiting_time;total_waiting_time += processes[i].waiting_time;total_turnaround_time += processes[i].turnaround_time;}printf("Average Waiting Time: %f\n", (float)total_waiting_time / n);printf("Average Turnaround Time: %f\n", (float)total_turnaround_time / n);return 0;}```五、实验结果与分析（此处应填写实验结果，包括运行程序输出、图表等，以及对实验结果的分析。

进程管理实验报告_共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篇)

第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、掌握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. 进程通信实验结果显示，使用管道实现进程间通信时，进程能正确地接收和发送数据；使用共享内存实现进程间通信时，进程能正确地访问共享内存中的数据。

进程的管理实验报告

一、实验目的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不同，说明子进程是独立于父进程的实体。

国开电大操作系统实验2：进程管理实验报告

一、实验题目：进程管理实验二、实验目的和要求：实验目的：（1）加深对进程概念的理解，尤其是进程的动态性、并发性。

（2）了解进程如何被创建和终止。

（3）学会查看进程的状态信息。

（4）学会使用进程管理命令。

（5）学会在后台运行进程。

实验要求：（1）理解有关进程的概念，能用ps命令列出系统中进程的有关信息，并进行分析。

（2）理解进程的创建及族系关系。

（3）能使用&，jobs，bg，at等命令控制进程的运行。

（4）了解终止进程的方法。

三、实验内容：1.使用ps命令查看系统中运行进程的信息。

2.利用系统调用实现进程的创建、终止、等待、睡眠等操作。

四、实验技术和方法：（说明：对本实验涉及的教材中的相关内容进行归纳总结，只需简要说明即可。

）加深对进城概念的理解，尤其是进程的动态性、并发性。

学会使用ps命令观察进程的状态，并分析进程族系关系；能使用& ， jobs， bg， at 等命令控制进程的运行利用系统调用实现进程的创建、终止、等待、睡眠等操作。

五、实验环境：（说明：列出本实验使用到的软件平台和工具，如Linux系统版本，shell类型，vi编辑工具等。

）在虚拟机中的Linux RedHat Linux 9六、实验步骤和结果：（说明：详细给出实验步骤和结果。

实验步骤不一定与《实验指南》中的完全一致。

对实验结果，除文字说明外，对一些关键结果，需要给出一些界面截图。

）１、输入ps 命令PS命令用来报告系统当前的进程状态。

２、输入ps –e命令可以显示系统中运行的所有进程，包括系统进程和用户进程。

３、输入ps –f命令可以得到进程详细信息。

４、输入ps –el 命令显示进程环境变量列出长表。

二、进程控制１、后台进程（１）$grep “注册用户名” /etc/passwd > /tmp/abc &（２）ps –p pid２、作业控制（1）进程休眠60秒 Sleep 60 &（2）进程休眠30秒 Sleep 30 &（3）查看进程状态 Jobs（4）把睡眠30秒的sleep命令放在前台执行 fg %2（5）当提示符出现后，再查看进程状态 jobs三、发送中断信号（１）后台运行sleep命令$sleep 120 &（２）查看sleep进程的状态$ps –p pid（３）终止sleep命令$kill -9 pid（４）再查看sleep进程的状态$ps –p pid四、减轻系统负载【at命令】让一个命令在指定的时间运行，并把结果输出在一个文件中例：at time>date>who><ctrl>dat 命令会把已执行命令的标准输出发送到用户的邮箱，用cat命令查看邮箱内容，显示结果。

进程管理实验报告

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

实验二进程管理

实验二进程管理（一）实验目的或实验原理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的排列都是有可能的。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

进程管理实验报告

进程管理实验报告
摘要：
进程管理是操作系统中的重要概念之一，它涉及到进程的创建、调度和终止等方面。

本实验通过使用C语言编写一个简单的进程管
理程序来加深对进程管理原理的理解。

实验分为进程创建、调度和
终止三个部分，通过实验结果可以验证进程管理算法的正确性和效率。

1. 引言
进程是计算机中进行资源分配和调度的基本单位，它代表了一
个正在运行的程序。

进程管理是操作系统中的一个核心功能，负责
分配资源、调度进程和管理进程的状态等。

通过对进程管理的研究
和实验，可以深入了解操作系统的工作原理，并且优化进程管理算法，提高系统性能。

2. 实验目的
本实验的主要目的是通过编写一个进程管理程序，实现进程的创建、调度和终止等功能。

通过实验，验证进程管理算法的正确性和效率，并加深对进程管理原理的理解。

3. 实验环境
本实验使用C语言进行编程，采用Linux操作系统。

4. 实验内容
4.1 进程创建
进程创建是指操作系统为程序创建一个进程，使其能够在系统中运行。

在本实验中，我们使用fork()函数创建一个子进程，并通过exec()函数加载可执行文件。

4.2 进程调度
进程调度是指根据一定的算法选择哪个进程优先执行。

常见的调度算法有先来先服务（FCFS）、最短作业优先（SJF）、优先级调度等。

在本实验中，我们选择简单的先来先服务调度算法。

4.3 进程终止。

【操作系统实验报告实验一进程管理(20210814000319)】进程管理实验报告

~~\r\n);
public void testblock()
(m);
{
m--;
rryList hblock1 = new rryList();
}
hblock1 = hblock;
// 输出就绪数组和堵塞数组的信息
pcb p = (pcb)list1[j];
public void outputll()
I!
\r\n=======CPU 运行了： + () + 次 =======\r\n);
I!
H*********当前就绪队列的信息！
I!
H*********
I!
当前就绪队列的信息！ *********);
//h
for (i = 1; i = n; i++)
为运行的时间片次数，
{
time1Intevl
pcb jincheng = new pcb();
为时间片大小(毫秒)
= i;
// 对进程进行初始化，建立就绪数组、堵塞数组。
= () + 1);
public void input()//对进程进行初始化，建立就绪队列、堵塞队列
第1页共1页
本文格式为 Word 版，下载可任意编辑，页眉双击删除即可。
//r
n=;
为可随机产生的进程数
c=;
(r=m-n)
1=;
//
b1 = b;
，b，c 分别为，B，C 三类
c1 = c;
资源的总量
r = m - n;
//i
time1Intevl = ;
为进城计数，i=1…n
= time1Intevl;

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

六、自我评价与总结
本次操作系统实验是模拟进程管理过程，解决哲学家的就餐问题。个人本次实验还比较顺利，使用了比较熟悉的 c++语言进行算法的编写，比较巧妙的定义了两个类来定义哲学家和筷子对象的属性以及相应的动作，方便在各种就餐过程中对筷子的资源进行申请和释放，以及哲学家实现相应的动作。另一个觉得比较好的地方是解决了死锁问题，通过判断当前哲学家是否可以同时拿起左右筷子来避免死锁。
①至多只允许四个哲学家同时进餐，以保证至少有一个哲学家可以进餐，
最终总会释放出他所用过的两只筷子，从而可使更多的哲学家进餐；
②仅当左右两只筷子均可用时，才允许哲学家拿起筷子就餐；
③规定奇数号哲学家先拿起右边筷子，然后再去拿左边筷子，而偶数号哲
学家则相反。
本实验中采取方法 2.
三、数据结构及功能设计
}; bool b[5]; int i, j; srand(time(0)); j = rand() % 5; for (i = j; i < j + 5; i++) {
b[i % 5] = philosopher[i % 5].eat(); cout << endl << "********************************************************" << endl; } for (i = j; i < j + 5; i++) { if (b[i % 5]) {
五、测试用例及运行结果、分析
测试结果截图：
分析：产生了一个随机数 0，并依次加 1 对每个哲学家进行分析。分析时首先看左筷子是否可用，然后看右筷子，若有一个不可用则放下手中的另一只筷子，并说明 need waiting。然后再下一时间段对每个哲学家再次分析，直到每个哲学家都吃上饭，程序结束。通过实验结果可得，程序正确运行，且解决了死锁问题。

实验二-实验报告(进程管理)

实验二模拟实现进程管理组长：李和林软件1402一、实验目的1.理解进程的概念，明确进程和程序的区别。

2.理解并发执行的实质。

3.掌握进程的创建，睡眠，撤销等进程控制方法。

二、实验内容用C语言，JAVA语言，C++语言编写程序，模拟实现创建新的进程；查看运行进程，换出某个进程；杀死运行进程。

三、实验准备1.进程的定义进程是程序在一个数据集合上的运行过程，是系统资源分配和调度的一个独立单位。

一个程序在不同的数据集合上运行，乃至一个程序在同样数据集合上的多次运行都是不同的进程。

2.进程的状态通常情况下，一个进程必须具有就绪，执行和阻塞三种基本情况。

1)就绪状态当进程已分配到除处理器外的所有必要资源后，只要再获得处理器就可以立即执行，这时进程的状态就为就绪状态。

在一个系统里，可以有多个进程同时处于就绪状态，通常把这些就绪进程排成一个或多个队列，称为就绪队列。

2)执行状态处于就绪状态的进程一旦获得处理器，就可以运行，进程状态也就处于执行状态，在单处理器系统中，只能有一个进程处于执行状态，在多处理器系统中，则可能有多个进程处于执行状态3)阻塞状态正在执行的进程因为发生某些事件而暂停运行，这种受阻暂停的状态称为阻塞状态，也可称为等待状态。

通常将处于阻塞状态的进程拍成一个队列，称为阻塞队列，在有些系统中，也会按阻塞原因的不同将阻塞状态的进程排成多个队列。

3.进程状态之间的转换4.进程控制块1）进程控制块的作用进程控制块是进程实体的重要组成部分，主要包含下述四个方面的信息：a)进程标示信息b)说明信息c)现场信息d)管理信息5.进程控制块的组织方式1）链接方式2）索引方式6.进程控制原语1）创建原语2）撤销原语3）阻塞原语4）唤醒原语7.程序代码#include<stdio.h>#include<iostream>using namespace std;void clrscr();void create();void run( );void exchange( );//唤出void kill( );void wakeUp( );//唤醒struct process_type{int pid;int priority;//优先次序int size;int state;//状态char info[10];};struct process_type internalMemory[20];int amount=0,hangUp=0,pid,flag=0;//数目，挂起void main( ){int n;int a;n=1;clrscr( );while(n==1){cout<<"\n********************************************";cout<<"\n* 进程演示系统 *";cout<<"\n********************************************";cout<<"\n 1.创建新的进程 2.查看运行进程 ";cout<<"\n 3.换出某个进程 4.杀死运行进程 ";cout<<"\n 5.唤醒某个进程¨ 6.退出系统 ";cout<<"\n*********************************************"<<endl;cout<<"请选择 ";cin>>a;switch(a){case 1:create( );break;case 2:run( );break;case 3:exchange();//换出break;case 4:kill();break;case 5:wakeUp();break;case 6:exit(0);default:n=0;}}}void create(){ //创建进程int i=0;if (amount>=20){cout<<" 内存已满，请先结束或换出进程";}else{for (i=0;i<20;i++){if (internalMemory[i].state==0){break;}}cout<<"请输入新进程的pid: "<<endl;cin>>internalMemory[ i ].pid;cout<<"请输入新进程的优先级: "<<endl;cin>>internalMemory[amount].priority;cout<<"请输入新进程的大小: "<<endl;cin>>internalMemory[amount].size;cout<<"请输入新进程的内容: "<<endl;cin>>internalMemory[amount].info;internalMemory[i].state=1;amount++;}}void clrscr()//清除内存空间{for (int i=0;i<19;i++){internalMemory[i].pid=0;internalMemory[i].priority=0;internalMemory[i].size=0;internalMemory[i].state=0;}amount=0;}void run(){for (int i=0;i<20;i++){if (internalMemory[i].state==1){cout<<"当前内存中的进程：\n"<<endl;cout<<"当前运行的进程: ";cout<<internalMemory[i].pid<<endl;cout<<"当前运行进程的优先级: ";cout<<internalMemory[i].priority<<endl;cout<<"当前运行进程占用的空间大小: ";cout<<internalMemory[i].size;}}}void exchange( ){//唤出优先级最小的进程if (!amount){cout<<"当前没有运行进程\n";return;}cout<<"\n输入换出进程的ID值: ";cin>>pid;for (int i=0;i<20;i++){if (pid==internalMemory[i].pid){if (internalMemory[i].state==1){internalMemory[i].state=2;hangUp++;cout<<"\n已经成功换出进程\n";}else if (internalMemory[i].state==0){cout<<"\n要换出的进程不存在";}else{cout<<"\n要换出的进程已被挂起\n";}flag=1;break;}}if (flag==0){cout<<"\n要换出的进程不存在";}}void kill( ){if (!amount){cout<<"当前没有运行进程\n";return;}cout<<"请输入要杀死的进程: ";cin>>pid;for (int i=0;i<20;i++){if (pid==internalMemory[i].pid){if (internalMemory[i].state==1){internalMemory[i].state=0;amount--;cout<<"此进程被杀死"<<pid;}else if (internalMemory[i].state==0){cout<<"\n要杀死的进程不存在\n";}else{cout<<"\n要杀死的进程已被挂起\n";}flag=1;break;}}if (!flag){cout<<"\n要杀死的进程不存在\n";}}void wakeUp(){if (!amount){cout<<"当前没有运行进程"<<endl;return;}if (!hangUp){cout<<"当前没有挂起进程";return;}cout<<"请输入pid: ";cin>>pid;for (int i=0;i<20;i++){if (pid==internalMemory[i].pid){flag=0;if (internalMemory[i].state==2){internalMemory[i].state=1;hangUp--;cout<<"已经成功唤醒进程\n";}else if (internalMemory[i].state==0){cout<<"\n要换醒的进程不存在\n";}else{cout<<"\n要唤醒的进程已被挂起\n";}break;}}if (flag){cout<<"\n要唤醒的进程已被挂起\n"<<endl;}}8.实现的结果。

实验进程管理实验报告

一、实验目的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. 进程的创建与调度实验过程中，我们成功创建了多个进程，并通过修改进程优先级，观察到调度策略的变化。

实验一二--进程管理

进程管理实验报告

进程管理实验实验报告

最新实验二-实验报告(进程管理)

进程管理实验报告源代码(3篇)

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

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

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

进程的管理实验报告结论

进程的管理实验报告

国开电大 操作系统 实验2：进程管理实验报告

进程管理实验报告

实验二进程管理

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

进程管理实验报告

【操作系统实验报告实验一进程管理(20210814000319)】 进程管理实验报告

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

实验二-实验报告(进程管理)

实验进程管理实验报告

国开电大操作系统实验2：进程管理实验报告

【操作系统实验报告实验一进程管理(20210814000319)】进程管理实验报告