实验三进程的创建和简单控制

一、实验目的本次实验旨在通过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, &param) == -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`类型的互斥锁实现进程互斥。

DWORD dwVerReq=::GetProcessVersion(dwIdThis);
WORD wMajorReq=(WORD)(dwVerReq>16);
WORD wMinorReq=(WORD)(dwVerReq&0xffff);
::cout<<"Process ID:"<<dwIdThis<<",requires OS:"<<wMajorReq<<wMinorReq<<::endl;
{
//改变优先级
::SetPriorityClass(
::GetCurrentProcess(), //利用这一进程
HIGH_PRIORITY_CLASS); //改变为high
//报告给用户
::cout<<"Task Manager should indicate this "
"process is high priority."<<::endl;
//设置版本信息的数据结构，以便保存操作系统的版本信息
OSVERSIONINFOEX osvix;
::ZeroMemory(&osvix,sizeof(osvix));
osvix.dwOSVersionInfoSize=sizeof(osvix);
//提取版本信息和报告
::GetVersionEx(reinterpret_cast<LPOSVERSIONINFO>(&osvix));
Parent();
}
return 0;
}
分析：程序4-3.cpp说明了一个进程从“生”到“死”的整个一生，第一次执行时，它创建一个子进程，其行为如同“父亲”。在创建子进程之前，先创建一个互斥的内核对象，其行为对于子进程来说，如同一个“自杀弹”。当创建子进程时，就打开了互斥体并在其他线程中进行别的处理工作，同时等待着父进程使用ReleaseMutex（）API发出“死亡”信号。然后用Sleep（）API调用来模拟父进程处理其他工作，等完成时，指令子进程终止。

电大操作系统实验报告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 程序，创建一个子进程，子进程进入睡眠状态一段时间，然后被唤醒并输出状态转换信息。

操作系统实验3进程的创建控制实验实验三的目标是通过实现一个进程控制程序，来加深我们对进程创建和控制机制的理解，并通过实践来熟悉和掌握相关的编程技巧。

在进行实验之前，我们需要先了解进程的一些基本概念和相关知识。

首先，进程的创建是通过操作系统中的系统调用来完成的。

在Linux系统中，常用的创建进程的系统调用有fork(和exec(。

fork(系统调用可以创建一个新的进程，该进程与调用fork(的进程几乎完全相同；而exec(系统调用则在新创建的进程中执行一个新的程序。

另外，进程的控制机制主要是通过进程的状态来实现的。

进程可以处于就绪状态、运行状态和阻塞状态。

就绪状态的进程可以被调度器选择后立即运行，而阻塞状态的进程则需要等待一些条件满足后才能被唤醒并变为就绪状态。

实验三的具体内容包括：1. 编写一个程序，通过调用fork(创建多个子进程。

子进程和父进程可以并行执行，共享程序的代码和数据段。

2. 子进程通过调用exec(系统调用执行不同的程序。

可以通过调用不同的exec(函数或者传入不同的参数来执行不同的程序。

3. 子进程执行的程序可能会产生不同的结果，比如输出不同的字符串或者产生不同的返回值。

我们可以通过wait(系统调用等待子进程退出，并获取子进程的返回值。

4. 父进程可以通过调用waitpid(系统调用来选择等待一些特定的子进程，以及获取特定子进程的返回值。

通过实验三的实践，我将更加深入地了解进程的创建和控制机制。

实验三的实验结果将让我熟悉和掌握相关的编程技巧，为我今后更加熟练地编写和控制进程打下坚实的基础。

总之，实验三是一个非常有意义的实验，将帮助我更加深入地理解进程的创建和控制机制，并通过实践获得相关的编程技巧。

这将对我今后的学习和实践有很大的帮助。

★进程管理实验报告_共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族调用可以执行给定程序。

进程控制与进程通信程序实验报告一、引言进程是计算机系统中最基本的概念之一，是操作系统中最小的资源管理单位。

进程控制与进程通信是操作系统中重要的内容，涉及到进程的创建、调度和终止，以及进程间的信息传递和同步管理。

本实验旨在通过编写进程控制与进程通信程序，加深对操作系统中进程管理和通信机制的理解。

二、实验目的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操作，实现进程间的同步和互斥。

五、实验结果通过实验，我们成功实现了进程的创建、调度和终止，以及进程间的信息传递和同步管理。

三、实验内容
（一）进程创建
编写程序实现创建多个进程，并观察进程的执行情况。通过调用Windows API函数｀CreateProcess`来创建新的进程。在创建进程时，设置不同的参数，如进程的优先级、命令行参数等，观察这些参数对进程执行的影响。
（二）进程控制
实现对进程的暂停、恢复和终止操作。使用｀SuspendThread`和｀ResumeThread`函数来暂停和恢复进程中的线程，使用｀TerminateProcess`函数来终止进程。通过控制进程的执行状态，观察系统的资源使用情况和进程的响应。
（一）进程创建实验结果与分析
创建多个进程后，通过任务管理器观察到新创建的进程在系统中运行。不同的进程优先级设置对进程的CPU占用和响应时间产生了明显的影响。高优先级的进程能够更快地获得CPU资源，执行速度相对较快；而低优先级的进程则在CPU资源竞争中处于劣势，可能会出现短暂的卡顿或计一个多进程同步的程序，使用信号量、互斥量等同步机制来协调多个进程的执行。例如，实现一个生产者消费者问题，多个生产者进程和消费者进程通过共享缓冲区进行数据交换，使用同步机制来保证数据的一致性和正确性。
四、实验步骤
（一）进程创建实验步骤
1、打开Visual Studio 2019，创建一个新的C+＋控制台应用程序项目。
六、实验中遇到的问题及解决方法
（一）进程创建失败
在创建进程时，可能会由于参数设置不正确或系统资源不足等原因导致创建失败。通过仔细检查参数的设置，确保命令行参数、环境变量等的正确性，并释放不必要的系统资源，解决了创建失败的问题。
（二）线程控制异常
在暂停和恢复线程时，可能会出现线程状态不一致或死锁等异常情况。通过合理的线程同步和错误处理机制，避免了这些异常的发生。在代码中添加了对线程状态的判断和异常处理的代码，保证了线程控制的稳定性和可靠性。

（1）首先查找调用进程是否有子进程，若无，则返回出错码；（2）若找到一处于“僵死状态”的子进程，则将子进程的执行时间加到父进程的执行时间上，并释放子进程的进程表项；（3）若未找到处于“僵死状态”的子进程，则调用进程便在可被中断的优先级上睡眠，等待其子进程发来软中断信号时被唤醒。

4、exit（）终止进程的执行。

系统调用格式：void exit(status)int status;其中，status 是返回给父进程的一个整数，以备查考。

为了及时回收进程所占用的资源并减少父进程的干预，LINUX/LINUX 利用exit( )来实现进程的自我终止，通常父进程在创建子进程时，应在进程的末尾安排一条exit( )，使子进程自我终止。

exit(0)表示进程正常终止，exit(1)表示进程运行有错，异常终止。

如果调用进程在执行exit( )时，其父进程正在等待它的终止，则父进程可立即得到其返回的整数。

核心须为exit( )完成以下操作：（1）关闭软中断（2）回收资源（3）写记帐信息（4）置进程为“僵死状态”参考程序#include<stdio.h>#include<unistd.h>main( ){in t pid;pid=fork( ); /*创建子进程*/switch(pid){case -1:printf("fork fail!\n");exit(1);case 0: /*创建失败*//*子进程*/execl("/bin/ls","ls","­1","­color",NULL); printf("exec fail!\n");exit(1);default:wait(NULL);/*父进程*/ /*同步*/printf("ls completed !\n");exit(0);}}运行结果执行命令ls -l -color ，（按倒序）列出当前目录下所有文件和子目录；ls completed!分析原因程序在调用fork( )建立一个子进程后，马上调用wait( )，使父进程在子进程结束之前，一直处于睡眠状态。

华北电力大学
实验报告
|
|
实验名称操作系统综合实验
课程名称操作系统
|
|
专业班级：网络学生姓名：
学号：成绩：
指导教师：王德文/姜丽梅实验日期：2015年11月4日
2. 当loop线程在控制台1中执行，并且在控制台2中执行suspend命令时，为什么控制台1中的loop线程处于就绪状态而不是运行状态？
答：当在控制台2 中执行suspend命令时，实质上是优先级为24的控制台2线程抢占了处理器，也就是控制台2线程处于运行状态，所以此时loop线程处于就绪状态了。

图 1 调试EOS信号量的工作过程。

华北电力大学实验报告
第页共页。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

操作系统实验报告三一、实验目的本次操作系统实验的目的在于深入了解操作系统的进程管理、内存管理和文件系统等核心功能，通过实际操作和观察，增强对操作系统原理的理解和掌握，提高解决实际问题的能力。

二、实验环境本次实验在 Windows 10 操作系统环境下进行，使用了 Visual Studio 2019 作为编程工具，并借助了相关的操作系统模拟软件和调试工具。

三、实验内容与步骤（一）进程管理实验1、创建多个进程使用 C+＋语言编写程序，通过调用系统函数创建多个进程。

观察每个进程的运行状态和资源占用情况。

2、进程同步与互斥设计一个生产者消费者问题的程序，使用信号量来实现进程之间的同步与互斥。

分析在不同并发情况下程序的执行结果，理解进程同步的重要性。

（二）内存管理实验1、内存分配与回收实现一个简单的内存分配算法，如首次适应算法、最佳适应算法或最坏适应算法。

模拟内存的分配和回收过程，观察内存的使用情况和碎片产生的情况。

2、虚拟内存管理了解 Windows 操作系统的虚拟内存机制，通过查看系统性能监视器观察虚拟内存的使用情况。

编写程序来模拟虚拟内存的页面置换算法，如先进先出（FIFO）算法、最近最少使用（LRU）算法等。

（三）文件系统实验1、文件操作使用 C+＋语言对文件进行创建、读写、删除等操作。

观察文件在磁盘上的存储方式和文件目录的结构。

2、文件系统性能测试对不同大小和类型的文件进行读写操作，测量文件系统的读写性能。

分析影响文件系统性能的因素，如磁盘碎片、缓存机制等。

四、实验结果与分析（一）进程管理实验结果1、创建多个进程在创建多个进程的实验中，通过任务管理器可以观察到每个进程都有独立的进程 ID、CPU 使用率、内存占用等信息。

多个进程可以并发执行，提高了系统的资源利用率。

2、进程同步与互斥在生产者消费者问题的实验中，当使用正确的信号量机制时，生产者和消费者能够协调工作，不会出现数据不一致或死锁的情况。

第1篇一、实验目的1. 理解进程的概念和进程创建的基本原理。

2. 掌握使用C语言模拟进程创建的方法。

3. 熟悉进程的属性和进程之间的通信机制。

4. 分析实验结果，加深对进程管理的理解。

二、实验环境1. 操作系统：Windows 102. 编程语言：C语言3. 开发环境：Visual Studio 2019三、实验原理进程是计算机中程序执行的基本单位，是操作系统进行资源分配和调度的一个独立单位。

进程创建是操作系统的一个重要功能，它负责为进程分配必要的资源，并建立进程控制块（PCB）。

在模拟进程创建实验中，我们将使用C语言编写程序，模拟进程的创建、运行和销毁过程。

通过模拟进程的创建，我们可以了解进程的基本属性，如进程ID、进程状态、父进程ID等。

四、实验步骤1. 定义进程结构体，包含进程的基本属性，如进程ID、进程状态、父进程ID等。

```ctypedef struct {int pid; // 进程IDint state; // 进程状态int parent_pid; // 父进程ID// 其他属性} Process;```2. 编写进程创建函数，用于创建新进程。

```cProcess create_process(int parent_pid) {Process new_process;new_process.pid = ...; // 分配进程IDnew_process.state = ...; // 设置进程状态 new_process.parent_pid = parent_pid;// 设置其他属性return new_process;}```3. 编写进程运行函数，用于模拟进程的运行过程。

```cvoid run_process(Process p) {// 模拟进程运行过程// ...}```4. 编写进程销毁函数，用于销毁进程。

```cvoid destroy_process(Process p) {// 销毁进程资源// ...}```5. 编写主函数，模拟进程创建、运行和销毁过程。

一、实验目的1. 理解进程的概念及其在操作系统中的作用。

2. 掌握进程的创建、调度、同步和通信的基本原理。

3. 通过实验演示进程系统的运行过程，加深对进程管理的理解。

二、实验环境1. 操作系统：Linux2. 编程语言：C/C++3. 开发工具：gcc三、实验内容1. 进程的创建2. 进程的调度3. 进程的同步4. 进程的通信四、实验步骤1. 进程的创建（1）编写一个主函数，作为父进程；（2）在父进程中，使用fork()系统调用创建子进程；（3）输出父进程和子进程的进程号、父进程号和子进程号。

2. 进程的调度（1）使用进程调度算法（如FIFO、时间片轮转）对进程进行调度；（2）设置进程的优先级，实现进程的动态调度；（3）输出进程的调度结果，包括进程名、进程号、优先级和调度时间。

3. 进程的同步（1）使用互斥锁（mutex）实现进程的互斥访问；（2）使用条件变量（condition variable）实现进程的同步；（3）输出进程同步的结果，包括互斥锁的使用情况和条件变量的等待/唤醒情况。

4. 进程的通信（1）使用管道（pipe）实现进程间的数据传递；（2）使用共享内存（shared memory）实现进程间的数据共享；（3）输出进程通信的结果，包括管道和共享内存的使用情况。

五、实验结果与分析1. 进程的创建实验结果：成功创建父进程和子进程，输出进程号、父进程号和子进程号。

分析：通过fork()系统调用，父进程创建子进程，子进程继承父进程的代码段和数据段。

2. 进程的调度实验结果：根据进程调度算法，输出进程的调度结果，包括进程名、进程号、优先级和调度时间。

分析：通过设置进程优先级和调度算法，实现进程的动态调度，提高系统资源利用率。

3. 进程的同步实验结果：成功实现互斥锁和条件变量的使用，输出进程同步的结果。

分析：通过互斥锁和条件变量，实现进程的同步访问和条件等待，保证数据的一致性和进程的同步。

4. 进程的通信实验结果：成功使用管道和共享内存实现进程间的数据传递和共享。

进程控制实验报告进程控制实验报告一、实验目的本实验旨在通过实际操作，深入理解进程控制的概念、原理和实现方式，掌握进程控制的技巧和方法，提升解决实际问题的能力。

二、实验原理进程控制是操作系统内核的重要功能之一，它负责协调和管理系统中多个进程的执行顺序和资源分配。

进程控制的主要任务包括创建和终止进程、进程切换和进程同步等。

本实验将通过具体的操作，学习和体验进程控制的过程和细节。

三、实验步骤1.实验准备（1）了解和熟悉实验室环境，包括计算机硬件配置、操作系统版本等信息。

（2）准备实验材料，包括相关文档、软件工具等。

（3）明确实验任务和目的，制定实验计划。

2.创建进程（1）打开实验环境，启动操作系统。

（2）使用编程语言（如C语言）编写一个简单的程序，该程序将创建一个新的进程。

（3）编译并运行程序，观察和记录进程的创建过程。

3.进程切换（1）编写一个程序，该程序将在两个进程之间进行切换。

（2）运行程序，观察和记录进程切换的过程和效果。

4.进程同步（1）使用信号量或其他同步机制实现两个进程的同步。

（2）运行程序，观察和记录进程同步的过程和效果。

5.进程终止（1）编写一个程序，该程序将终止一个指定的进程。

（2）运行程序，观察和记录进程终止的过程和效果。

6.实验总结与报告编写（1）总结实验过程和结果，梳理实验中的问题和解决方法。

（2）编写实验报告，包括实验目的、原理、步骤、结果分析等。

四、实验结果与分析通过本次实验，我们成功地创建了一个新的进程，并实现了进程之间的切换、同步和终止。

在实验过程中，我们深入理解了进程控制的概念、原理和实现方式，掌握了进程控制的技巧和方法。

同时，我们也遇到了一些问题，如进程创建失败、进程切换不成功等，但通过仔细分析问题原因并采取相应的解决方法，最终成功解决了这些问题。

通过本次实验，我们不仅学到了专业知识，也提高了解决实际问题的能力。

五、实验结论与建议本次实验让我们更加深入地理解了进程控制的相关知识，并掌握了进程控制的基本操作方法。

实验三进程调度实验目的1、理解有关进程控制块、进程队列的概念。

2、掌握进程优先权调度算法和时间片轮转调度算法的处理逻辑。

实验内容与基本要求1、设计进程控制块PCB的结构，分别适用于优先权调度算法和时间片轮转调度算法。

2、建立进程就绪队列。

3、编制两种进程调度算法：优先权调度算法P和时间片轮转调度算法R。

实验报告内容1、优先权调度算法和时间片轮转调度算法原理。

2、程序流程图。

3、程序及注释。

4、运行结果以及结论。

1、优先权调度算法和时间片轮转调度算法原理优先权调度算法：当该算法用于作业调度时，系统从后备作业队列中选择若干个优先级最高的，且系统能满足资源要求的作业装入内存运行；当该算法用于进程调度时，将把处理机分配给就绪进程队列中优先级最高的进程投入运行。

分为非抢占式优先级算法和抢占式优先级算法。

时间片轮转调度算法原理：系统将就绪进程按到达的顺序排成一个队列，按FCFS原则，进程调度程序总是选择就绪队列中的第一个进程执行，且只运行一个时间片。

时间用完后，即使此进程并未完成，仍然将处理机分配给下一个就绪的进程，将此进程返回到就绪队列的末尾，等候重新运行。

2、程序流程图。

3、程序及注释#include <stdio.h>#include <stdlib.h>#include <string.h>typedef struct node{char name[20]; /*进程的名字*/int prio; /*进程的优先级*/int round; /*分配CPU的时间片*/int cputime; /*CPU执行时间*/int needtime; /*进程执行所需要的时间*/char state; /*进程的状态，W--就绪态，R--执行态，F--完成态*/int count; /*记录执行的次数*/struct node *next; /*链表指针*/}PCB;PCB *ready=NULL,*run=NULL,*finish=NULL; /*定义三个队列，就绪队列，执行队列和完成队列*/int num;void GetFirst(); /*从就绪队列取得第一个节点*/void Output(); /*输出队列信息*/void InsertPrio(PCB *in); /*创建优先级队列，规定优先数越小，优先级越高*/void InsertTime(PCB *in); /*时间片队列*/void InsertFinish(PCB *in); /*时间片队列*/void PrioCreate(); /*优先级输入函数*/void TimeCreate(); /*时间片输入函数*/void Priority(); /*按照优先级调度*/void RoundRun(); /*时间片轮转调度*/int main(void){char chose;printf("请输入要创建的进程数目:\n");scanf("%d",&num);getchar();printf("输入进程的调度方法：(P/R)\n");scanf("%c",&chose);switch(chose){case 'P':case 'p':PrioCreate();Priority();break;case 'R':case 'r':TimeCreate();RoundRun();break;default:break;}Output();return 0;}void GetFirst() /*取得第一个就绪队列节点*/{run = ready;if(ready!=NULL){run ->state = 'R';ready = ready ->next;run ->next = NULL;}}void Output() /*输出队列信息*/{PCB *p;/*p = ready;*/printf("进程名\t优先级\t时间片\tcpu时间\t需要时间\t进程状态\t计数器\n");p = ready;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needtime, p->state,p->count);p = p->next;}p = finish;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needtime, p->state,p->count);p = p->next;}p = run;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needtime, p->state,p->count);p = p->next;}}void InsertPrio(PCB *in) /*创建优先级队列，规定优先数越小，优先级越低*/{PCB *fst,*nxt;fst = nxt = ready;if(ready == NULL) /*如果队列为空，则为第一个元素*/{in->next = ready;ready = in;}else /*查到合适的位置进行插入*/{if(in ->prio > fst ->prio) /*比第一个还要大(大于等于)，则插入到队头*/{in->next = ready;ready = in;}else{while(fst->next != NULL) /*移动指针查找第一个别它小的元素的位置进行插入*/{nxt = fst;fst = fst->next;}if(fst ->next == NULL) /*已经搜索到队尾，则其优先级数最小，将其插入到队尾即可*/{in ->next = fst ->next;fst ->next = in;}else /*插入到队列中*/{nxt = in;in ->next = fst;}}}}void InsertTime(PCB *in) /*将进程插入到就绪队列尾部*/ {PCB *fst;fst = ready;if(ready == NULL){in->next = ready;ready = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void InsertFinish(PCB *in) /*将进程插入到完成队列尾部*/ {PCB *fst;fst = finish;if(finish == NULL){in->next = finish;finish = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void PrioCreate() /*优先级调度输入函数*/{PCB *tmp;printf("输入进程名字和进程所需时间：\n");for(i = 0;i < num; i++){if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL){perror("malloc");exit(1);}scanf("%s",tmp->name);getchar(); /*吸收回车符号*/scanf("%d",&(tmp->needtime));tmp ->cputime = 0;tmp ->state ='W';tmp ->prio = 50 - tmp->needtime; /*设置其优先级，需要的时间越多，优先级越低*/tmp ->round = 0;tmp ->count = 0;InsertPrio(tmp); /*按照优先级从高到低，插入到就绪队列*/}}void TimeCreate() /*时间片输入函数*/{PCB *tmp;int i;printf("输入进程名字和进程时间片所需时间：\n");for(i = 0;i < num; i++){if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL){perror("malloc");exit(1);}scanf("%s",tmp->name);getchar();scanf("%d",&(tmp->needtime));tmp ->cputime = 0;tmp ->state ='W';tmp ->prio = 0;tmp ->round = 2; /*假设每个进程所分配的时间片是2*/tmp ->count = 0;InsertTime(tmp);}void Priority() /*按照优先级调度，每次执行一个时间片*/{int flag = 1;GetFirst();while(run != NULL) /*当就绪队列不为空时，则调度进程如执行队列执行*/{Output(); /*输出每次调度过程中各个节点的状态*/while(flag){run->prio -= 0; /*优先级减去三,若设为0则优先级不变*/run->cputime++; /*CPU时间片加一*/run->needtime--;/*进程执行完成的剩余时间减一*/if(run->needtime == 0)/*如果进程执行完毕，将进程状态置为F，将其插入到完成队列*/{run ->state = 'F';run->count++; /*进程执行的次数加一*/InsertFinish(run);flag = 0;}else /*将进程状态置为W，入就绪队列*/{run->state = 'W';run->count++; /*进程执行的次数加一*/InsertTime(run);flag = 0;}}flag = 1;GetFirst(); /*继续取就绪队列队头进程进入执行队列*/}}void RoundRun() /*时间片轮转调度算法*/{int flag = 1;GetFirst();while(run != NULL){Output();while(flag){run->count++;run->cputime++;run->needtime--;if(run->needtime == 0) /*进程执行完毕*/{run ->state = 'F';InsertFinish(run);flag = 0;}else if(run->count == run->round)/*时间片用完*/{run->state = 'W';run->count = 0; /*计数器清零，为下次做准备*/InsertTime(run);flag = 0;}}flag = 1;GetFirst();}}4、运行结果以及结论。

实验三进程控制与描述➢背景知识➢实验目的➢工具/准备工作➢实验内容与步骤背景知识Windows的任务管理器提供了用户计算机上正在运行的程序和进程的相关信息，也显示了最常用的度量进程性能的单位。

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

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

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

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

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

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

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

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

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

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

图6Windows的任务管理器在本次实验中，你使用的操作系统版本是：Windows 7 旗舰版当前机器中由你打开，正在运行的应用程序有：1)Word文档2)QQ3)控制面板4)U盘Windows“任务管理器”的窗口由__6__个选项卡组成，分别是：1)应用程序2)进程3)服务4)性能5)联网6)用户当前“进程”选项卡显示的栏目分别是(可移动窗口下方的游标/箭头，或使窗口最大化进行观察)：1) 映像名称 2) 用户名3) CPU 4)内存（专用工作集）5)描述1.使用任务管理器终止进程步骤1：单击“进程”选项卡，一共显示了___55___个进程。

进程控制实验报告进程控制实验报告一、引言进程控制是操作系统中的重要概念，它涉及到进程的创建、调度、终止等方面。

本篇实验报告将介绍我们在进程控制实验中所进行的工作和实验结果。

二、实验目的本次实验的目的是通过编写程序，了解进程的创建、调度和终止过程，并掌握相关的系统调用和操作。

三、实验环境我们使用的实验环境是Linux操作系统，并使用C语言编写程序。

四、实验步骤1. 进程创建在实验中，我们编写了一个简单的程序，用于创建新的进程。

通过调用系统调用fork()，我们可以在父进程中创建一个子进程。

子进程是父进程的副本，它们共享一些资源，但有各自独立的执行空间。

2. 进程调度在实验中，我们使用了系统调用exec()来进行进程调度。

通过调用exec()，我们可以在一个进程中执行另一个可执行文件。

这样，原来的进程将被替换为新的进程，并开始执行新的程序。

3. 进程终止在实验中，我们使用了系统调用exit()来终止一个进程。

当一个进程执行完毕或者遇到错误时，可以调用exit()来结束自己的执行。

同时，exit()函数还可以传递一个整数值作为进程的返回值，供其他进程获取。

五、实验结果通过实验，我们成功地创建了多个进程，并进行了调度和终止操作。

我们观察到，创建的子进程在父进程的基础上执行，并且具有独立的执行空间。

在调度过程中，我们能够看到进程的切换和执行结果的输出。

在终止过程中，我们成功地结束了进程的执行，并获取了进程的返回值。

六、实验总结通过本次实验，我们深入了解了进程控制的相关概念和操作。

我们通过编写程序，实际操作了进程的创建、调度和终止过程。

这些实验结果对于我们理解操作系统的工作原理和进程管理机制具有重要意义。

七、实验感想本次实验让我们深刻认识到进程控制在操作系统中的重要性。

进程的创建、调度和终止是操作系统能够高效运行的基础。

通过实验，我们不仅掌握了相关的系统调用和操作，还加深了对操作系统原理的理解。

八、实验改进在实验中，我们可以进一步扩展功能，例如实现进程间的通信和同步机制。