模拟进程管理(c语言)
进程管理实验报告
实验名称: 进程管理实验要求:阅读后面的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]为下一条指令地址。
c语言实现进程控制的实验原理
c语言实现进程控制的实验原理进程控制是操作系统中非常重要的一个概念，它涉及到对进程的创建、终止、挂起、恢复等操作。
本文将以C语言为例，介绍进程控制的实验原理。
一、进程控制的基本概念进程是计算机系统中正在运行的程序的实例。
操作系统通过进程控制来管理和控制进程的运行。
进程控制的基本概念包括进程创建、进程终止、进程挂起和进程恢复等。
1. 进程创建进程的创建是指在操作系统中创建一个新的进程。
在C语言中，可以使用fork()函数来创建一个新的进程。
fork()函数会创建一个子进程，子进程是父进程的一个副本，它们共享代码段、数据段和堆栈段。
子进程的代码从fork()函数之后开始执行，而父进程的代码继续执行。
通过判断fork()函数的返回值，可以确定当前是在父进程还是子进程中。
2. 进程终止进程的终止是指进程的执行结束或被强制终止。
在C语言中，可以使用exit()函数来终止当前进程的执行。
exit()函数会将进程的退出状态传递给父进程，并释放进程所占用的系统资源。
3. 进程挂起和恢复进程的挂起是指将一个正在运行的进程暂停执行，而进程的恢复是指将一个挂起的进程重新开始执行。
在C语言中，可以使用sleep()函数来使进程挂起一段时间。
sleep()函数会暂停当前进程的执行，直到指定的时间过去。
而进程的恢复可以通过设置一个定时器来实现，当定时器时间到达时，进程将恢复执行。
二、进程控制的实验原理为了更好地理解进程控制的原理，我们可以通过一个简单的实验来进行演示。
我们创建一个C语言程序，其中包含一个主进程和一个子进程。
主进程负责创建子进程，并通过信号机制来控制子进程的挂起和恢复。
```c#include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <signal.h>// 子进程的处理函数void child_process(){printf("Child process starts running.\n");sleep(5);printf("Child process finishes.\n");exit(0);}int main(){pid_t pid;// 创建子进程pid = fork();if (pid < 0){printf("Failed to create child process.\n"); return -1;}else if (pid == 0){// 子进程child_process();}else{// 父进程printf("Parent process starts running.\n");// 等待子进程运行5秒后发送SIGSTOP信号，使其挂起sleep(5);printf("Parent process sends SIGSTOP signal.\n");kill(pid, SIGSTOP);// 等待2秒后发送SIGCONT信号，使子进程恢复执行sleep(2);printf("Parent process sends SIGCONT signal.\n");kill(pid, SIGCONT);// 等待子进程结束wait(NULL);printf("Parent process finishes.\n");}return 0;}```在上面的代码中，我们首先使用fork()函数创建了一个子进程。
计算机专业基础综合(进程管理)模拟试卷7
计算机专业基础综合（进程管理）模拟试卷7(总分：64.00，做题时间：90分钟)一、<B>单项选择题1-40小题。
下列每题给出的四个选项中，只有一个选项是最符合题目要求的。
</B>(总题数：22，分数：44.00)1.下列选项中，导致创建新进程的操作是( )。
I．用户登录成功Ⅱ．设备分配Ⅲ．启动程序执行A.仅I和ⅢB.仅Ⅱ和ⅢC.仅I和Ⅲ√D.I、Ⅱ、Ⅲ用户登录成功、启动程序执行均会导致创建新进程，而设备分配则不会。
2.下列选项中，操作系统提供给应用程序使用的接口是( )。
A.系统调用√B.中断C.库函数D.原语在现代操作系统中，操作系统提供了包括系统调用、命令接口、图形接口等方便用户使用系统资源的接口，在上述接口中，只有系统调用是提供给程序使用的。
3.下列进程调度算法中，综合考虑了进程等待时间和执行时间的是( )。
A.时间片轮转调度算法B.最短进程优先调度算法C.先来先服务调度算法D.高响应比优先调度算法√在若干进程调度算法中，时间片轮转调度算法考虑的是时间分配上的均衡，最短进程优先调度算法主要考虑的是短作业的等待时间，先来先服务调度算法考虑的是到达顺序的合理性，而只有高响应比优先调度算法做到了综合考虑进程等待时间和执行时间。
4.单处理机系统中，可并行的是( )。
I．进程与进程Ⅱ．处理机与设备Ⅲ．处理机与通道Ⅳ．设备与设备A.I、Ⅱ和ⅢB.I、Ⅱ和ⅣC.I、Ⅲ和ⅣD.Ⅱ、Ⅲ和Ⅳ√在单处理机系统中，仅有一个处理机，所以在一个特定的时刻只能有一个进程能够获得处理机的使用权，因而排除选项A、B和C，只有选项D是合理的答案。
5.如果有一个进程从运行状态变成等待状态，或完成工作后就撤销，则必定会发生( )。
A.进程切换√B.存储器再分配C.时间片轮转D.死锁此题主要考查进程切换的相关内容。
进程调度将从就绪队列中另选一个进程占用处理机。
使一个进程让出处理要，由另一个进程占用处理机的过程称为进程切换。
操作系统实验二：进程管理
操作系统实验二：进程管理操作系统实验二：进程管理篇一：操作系统实验报告实验一进程管理一、目的进程调度是处理机管理的核心内容。
本实验要求编写和调试一个简单的进程调度程序。
通过本实验加深理解有关进程控制块、进程队列的概念，并体会和了解进程调度算法的具体实施办法。
二、实验内容及要求1、设计进程控制块PCB的结构（PCB结构通常包括以下信息：进程名（进程ID）、进程优先数、轮转时间片、进程所占用的CPU时间、进程的状态、当前队列指针等。
可根据实验的不同，PCB结构的内容可以作适当的增删）。
为了便于处理，程序中的某进程运行时间以时间片为单位计算。
各进程的轮转时间数以及进程需运行的时间片数的初始值均由用户给定。
2、系统资源(r1…rw),共有w类，每类数目为r1…rw。
随机产生n进程Pi(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为时间片大小（毫秒）//对进程进行初始化，建立就绪数组、阻塞数组。
操作系统原理实验
操作系统原理实验一、实验目的本实验旨在通过实际操作，加深对操作系统原理的理解，掌握操作系统的基本功能和调度算法。
二、实验环境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. 完成实验后，整理实验报告，包括实验目的、实验环境、实验内容、实验步骤和实验结果等。
(完整word版)进程管理实验报告源代码
实验一进程管理1．目的和要求通过实验理解进程的概念，进程的组成（PCB结构），进程的并发执行和操作系统进行进程管理的相关原语（主要是进程的创建、执行、撤消）。
2．实验内容用C语言编程模拟进程管理，至少要有：创建新的进程；查看运行进程；换出某个进程；杀死运行进程以及进程之间通信等功能。
3．实验环境Windows操作系统、VC++6.0C语言4．实验提示PCB结构通常包括以下信息：进程名，进程优先数，轮转时间片，进程所占用的CPU时间，进程的状态，当前队列指针等。
可根据实验的不同，PCB结构的内容可以作适当的增删。
主体程序#include "conio.h"#include "stdio.h"#include "stdlib.h"struct jincheng_type{int pid;int youxian;int daxiao;int msg;int live;};struct jincheng_type neicun[20],waicun[20];int shumu=0,pid_l;main(){int n,m,i;char 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.进程之间通信 6.退出");printf("\n********************************************");printf("\n请选择（1～6) ");a=getch();switch(a){case'1':create( );break;case'2':viewrun( );break;case'3':huanchu();break;case'4':kill( );break;case'5':tongxun( );break;case'6': exit(0);default: n=0;}}}create( ) /* 创建一个进程的示例（不完整的程序）*/ {if(shumu>=20){printf("\n内存已满，请先结束或换出进程\n");}else{printf("\n请输入新进程的pid\n");scanf("%d",&neicun[shumu+1].pid);printf("\n请输入新进程的优先级\n");scanf("%d",&neicun[shumu+1].youxian);printf("\n请输入新进程的大小\n");scanf("%d",&neicun[shumu+1].daxiao);printf("\n请输入新进程的消息\n");scanf("%d",&neicun[shumu+1].msg);neicun[shumu+1].live=1;shumu++;}return neicun[shumu-1].live;}viewrun( )/*查看运行进程*/{int vpid;printf("\n请输入进程的pid\n");scanf("%d",&vpid);if(vpid>0&&vpid<=20&&neicun[vpid].live==1){printf("\n进程的pid是: %d\n",neicun[vpid].pid);printf("进程的优先级是: %d\n",neicun[vpid].youxian);printf("进程的大小是:%d\n",neicun[vpid].daxiao);printf("进程的消息是:%d\n",neicun[vpid].msg);}else{printf("\n所查看运行进程不存在\n");}printf("请按回车退出查看\n");vpid=getch();}huanchu()/*换出某个进程*/{int pid1,pid2;char c;printf("\n请输入第一个替换进程的pid\n");scanf("%d",&pid1);printf("\n请输入第二个替换进程的pid\n");scanf("%d",&pid2);if(pid1>0&&pid1<=20&&neicun[pid1].live==1){if(neicun[pid1].youxian>neicun[pid2].youxian){waicun[20].pid=neicun[pid1].pid;waicun[20].youxian=neicun[pid1].youxian;waicun[20].daxiao=neicun[pid1].daxiao;waicun[20].msg=neicun[pid1].msg;neicun[pid1].pid=neicun[pid2].pid;neicun[pid1].youxian=neicun[pid2].youxian;neicun[pid1].daxiao=neicun[pid2].daxiao;neicun[pid1].msg=neicun[pid2].msg;neicun[pid2].pid=waicun[20].pid;neicun[pid2].youxian=waicun[20].youxian;neicun[pid2].daxiao=waicun[20].daxiao;neicun[pid2].msg=waicun[20].msg;printf("\n替换完成\n");printf("\n被替换进程的pid是: %d\n",waicun[20].pid); printf("被替换进程的优先级是: %d\n",waicun[20].youxian); printf("被替换进程的大小是:%d\n",waicun[20].daxiao); printf("被替换进程的消息是:%d\n",waicun[20].msg);}else{printf("\n进程优先级不够大");}}else{printf("所查看运行进程不存在");}printf("请按回车退出换出进程\n");c=getche();return;}kill()/*杀死运行进程*/{int kpid;printf("\n请输入进程的pid\n");scanf("%d",&kpid);if(kpid>0&&kpid<20&&neicun[kpid].live==1){neicun[kpid].live=0;}return;}tongxun( )/*进程之间通信*/{int tpid1,tpid2;int buffer;char d;printf("\n请输入通信源进程pid\n");scanf("%d",&tpid1);printf("\n请输入通信目的进程pid\n");scanf("%d",&tpid2);if(tpid1>0&&tpid1<20&&neicun[tpid1].live==1){buffer=neicun[tpid1].msg;neicun[tpid1].msg=neicun[tpid2].msg;neicun[tpid2].msg=buffer;printf("\n源进程的消息是: %d\n",neicun[tpid1].msg);printf("\n目的进程的消息是: %d\n",neicun[tpid2].msg);}else{printf("\n所查看运行进程不存在\n");}printf("\n请按回车退出进程通信\n");d=getch();return;}5．实验运行结果******************************************** * 进程演示系统* ********************************************1.创建新的进程2.查看运行进程3.换出某个进程4.杀死运行进程5.进程之间通信6.退出系统******************************************** 请选择（1～6）然后根据你选择的不同，出现不同的结果。
电大操作系统实验报告3_ 进程管理实验
电大操作系统实验报告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 程序，创建一个子进程，子进程进入睡眠状态一段时间，然后被唤醒并输出状态转换信息。
C语言操作系统编程进程管理和内存管理
C语言操作系统编程进程管理和内存管理1. 概述操作系统是计算机系统中最核心的软件之一，它负责管理计算机的硬件资源并提供应用程序运行的环境。
编写操作系统需要掌握底层硬件知识、算法与数据结构以及编程语言。
本文将重点介绍C语言在操作系统编程中的进程管理和内存管理实践。
2. 进程管理2.1 进程与线程的概念在操作系统中，进程是指一个正在运行的程序实例，它具有自己的内存空间、代码、数据和文件等资源。
线程是进程的执行单元，一个进程可以拥有多个线程，它们共享进程的资源。
2.2 进程创建和销毁在C语言中，可以利用操作系统提供的API来创建和销毁进程。
常用的API包括`fork()`、`exec()`和`exit()`等。
`fork()`函数可以创建一个新的进程，`exec()`函数可以用新的程序替换当前进程的代码和数据段，`exit()`函数可以正常或异常地退出进程。
2.3 进程调度进程调度决定了系统中哪个进程在什么时候运行。
C语言通过操作系统提供的API进行进程调度，如`sched_yield()`函数可以让出CPU，`sleep()`函数可以使进程进入休眠状态。
此外，还可以使用多线程编程来实现并发执行。
3. 内存管理3.1 内存模型在操作系统中，内存被划分为多个区域，如代码段、数据段、堆和栈等。
C语言程序的内存布局包括：全局变量、静态变量、堆、栈等。
3.2 动态内存分配动态内存分配是指程序在运行过程中根据需要动态地分配和释放内存。
C语言提供了`malloc()`和`free()`函数来实现动态内存分配。
使用时应注意避免内存泄漏和悬空指针等问题。
3.3 内存保护和地址空间操作系统通过内存保护机制来避免不同进程之间的内存访问冲突。
C语言通过指针操作来访问内存，需要合理地使用指针，并通过操作系统提供的API实现内存保护。
4. 示例代码以下是一个简单的示例代码，演示了C语言操作系统编程中的进程管理和内存管理：```c#include <stdio.h>#include <stdlib.h>int main() {// 创建子进程int pid = fork();if (pid < 0) {printf("进程创建失败\n");exit(1);} else if (pid == 0) {// 子进程执行的代码printf("子进程ID：%d\n", getpid()); printf("父进程ID：%d\n", getppid()); exit(0);} else {// 父进程执行的代码printf("父进程ID：%d\n", getpid()); printf("子进程ID：%d\n", pid);}return 0;}```5. 总结本文介绍了C语言操作系统编程中的进程管理和内存管理。
进程管理实验报告代码
一、实验目的1. 理解进程的概念和进程状态转换。
2. 掌握进程同步与互斥的基本方法。
3. 学习使用信号量实现进程同步与互斥。
4. 熟悉进程调度算法。
二、实验环境1. 操作系统：Windows/Linux2. 编程语言：C/C++3. 开发工具：Visual Studio/Code::Blocks三、实验内容1. 进程状态转换2. 进程同步与互斥3. 信号量实现进程同步与互斥4. 进程调度算法四、实验步骤1. 进程状态转换```c#include <stdio.h>#include <unistd.h>void print_status(int state) {switch (state) {case 1: printf("创建状态\n"); break; case 2: printf("就绪状态\n"); break;case 3: printf("运行状态\n"); break; case 4: printf("阻塞状态\n"); break; case 5: printf("终止状态\n"); break; default: printf("未知状态\n"); break; }}int main() {int state = 1;print_status(state);sleep(1);state = 2;print_status(state);sleep(1);state = 3;print_status(state);sleep(1);state = 4;print_status(state);sleep(1);state = 5;print_status(state);return 0;}```2. 进程同步与互斥```c#include <stdio.h>#include <pthread.h>pthread_mutex_t lock;void thread_func(void arg) {pthread_mutex_lock(&lock);printf("线程 %d 进入临界区\n", (int )arg);sleep(2);printf("线程 %d 离开临界区\n", (int )arg);pthread_mutex_unlock(&lock);return NULL;}int main() {pthread_t tid1, tid2;int arg1 = 1, arg2 = 2;pthread_mutex_init(&lock, NULL);pthread_create(&tid1, NULL, thread_func, &arg1); pthread_create(&tid2, NULL, thread_func, &arg2); pthread_join(tid1, NULL);pthread_join(tid2, NULL);pthread_mutex_destroy(&lock);return 0;}```3. 信号量实现进程同步与互斥```c#include <stdio.h>#include <pthread.h>#include <semaphore.h>sem_t sem;void thread_func(void arg) {sem_wait(&sem);printf("线程 %d 进入临界区\n", (int )arg);sleep(2);printf("线程 %d 离开临界区\n", (int )arg);sem_post(&sem);return NULL;}int main() {pthread_t tid1, tid2;int arg1 = 1, arg2 = 2;sem_init(&sem, 0, 1);pthread_create(&tid1, NULL, thread_func, &arg1); pthread_create(&tid2, NULL, thread_func, &arg2);pthread_join(tid1, NULL);pthread_join(tid2, NULL);sem_destroy(&sem);return 0;}```4. 进程调度算法```c#include <stdio.h>#include <stdlib.h>#include <unistd.h>#define MAX_PROCESSES 5typedef struct {int pid;int arrival_time;int burst_time;int wait_time;int turnaround_time;} Process;int compare(const void a, const void b) {Process proc1 = (Process )a;Process proc2 = (Process )b;return proc1->arrival_time - proc2->arrival_time;}void fcfs(Process processes[], int n) {processes[0].wait_time = 0;processes[0].turnaround_time = processes[0].burst_time;for (int i = 1; i < n; i++) {processes[i].wait_time = processes[i - 1].turnaround_time + processes[i].arrival_time - processes[i].burst_time;processes[i].turnaround_time = processes[i].wait_time + processes[i].burst_time;}}int main() {Process processes[MAX_PROCESSES] = {{1, 0, 3, 0, 0},{2, 1, 6, 0, 0},{3, 4, 4, 0, 0},{4, 6, 5, 0, 0},{5, 8, 2, 0, 0}};qsort(processes, MAX_PROCESSES, sizeof(Process), compare);fcfs(processes, MAX_PROCESSES);for (int i = 0; i < MAX_PROCESSES; i++) {printf("PID: %d, Wait Time: %d, Turnaround Time: %d\n", processes[i].pid, processes[i].wait_time, processes[i].turnaround_time);}return 0;}```五、实验结果与分析通过以上实验，我们了解了进程状态转换、进程同步与互斥、信号量实现进程同步与互斥以及进程调度算法。
操作系统实训报告
操作系统实训报告一、实训背景操作系统是计算机系统中最基本的软件之一，它负责管理计算机系统的各种资源，如内存、CPU、磁盘等。
为了更好地掌握操作系统的原理和实现，我们在课程中进行了一系列的操作系统实训。
二、实训内容1. 实验环境搭建在开始实验之前，我们需要先搭建好实验环境。
我们使用了虚拟机软件VMware Workstation来模拟一个计算机系统，并安装了Ubuntu 操作系统作为我们的实验平台。
2. 实验任务在本次实训中，我们主要完成了以下几个任务：（1）进程管理：通过编写一个简单的C程序来模拟进程创建、销毁和调度等操作。
（2）内存管理：通过编写一个简单的C程序来模拟内存分配和回收等操作。
（3）文件系统：通过使用Linux命令行工具来创建、读取和删除文件，并学习了文件权限管理等知识。
三、实训过程1. 进程管理首先，我们使用C语言编写了一个简单的程序，用于模拟进程创建和销毁。
程序首先创建一个父进程，并利用fork()函数创建两个子进程。
然后，父进程等待子进程结束后输出一条消息并退出。
接着，我们修改了程序，使用了wait()函数来实现进程调度。
wait()函数可以让父进程等待子进程结束后再继续执行。
我们在程序中使用了两个wait()函数来实现进程的顺序执行。
最后，我们添加了一个信号处理函数，用于处理子进程结束时发送的SIGCHLD信号。
信号处理函数可以在子进程结束时立即执行，不需要等待父进程调度。
2. 内存管理接下来，我们使用C语言编写了一个简单的程序，用于模拟内存分配和回收。
程序首先创建一个指向整型数组的指针，并使用malloc()函数动态分配一块内存。
然后，在内存中写入一些数据，并输出到屏幕上。
最后，使用free()函数释放内存并退出程序。
在编写程序时，我们注意到malloc()和free()函数是操作系统提供的内存管理接口。
malloc()函数可以动态分配一块指定大小的内存，并返回一个指向该内存区域的指针；而free()函数可以释放之前分配的内存。
计算机专业基础综合操作系统(进程管理)模拟试卷1(题后含答案及解析)
计算机专业基础综合操作系统（进程管理）模拟试卷1(题后含答案及解析)题型有：1. 单项选择题 2. 综合应用题单项选择题1-40小题，每小题2分，共80分。
下列每题给出的四个选项中，只有一个选项是最符合题目要求的。
1．进程处于( )等待状态时，它是处于非阻塞状态的。
A．等待从键盘输入数据B．等待协作进程的一个信号C．等待操作系统分配CPU时间D．等待网络数据进入内存正确答案：C 涉及知识点：操作系统2．下列叙述中，错误的是( )。
A．操作系统是用户与计算机之间的接口B．程序的并发执行，使程序失去了顺序执行时具有的封闭性和可再现性，程序与程序的执行不再一一对应C．进程从一个状态到另一个状态的转换，都是靠使用不同的原语来实现的D．在单CPU系统中，任何时刻处于就绪状态的进程有多个，而且只有处于就绪状态的进程经调度程序选中后才可进入运行状态正确答案：C解析：从用户的角度看，操作系统是用户使用计算机的桥梁，用户通过操作系统的两类接口来达到操纵计算机的目的。
选项A正确。
选项B的叙述也是正确的，因为这正是引入进程概念的原因。
进程从一个状态到另一个状态的转换是一个非常复杂的过程，除了要使用不同的原语外，有时还要借助于硬件触发器才能完成。
例如，UNIX系统中，从系统态到用户态的转换要借助硬件触发器。
因此，选项C错误。
处于就绪状态的进程已经获得了除CPU之外的所有资源，由于只有一个CPU，任何时刻就只能有一个进程获得CPU，而其他的就只能在就绪状态对应的队列上排队等待调度程序的调度。
所以选项D也正确。
知识模块：操作系统3．进程调度是从( )选择一个进程投入运行的。
A．就绪队列B．等待队列C．作业后备队列D．提交队列正确答案：A解析：处于就绪队列的进程是获得了除处理机以外的所有资源处于准备执行的状态。
进程调度就是负责从就绪队列中挑选进程投入运行的。
知识模块：操作系统4．下列叙述中，正确的是( )。
A．分时系统中，时间片越小，响应时间越长B．多道程序的引入，主要是为了提高CPU及其他资源的利用率C．飞机票订票系统是分时系统D．PCB是进程存在的唯一标志，而程序是系统感知进程存在的唯一实体正确答案：B解析：分时系统的响应时间T≈nq，n是用户数目，而q是时间片。
进程管理实验报告
进程管理实验报告
摘要：
进程管理是操作系统中的重要概念之一，它涉及到进程的创建、调度和终止等方面。
本实验通过使用C语言编写一个简单的进程管
理程序来加深对进程管理原理的理解。
实验分为进程创建、调度和
终止三个部分，通过实验结果可以验证进程管理算法的正确性和效率。
1. 引言
进程是计算机中进行资源分配和调度的基本单位，它代表了一
个正在运行的程序。
进程管理是操作系统中的一个核心功能，负责
分配资源、调度进程和管理进程的状态等。
通过对进程管理的研究
和实验，可以深入了解操作系统的工作原理，并且优化进程管理算法，提高系统性能。
2. 实验目的
本实验的主要目的是通过编写一个进程管理程序，实现进程的创建、调度和终止等功能。
通过实验，验证进程管理算法的正确性和效率，并加深对进程管理原理的理解。
3. 实验环境
本实验使用C语言进行编程，采用Linux操作系统。
4. 实验内容
4.1 进程创建
进程创建是指操作系统为程序创建一个进程，使其能够在系统中运行。
在本实验中，我们使用fork()函数创建一个子进程，并通过exec()函数加载可执行文件。
4.2 进程调度
进程调度是指根据一定的算法选择哪个进程优先执行。
常见的调度算法有先来先服务（FCFS）、最短作业优先（SJF）、优先级调度等。
在本实验中，我们选择简单的先来先服务调度算法。
4.3 进程终止。
实验二-实验报告(进程管理)
实验二模拟实现进程管理组长：李和林软件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）模拟进程管理专业：信息管理与信息系统班级：信管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. 掌握Linux环境下进程的创建、调度、同步与通信等基本操作。
3. 通过实验加深对进程管理知识的理解和应用。
二、实验环境1. 操作系统：Linux2. 实验工具：xshell、vi编辑器、gcc编译器三、实验内容1. 进程的创建与终止2. 进程的调度策略3. 进程同步与互斥4. 进程间的通信四、实验步骤1. 进程的创建与终止（1）编写C语言程序，使用fork()系统调用创建子进程。
（2）通过exec()系统调用执行新的程序，实现进程替换。
（3）使用waitpid()函数等待子进程结束。
（4）使用kill()函数终止指定进程。
2. 进程的调度策略（1）观察Linux系统中进程调度算法，如FCFS、RR、SJF等。
（2）编写程序，模拟不同的调度算法，分析其性能。
3. 进程同步与互斥（1）使用信号量实现进程同步，如生产者-消费者问题。
（2）使用互斥锁实现进程互斥，如银行家算法。
4. 进程间的通信（1）使用管道实现进程间通信。
（2）使用消息队列实现进程间通信。
（3）使用共享内存实现进程间通信。
五、实验结果与分析1. 进程的创建与终止通过实验，我们掌握了使用fork()、exec()、waitpid()、kill()等系统调用创建、替换、等待和终止进程的方法。
在实际应用中，进程的创建与终止是进程管理的基础。
2. 进程的调度策略通过模拟不同的调度算法，我们发现FCFS算法简单，但效率较低；RR算法适用于交互式系统，但可能导致进程饥饿；SJF算法效率较高，但难以实现。
在实际应用中，应根据系统需求选择合适的调度算法。
3. 进程同步与互斥通过使用信号量和互斥锁，我们实现了进程同步与互斥。
在实际应用中，进程同步与互斥是保证系统正确性和效率的关键。
4. 进程间的通信通过使用管道、消息队列和共享内存，我们实现了进程间的通信。
在实际应用中，进程间的通信是提高系统并发性和效率的重要手段。
模拟进程创建实验报告(3篇)
第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. 编写主函数，模拟进程创建、运行和销毁过程。
c语言实现多级反馈队列调度的算法模拟进程的控制
c语言实现多级反馈队列调度的算法模拟进程的控制目录1. 引言1.1 背景和意义1.2 结构概述1.3 目的2. 多级反馈队列调度算法2.1 基本原理2.2 算法设计思路2.3 算法流程图3. C语言实现模拟进程控制3.1 数据结构定义3.2 进程创建与销毁3.3 进程调度与执行4. 实验结果与分析4.1 实验环境介绍4.2 实验结果展示4.3 结果分析与讨论5. 结论与展望5.1 结论总结5.2 存在问题与改进方向1. 引言1.1 背景和意义在计算机科学领域，进程调度是操作系统中非常重要的一个功能。
它负责决定哪个进程可以使用CPU并以何种顺序执行。
进程调度算法的优劣直接影响了系统的性能和效率。
多级反馈队列调度算法是一种常用的进程调度算法之一，它可以根据进程的类型和优先级将进程划分到不同的队列中，并根据优先级来决定进程的执行顺序。
该算法兼具公平性和高响应时间两个特点，适合应用于多任务环境下。
本文旨在使用C语言实现模拟多级反馈队列调度算法，并通过模拟进程控制过程，探讨其在实际应用中的表现。
通过实验结果与分析，我们将评估该算法在不同场景下的性能指标，并对其中存在问题提出改进方向。
1.2 结构概述本文共分为五个部分组成：•引言：介绍本文撰写目的、研究背景以及多级反馈队列调度算法在进程控制中的重要性。
•多级反馈队列调度算法：详细介绍多级反馈队列调度算法的基本原理、设计思路和算法流程图。
•C语言实现模拟进程控制：描述C语言中如何定义数据结构以及实现进程的创建、销毁以及调度和执行过程。
•实验结果与分析：介绍实验环境并展示实验结果，对结果进行分析和讨论。
•结论与展望：总结本文的研究成果，并提出该算法在应用过程中存在的问题以及改进方向。
通过以上结构安排，我们将全面深入地探讨多级反馈队列调度算法在模拟进程控制中的应用。
1.3 目的本文旨在通过使用C语言实现多级反馈队列调度算法，模拟进程控制过程。
通过对该算法进行分析和实验，目标如下：1.探讨多级反馈队列调度算法在不同场景下的优劣势，并对其性能指标进行评估。
计算机专业基础综合(进程管理)模拟试卷2(题后含答案及解析)
计算机专业基础综合（进程管理）模拟试卷2(题后含答案及解析) 题型有：1. 单项选择题 2. 综合应用题单项选择题1-40小题，每小题2分，共80分。
下列每题给出的四个选项中，只有一个选项是最符合题目要求的。
1．“可抢占”和“不可抢占”的优先级调度算法相比，( )。
A．前者开销小B．前者开销大C．两者开销大致相同D．两者开销不能相比正确答案：B解析：因为“可抢占”优先级调度始终保证在处理机上运行的是优先级最高的进程，这样，当处理机正在运行某个进程时，很可能会被其他优先级更高的进程“抢占”引起处理机调度，与“不可抢占”算法相比，前者的调度次数会更频繁，而每调度一次都会引起保护现场、恢复现场的工作，所以“可抢占”的优先级调度算法开销更大。
知识模块：进程管理2．一个进程获得了除CPU以外的所有资源，则该进程可能处于( )状态。
A．运行B．就绪C．等待D．就绪和等待正确答案：B解析：处于就绪状态的进程，只要获得处理机(被进程调度选中)，即可变为运行状态。
知识模块：进程管理3．银行家算法在解决死锁问题中是用于( )的。
A．预防死锁B．避免死锁C．检测死锁D．解除死锁正确答案：B解析：本题考查银行家算法在分配资源时采用安全性检查，从而避免死锁。
知识模块：进程管理4．保护现场是指将现场信息保存至( )。
A．磁盘B．各相应的寄存器C．进程的PCB中D．内存系统区正确答案：C解析：进程控制块(PCB)是记录进程有关信息的一块主存，其中包括该进程的中断现场保护区，它是进程存在的唯一标识。
知识模块：进程管理5．计算机系统中判别是否有中断事件发生应是在( )。
A．进程切换时B．执行完一条指令后C．执行P操作后D．由用户态转入核心态时正确答案：B解析：系统中，只有当执行完一条指令后，才判别是否有中断发生。
知识模块：进程管理6．若当前进程因时间片用完而让出处理机时，该进程应转变为( )状态。
A．就绪B．等待C．运行D．完成正确答案：A解析：当时间片用光后，进程变为就绪状态。
全国自考操作系统(进程管理)模拟试卷2.doc
（B）可以有多个
（C）不能被挂起
（D）必须在执行完后才能被撤下
5用户编写的C程序中的自动变量位于进程映像的_______部分。
（A）数据段
（Bபைடு நூலகம்用户栈
（C）正文段
（D）堆段
6在单CPU的操作系统中，如当前共有4个进程，其中1个进程在核心态下执行，至少有_______个进程处于核心态。
（A）1
（C）后者可并发执行，前者则不行
（D）前者是批处理的，后者是分时的
3某一进程从阻塞状态进入就绪状态可能原因之一是_______。
（A）现运行进程运行结束
（B）现运行进程执行了semWait操作
（C）现运行进程执行了semSignal操作
（D）现运行进程时间片用完
4在UNIX的单处理机系统中，处于SRUN状态的进程_______。
（B）2
（C）3
（D）4
7 UNIX的切换调度程序swtch的第一部分和第三部分涉及进程现场的保护和恢复，在该程序中保护和恢复的一般是_______的现场。
（A）系统进程
（B）用户进程
（C）同一个进程
（D）不同的进程
8在UNIX系统中，核心发现了可能更适合占用处理机的进程，设置了强迫调度标志_______。
（A）runout
（B）runin
（C）runrun
（D）flag
9父进程刚执行了系统调用fork创建一个子进程后，这个子进程的初始状态为_______。
（A）创建态
（B）睡眠态
（C）就绪态
（D）等待态
二、填空题
10作业控制方式有_______和_______。
11在图3—1中，①表示_______状态。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
typedef struct node
{
char name[10]; /*进程标识符*/
int prio; /*进程优先数*/
int round; /*进程时间轮转时间片*/
int cputime; /*进程占用CPU时间*/
int needtime; /*进程到完成还要的时间*/
int count; /*计数器*/
char state; /*进程的状态*/
struct node *next; /*链指针*/
}PCB;
PCB *finish,*ready,*tail,*run; /*队列指针*/
int N; /*进程数*/
/*将就绪队列中的第一个进程投入运行*/
firstin()
{
run=ready; /*就绪队列头指针赋值给运行头指针*/
run->state='R'; /*进程状态变为运行态*/
ready=ready->next; /*就绪对列头指针后移到下一进程*/
}
/*标题输出函数*/
void prt1(char a)
{
if(toupper(a)=='P') /*优先数法*/
printf(" 进程号cpu时间所需时间优先数状态\n");
else
printf(" 进程号cpu时间所需时间记数时间片状态\n"); }
/*进程PCB输出*/
void prt2(char a,PCB *q)
{
if(toupper(a)=='P') /*优先数法的输出*/
printf(" %-10s%-10d%-10d%-10d %c\n",q->name,
q->cputime,q->needtime,q->prio,q->state);
else/*轮转法的输出*/
printf(" %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,
q->cputime,q->needtime,q->count,q->round,q->state);
}
/*输出函数*/
{
PCB *p;
prt1(algo); /*输出标题*/
if(run!=NULL) /*如果运行指针不空*/
prt2(algo,run); /*输出当前正在运行的PCB*/ p=ready; /*输出就绪队列PCB*/
while(p!=NULL)
{
prt2(algo,p);
p=p->next;
}
p=finish; /*输出完成队列的PCB*/
while(p!=NULL)
{
prt2(algo,p);
p=p->next;
}
getchar(); /*压任意键继续*/
}
/*优先数的插入算法*/
insert1(PCB *q)
{
PCB *p1,*s,*r;
int b;
s=q; /*待插入的PCB指针*/
p1=ready; /*就绪队列头指针*/
r=p1; /*r做p1的前驱指针*/
b=1;
while((p1!=NULL)&&b) /*根据优先数确定插入位置*/ if(p1->prio>=s->prio)
{
r=p1;
p1=p1->next;
}
else
b=0;
if(r!=p1) /*如果条件成立说明插入在r与p1之间*/
{
r->next=s;
s->next=p1;
}
else
{
s->next=p1; /*否则插入在就绪队列的头*/
}
}
/*优先数创建初始PCB信息*/
void create1(char alg)
{
PCB *p;
int i,time;
char na[10];
ready=NULL; /*就绪队列头指针*/
finish=NULL; /*完成队列头指针*/
run=NULL; /*运行队列指针*/
printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/ for(i=1;i<=N;i++)
{
p=(PCB *)malloc(sizeof(PCB));
scanf("%s",na);
scanf("%d",&time);
strcpy(p->name,na);
p->cputime=0;
p->needtime=time;
p->state='w';
p->prio=50-time;
if(ready!=NULL) /*就绪队列不空调用插入函数插入*/
insert1(p);
else
{
p->next=ready; /*创建就绪队列的第一个PCB*/
ready=p;
}
}
//clrscr();
printf(" 优先数算法输出信息:\n");
printf("************************************************\n");
prt(alg); /*输出进程PCB信息*/
run=ready; /*将就绪队列的第一个进程投入运行*/
ready=ready->next;
run->state='R';
}
/*优先数调度算法*/
priority(char alg)
{
while(run!=NULL) /*当运行队列不空时，有进程正在运行*/
{
run->cputime=run->cputime+1;
run->needtime=run->needtime-1;
run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/
if(run->needtime==0) /*如所需时间为0将其插入完成队列*/
{
run->next=finish;
finish=run;
run->state='F'; /*置状态为完成态*/
run=NULL; /*运行队列头指针为空*/
if(ready!=NULL) /*如就绪队列不空*/
firstin(); /*将就绪对列的第一个进程投入运行*/
}
else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/ if((ready!=NULL)&&(run->prio<ready->prio))
{
run->state='W';
insert1(run);
firstin(); /*将就绪队列的第一个进程投入运行*/
}
prt(alg); /*输出进程PCB信息*/
}
}
/*主函数*/
main()
{
char algo; /*算法标记*/
//clrscr();
//printf("选择算法:P/R(优先数算法/时间片轮转算法)\n");
//scanf("%c",&algo); /*输入字符确定算法*/
algo='p';
printf("输入进程数：\n");
scanf("%d",&N); /*输入进程数*/
if(algo=='P'||algo=='p')
{
create1(algo); /*优先数法*/
priority(algo);
}
else
if(algo=='R'||algo=='r')
{
//create2(algo); /*轮转法*/
//roundrun(algo);}}。