您的位置：360文档中心› 进程管理实验-C语言版

进程管理实验-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进程结构PCB的描述：typedef struct jincheng_type{int pid;int priority;char state;int blocktime;}PCB;PCB是对进程的描述，pid代表进程号，priority代表优先级，state代表状态，blocktime代表阻塞时间。

2进程队列的描述：使用顺序表typedef struct queuelist{PCB pro[MAXSIZE];int length;}MEMORY;内存的描述，系统创建的进程都保存在这里，MAXSIZE是内存中允许存放最大的进程数目3本实验主要包含如下三个主要操作（1）创建进程操作void create(MEMORY *P,int count);参数P是指向存放进程的内存指针（头指针），count是指创建进程的数目。

（2）查询进程操作int check(MEMORY *P,int pid);参数P是指向存放进程的内存指针（头指针），pid是指查询进程的进程号，若查询到该进程则返回OK（1），否则返回ERROR（0）。

（3）置换进程操作int exchange(MEMORY *P);参数P是指向存放进程的内存指针（头指针），将换出的进程保存在PCB pcb;中，若换出某个进程则返回OK（1），否则返回ERROR（0）。

（4）删除进程操作int kill(MEMORY *P,int i);参数P是指向存放进程的内存指针（头指针），删除内存中第i个进程，若删除某个进程则返回OK （1），否则返回ERROR （0）。

进程管理实验实验报告

进程管理实验实验报告

一、实验目的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程序，使用管道实现父进程和子进程之间的通信。

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

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

最新实验二-实验报告(进程管理)实验目的：1. 理解操作系统中进程的概念及其特性。

2. 掌握进程管理的基本原理和方法。

3. 学习进程创建、撤销、阻塞和唤醒等操作。

4. 熟悉进程间的同步与通信机制。

实验环境：- 操作系统：Linux/Unix- 编程语言：C/C++- 开发工具：GCC编译器，GDB调试器实验内容：1. 创建进程：编写程序，使用系统调用fork()创建子进程，并观察父进程与子进程的行为差异。

2. 进程撤销：实现一个程序，通过系统调用exit()或abort()撤销进程，并观察其对进程组和会话的影响。

3. 进程阻塞与唤醒：设计并实现一个父进程和多个子进程的程序，其中子进程执行阻塞操作（如sleep()），父进程负责唤醒这些子进程。

4. 进程同步：利用信号量或管程等同步机制，实现两个并发进程的同步操作。

5. 进程通信：通过管道(PIPE)、消息队列、共享内存等IPC机制，实现进程间的信息交换。

实验步骤：1. 设计并编写创建进程的程序代码。

2. 在Linux环境下使用GCC编译程序，并记录编译过程。

3. 运行程序，使用GDB等工具调试程序，并观察fork()的执行效果。

4. 实现进程撤销的程序，并记录exit()和abort()的不同行为。

5. 编写进程阻塞与唤醒的程序，并通过实验观察不同进程状态的变化。

6. 完成进程同步的代码实现，并测试死锁及其解决方法。

7. 编写并测试进程通信的程序，确保信息能够正确传递。

实验结果：- 展示创建进程前后的系统状态变化，包括进程表和内存分配情况。

- 记录进程撤销后，父进程收集子进程状态的输出。

- 展示进程阻塞与唤醒的输出结果，验证进程状态转换的正确性。

- 展示进程同步的实验结果，包括死锁的产生与解决。

- 展示进程通信的测试结果，验证信息传递的准确性。

实验分析：- 分析进程创建和撤销的系统资源变化。

- 讨论进程阻塞与唤醒机制的效率和应用场景。

- 探讨进程同步与通信的复杂性及其在多线程编程中的重要性。

操作系统-进程管理实验C语言

操作系统-进程管理实验C语言

#include"stdio.h"#include"stdlib.h"#define ready 1#define run 2struct pcb{char name[10];int priority; /*进程的优先级*/int state; /*进程的状态:可以有run、ready、finish(可有可无)*/int needtime; /*进程需要运行的时间*/int runtime;int time; /*进程已运行的时间*/struct pcb *next; /*指向下一个进程PCB的指针*/};typedef struct pcb PCB;PCB *head=NULL;/*此函数用于创建进程队列*/void create(void){ PCB *p, *q;int n,i;printf("Enter the number of the process:");scanf("%d",&n); /*输入要创建的进程的数量*/ head=(PCB *)malloc(sizeof(PCB)); /*创建一个表头结点*/p=head;for(i=1;i<=n;i++) /*用循环来创建指定个结点*/ { q=(PCB*)malloc(sizeof(PCB));p->next=q;p=q;printf("\nenter the NO.%d name of process:",i);scanf("%s",&p->name);printf("enter the priority of process:");scanf("%d",&p->priority);printf("enter the time need:");scanf("%d",&p->needtime);p->state=ready;p->runtime=0;p->next=NULL;}}/*删除执行完毕的进程*/void delete(PCB *head,PCB *p) {PCB *q;q=head;while(q->next!=p)q=q->next;q->next=p->next;free(p);}/*找出执行时间最短的进程*/PCB *getminneedtime(PCB *head) {PCB *p,*q;p=head->next;q=p->next;while(q){if(p->needtime>q->needtime)p=q;q=q->next;}return(p);}/*找出优先级最高的进程*/PCB *getpriority(PCB *head) {PCB *p,*q;p=head->next;q=p->next;while(q){if (p->priority>q->priority)p=q;}return (p);}/*时间片轮转*/void RR (void){ PCB *p,*q,*r;int time;printf("input the time:\n ");scanf("%d",&time);for(p=head->next;p->next;p=p->next) {r=p;}while(head->next){p=head->next; /*选出就绪队列的第一个进程*/p->state=run;printf("\n***Now the running process is:\n"); /*输出该进程的信息*/printf("%s\t",p->name);printf("state:run\t");printf("needtime: %d\t",p->needtime);printf("runtime: %d\n",p->needtime);q=head->next;if(p->needtime-p->runtime<=p->time) /*时间片内，进程运行结束否*/ {p->runtime=p->needtime;printf("runtime:%d\n",p->runtime);}else{p->runtime=p->runtime+p->time;printf("runtime:%d\n",p->runtime);}q=p->next;if(q!=NULL) /*输出就绪队列中的进程信息*/ printf("***Now the ready quenue is:\n");else printf("***Now the ready quenue is NONE!");while(q){printf("%s\t",q->name);printf("state:ready\t");printf("needtime:%d\t",q->needtime);printf("runtime:%d\t",q->runtime);printf("\n");q=q->next;}if(p->runtime==p->needtime){delete(head,p);}else{head->next=p->next;r->next=p;r=p;r->state=ready;r->next=NULL;}}}/*优先权调度算法*/void HPF (void){PCB *p,*q;int flag=1;while(head->next){ if(flag==1){p=getpriority(head); /*调用“找出执行时间最短的进程”函数*/p->state=run;} /*将选出的进程的状态改为“run”*/(p->runtime)++;(p->priority)--;printf("\n***Now the running process is:\n"); /*输出该进程的信息*/printf("%s\t",p->name);printf("state:run\t");printf("needtime: %d\t",p->needtime);printf("runtime: %d\n",p->runtime);q=head->next;if(q->next!=NULL) /*输出就绪队列中的进息*/ printf("***Now the ready quenue is:\n");else printf("***Now the ready quenue is NONE!");while(q){if(q!=p){ printf("%s\t",q->name);printf("state:ready\t");printf("needtime:%d\t",q->needtime);printf("runtime:%d\t",q->runtime);printf("\n");}q=q->next;}if(p->runtime==p->needtime){ delete(head,p);}else{for(q=head->next;q;q=q->next)if(p->priority>=q->priority){flag=0;}else { flag=1;p->state=ready;}}/*将该运行结束的进程删除掉*/}}/*短作业优先*/void SJF (void){PCB *p,*q;while(head->next){ p=getminneedtime(head); /*调用“找出执行时间最短的进程”函数*/p->state=run; /*将选出的进程的状态改为“run”*/printf("\n***Now the running process is:\n"); /*输出该进程的信息*/printf("%s\t",p->name);printf("state:run\t");printf("needtime: %d\t",p->needtime);printf("runtime: %d\n",p->needtime);q=head->next;if(q->next!=NULL) /*输出就绪队列中的进程信息*/ printf("***Now the ready quenue is:\n");else printf("***Now the ready quenue is NONE!");while(q){if(q!=p){ printf("%s\t",q->name);printf("state:ready\t");printf("needtime:%d\t",q->needtime);printf("runtime:%d\t",q->runtime);printf("\n");}q=q->next;}delete(head,p); /*将该运行结束的进程删除掉*/ }}/*输出菜单*/void printfunc(void){printf(" *******************\n");printf(" * 1-create *\n");printf(" * 2-SJF *\n");printf(" * 3-HPF *\n");printf(" * 4-RR *\n");printf(" * 0-exit *\n");printf(" *******************\n");}/*主函数*/main(){int choice;printfunc();do{printf("please input the number:");scanf("%d",&choice);getchar();switch (choice){case 1:create();printfunc();break;case 2:if(head==NULL || head->next==NULL)printf("就绪队列没有进程，请先创建进程\n");else{SJF();printfunc();}break;case 3:if(head==NULL || head->next==NULL)printf("就绪队列没有进程，请先创建进程\n");else{HPF();printfunc();}break;case 4 :if(head==NULL || head->next==NULL)printf("就绪队列没有进程，请先创建进程\n");else{RR();printfunc();}break;case 0:exit(0);}}while(1);}。

(完整word版)进程管理实验报告源代码

(完整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_ 进程管理实验电大操作系统实验报告 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篇)

进程管理实验报告源代码(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;}```五、实验结果与分析（此处应填写实验结果，包括运行程序输出、图表等，以及对实验结果的分析。

进程管理实验-C语言版

进程管理实验-C语言版
支持多个进程并发运行的简单进程 管理模拟系统
题目
本系统的同步机构采用信号量上的P、V操作的机制； 控制机构包括： （1)阻塞和唤醒操作； （2)时间片中断处理程序模拟时间片中断； （3)进程调度程序负责为各进程分配处理机。 系统中涉及了3个并发进程。它们之间的关系是： （1) 3个进程需要互斥使用临界资源S2。 （2)进程1和进程2又需互斥使用临界资源S1． 本系统在运行过程中随机打印出各进程的状态变换过 程，系统的调度过程及公共变量的变化情况。
{
pcb[n].status='c'; 本进程置为完成态 printf("process %d is completed\n",n); exe=NIL; 当前执行进程号置空
}
int find()
选进程
{ int j,pd,w; pd=NIL; w=MAXPRI; for(j=1;j<=3;j++) 先status=='r')
}
func p( );， func v(ad) ); wait操作 int p(intse char { sem[se].value=sem[se].value-1; 信号量减1 if sem[se].value>=0 return false； 有资源不等待 else { block(se); 阻塞到 se 等待队列 pcb[exe].inum=i; pcb[exe].addr=ad; 保护现场 exe=NIL; return true; 执行进程置空,等待标志
空
}
void init()
初始化
{ int j; for(j=1;j<=3;j++) 初始化各进程控制块 { pcb[j].id=j; pcb[j].status='r'; 进程号,进程状态 pcb[j].nextwr=NIL; pcb[j].mess:=NULL; 等待、消息

进程管理实验报告换出

进程管理实验报告换出

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

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

3. 通过实验加深对进程管理的理解和应用。

二、实验环境1. 操作系统：Windows 102. 编程语言：C语言3. 开发环境：Visual Studio三、实验内容1. 进程的创建与终止2. 进程的调度3. 进程同步4. 进程通信四、实验步骤1. 进程的创建与终止（1）编写代码创建一个进程，并获取该进程的进程ID（PID）。

（2）编写代码终止创建的进程。

2. 进程的调度（1）编写代码实现一个简单的进程调度算法，如先来先服务（FCFS）。

（2）模拟多个进程的运行，观察进程调度的效果。

3. 进程同步（1）编写代码实现生产者-消费者问题，使用互斥锁和条件变量实现进程同步。

（2）观察生产者和消费者进程的同步效果。

4. 进程通信（1）编写代码实现进程间通信，使用管道实现进程间的数据传递。

（2）观察进程间通信的效果。

五、实验结果与分析1. 进程的创建与终止实验结果：成功创建了进程，并通过PID获取到了进程信息。

终止进程后，进程的运行状态变为退出状态。

分析：通过实验，我们掌握了进程的创建与终止的基本操作，了解了进程的基本属性。

2. 进程的调度实验结果：实现了FCFS调度算法，模拟了多个进程的运行。

观察结果显示，进程按照创建顺序依次执行。

分析：通过实验，我们了解了进程调度的基本原理，掌握了FCFS调度算法的实现方法。

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

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

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

操作系统实验————（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．感想与心得体会做了两周的实验，问了很多同学，可程序还是有很多问题。

操作系统-进程管理实验C语言

操作系统-进程管理实验C语言

操作系统-进程管理实验C语言#include"stdio.h"#include"stdlib.h"#define ready 1#define run 2struct pcb{char name[10];int priority; /*进程的优先级*/int state; /*进程的状态:可以有run、ready、finish(可有可无)*/ int needtime; /*进程需要运行的时间*/int runtime;int time; /*进程已运行的时间*/struct pcb *next; /*指向下一个进程PCB的指针*/};typedef struct pcb PCB;PCB *head=NULL;/*此函数用于创建进程队列*/void create(void){ PCB *p, *q;int n,i;printf("Enter the number of the process:");scanf("%d",&n); /*输入要创建的进程的数量*/ head=(PCB *)malloc(sizeof(PCB)); /*创建一个表头结点*/p=head;for(i=1;i<=n;i++) /*用循环来创建指定个结点*/ { q=(PCB*)malloc(sizeof(PCB));p->next=q;p=q;printf("\nenter the NO.%d name of process:",i); scanf("%s",&p->name);printf("enter the priority of process:");scanf("%d",&p->priority);printf("enter the time need:");scanf("%d",&p->needtime);p->state=ready;p->runtime=0;p->next=NULL;}}/*删除执行完毕的进程*/void delete(PCB *head,PCB *p) {PCB *q;q=head;while(q->next!=p)q=q->next;q->next=p->next;free(p);}/*找出执行时间最短的进程*/PCB *getminneedtime(PCB *head) {PCB *p,*q; p=head->next;q=p->next;while(q){if(p->needtime>q->needtime)p=q;q=q->next;}return(p);}/*找出优先级最高的进程*/PCB *getpriority(PCB *head) {PCB *p,*q;p=head->next;q=p->next;while(q){if (p->priority>q->priority)p=q;}return (p);}/*时间片轮转*/void RR (void){ PCB *p,*q,*r;int time;printf("input the time:\n ");scanf("%d",&time);for(p=head->next;p->next;p=p->next) {r=p;}while(head->next){p=head->next; /*选出就绪队列的第一个进程*/p->state=run;printf("\n***Now the running process is:\n"); /*输出该进程的信息*/printf("%s\t",p->name);printf("state:run\t");printf("needtime: %d\t",p->needtime);printf("runtime: %d\n",p->needtime);q=head->next;if(p->needtime-p->runtime<=p->time) /*时间片内，进程运行结束否*/ {p->runtime=p->needtime;printf("runtime:%d\n",p->runtime);}else{p->runtime=p->runtime+p->time;printf("runtime:%d\n",p->runtime);}q=p->next;if(q!=NULL) /*输出就绪队列中的进程信息*/ printf("***Now the ready quenue is:\n");else printf("***Now the ready quenue is NONE!");while(q){printf("%s\t",q->name);printf("state:ready\t");printf("needtime:%d\t",q->needtime);printf("runtime:%d\t",q->runtime);printf("\n");q=q->next;}if(p->runtime==p->needtime){delete(head,p);}else{head->next=p->next;r->next=p;r=p;r->state=ready;r->next=NULL;}}}/*优先权调度算法*/void HPF (void){PCB *p,*q;int flag=1;while(head->next){ if(flag==1){p=getpriority(head); /*调用“找出执行时间最短的进程”函数*/p->state=run;} /*将选出的进程的状态改为“run”*/(p->runtime)++;(p->priority)--;printf("\n***Now the running process is:\n"); /*输出该进程的信息*/printf("%s\t",p->name);printf("state:run\t");printf("needtime: %d\t",p->needtime);printf("runtime: %d\n",p->runtime);q=head->next;if(q->next!=NULL) /*输出就绪队列中的进息*/ printf("***Now the ready quenue is:\n");else printf("***Now the ready quenue is NONE!");while(q){if(q!=p){ printf("%s\t",q->name);printf("state:ready\t");printf("needtime:%d\t",q->needtime);printf("runtime:%d\t",q->runtime);printf("\n");}q=q->next;}if(p->runtime==p->needtime){ delete(head,p);}else{for(q=head->next;q;q=q->next)if(p->priority>=q->priority){flag=0;}else { flag=1;p->state=ready;}}/*将该运行结束的进程删除掉*/}}/*短作业优先*/void SJF (void){PCB *p,*q;while(head->next){ p=getminneedtime(head); /*调用“找出执行时间最短的进程”函数*/p->state=run; /*将选出的进程的状态改为“run”*/printf("\n***Now the running process is:\n"); /*输出该进程的信息*/printf("%s\t",p->name);printf("state:run\t");printf("needtime: %d\t",p->needtime);printf("runtime: %d\n",p->needtime);q=head->next;if(q->next!=NULL) /*输出就绪队列中的进程信息*/ printf("***Now the ready quenue is:\n");else printf("***Now the ready quenue is NONE!");while(q){if(q!=p){ printf("%s\t",q->name);printf("state:ready\t");printf("needtime:%d\t",q->needtime);printf("runtime:%d\t",q->runtime);printf("\n");}q=q->next;}delete(head,p); /*将该运行结束的进程删除掉*/ }}/*输出菜单*/void printfunc(void){printf(" *******************\n");printf(" * 1-create *\n");printf(" * 2-SJF *\n");printf(" * 3-HPF *\n");printf(" * 4-RR *\n");printf(" * 0-exit *\n");printf(" *******************\n");}/*主函数*/main(){int choice;printfunc();do{printf("please input the number:"); scanf("%d",&choice);getchar();switch (choice){case 1:create();printfunc();break;case 2:if(head==NULL || head->next==NULL) printf("就绪队列没有进程，请先创建进程\n"); else{SJF();printfunc();}break;case 3:if(head==NULL || head->next==NULL) printf("就绪队列没有进程，请先创建进程\n"); else{HPF();printfunc();}break;case 4 :if(head==NULL || head->next==NULL) printf("就绪队列没有进程，请先创建进程\n"); else{RR();printfunc();}break;case 0:exit(0); }}while(1); }。

进程管理实验报告代码

进程管理实验报告代码

一、实验目的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;}```五、实验结果与分析通过以上实验，我们了解了进程状态转换、进程同步与互斥、信号量实现进程同步与互斥以及进程调度算法。

进程管理实验报告

进程管理实验报告

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

本实验通过使用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．.编辑c语言源程序$vi test.c~~~~按<insert>键,进入编辑模式，程序输入完成后，按<esc>键，退出编辑模式。

按: 键，进入命令模式，输入w存盘退出。

2．编译c语言源程序$gcc test.c没有错误提示，表示编译成功；否则返回第3步进行修改。

3．调试运行这个时候在某某.c所在的目录下面，就多了一个a.out的可执行文件，再在终端里面./a.out就可以看到结果了。

总结下：1.1.vi 某某.c1.2.在vi里面写c程序...（建议复制粘贴程序的人检查一下自己的代码，我看到有些人第一行写成include <stdio.h>）注意#和include是连在一起，才有预处理行的效果1.3.写完了保存退出（ESC然后:wq）1.4.终端输gcc 某某.c1.5.终端输./a.out二、关于进程的系统调用1.进程的创建fork()格式：pid=fork()功能：创建一个新进程，新进程与父进程具有相同的代码，父子进程都从fork()之后的那条语句开始执行。

对于父进程，pid 的值>0;对于子进程，pid的值=0;创建失败，pid的值<0。

2.进程的终止exit()格式：exit(status)功能：终止当前进程的执行，status是一个整数，其值可以返回父进程。

3.进程的同步wait()格式：wait()功能：父进程进入睡眠态，当子进程终止时被唤醒。

4．进程的延迟 sleep()格式：sleep(n)功能：当前进程延迟n秒执行。

5．进程执行另一程序 execl()实验二进程管理一、实验目的（1）加深对进程概念的理解，明确进程和程序的区别。

（2）进一步认识并发执行的实质。

二、实验内容1、进程的创建执行下面的程序，分析执行的结果。

#include <stdio.h>main(){ int i;printf("just 1 process.\n");i=fork();if (i==0)printf("I am child.\n");elseif (i>0)printf("I am parent.\n");elseprintf("fork() failed.\n");printf("program end.\n");}输出结果：2、进程的同步执行下面的程序，分析执行的结果。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

{
proce block(); 阻塞 proce wakeup(); 唤醒
int w; 工作指针 printf("process %d is blocked\n",exe); pcb[exe].status='w'; 置阻塞态 pcb[exe].nextwr=NIL; w=sem[se].firstwr; 信号量等待队列头指针赋给w if (w==NIL) sem[se].firstwr=exe; 空则当前进程作队头 else { while (pcb[w].nextwr!=NIL) w=pcb[w].nextwr; 指针后退到队尾 pcb[w].nextwr=exe; } 当前进程链接到队尾
void send(int sender,int receiver,int snum) 发送
{ struct message p,q; 工作指针 p=(message)malloc(sizeof(struct messagetp)); p->num=snum; 申请消息块,写入缓冲 p->next=NULL;下一指针置空 p->pro=sender;置发送者 printf(“send message to process %d” ,receiver); printf(“process %d already run %d times”,sender,snum);
置真
} } int v(int se，char ad) signal操作 { sem[se].value=sem[se].value+1; 信号量加1 if sem[se].value>0 return false; 无等待不重新调度 else { wakeup(se); 有等待唤醒 se 等待队列的进程 pcb[exe].inum=i; pcb[exe].addr=ad; 保护现场 return true; 要重新
}
void wakeup(int se)
{ int w; w=sem[se].firstwr; 队列头指针赋给w if (w!=NIL){非空则摘下首块 sem[se].firstwr=pcb[w].nextwr;重链接 pcb[w].status='r';置为高就绪态 printf("process %d is wakeup\n",w);
return pd; 返回进程号
int scheduler（） 调度
{ int pd; pd=find(); 找优先进程 if ((pd==NIL)&&(exe==NIL)) return NIL; else{ if (pd!=NIL){ 若有就绪进程则 if(exe==NIL) { 若当前没有进程执行则 pcb[pd].status=‘e’; 新进程置执行态 exe=pd; printf(“process %d is executing\n”,exe); } else if (pcb[pd].priority<pcb[exe].priority){ 切换 pcb[exe].status=‘r’; 原执行进程置高就绪态 printf("process %d enter into ready\n",exe); pcb[pd].status=‘e’; 新进程置执行态 exe=pd; printf("proecess %d is executing\n",exe);} } i=pcb[exe].inum; 恢复现场
空
}
void init()
初始化
{ int j; for(j=1;j<=3;j++) 初始化各进程控制块 { pcb[j].id=j; pcb[j].status='r'; 进程号,进程状态 pcb[j].nextwr=NIL; pcb[j].mess:=NULL; 等待、消息
指针
printf(“process %d priority?”, j); scanf(“%d”,&pcb[j].priority); pcb[j].inum=0; pcb[j].addr='0';
基本思路
进程调度算法采用剥夺式最高优先数法。各进程的 优先数通过键盘输入予以静态设置态进程中选择，再从t状态进程中选择。当现行 进程唤醒某个等待进程，且被唤醒进程的优先数小于现 行进程时，则剥夺现行进程的执行权。 各进程在使用临界资源S1和S2时，通过调用信号量 sem1和sem2上的P、V操作来实现同步。阻塞和唤醒操 作负责完成从进程的执行态到等待态以及从等待态到就 绪态的转换。 系统启动后，在完成必要的系统初始化后便执行进 程调度程序。当执行进程因“时间片中断”，或被排斥 使用临界资源，或唤醒某个进程时，立即进行进程调度。 当3个进程都处于完成状态后，系统退出运行。
void send(int sender,int receiver,int snum) 发送 q=pcb[receiver].mess; q指向接收者消息等 待队列首 if(q==NULL) pcb[receiver].mess=p; q空则p插入队首 else { while(q->next!=NULL) q=q->next; q移到队尾 q->next=p; } 将p链接到队尾 }
struct messagetp{ int num; message next; int pro; };
消息块类型(信息,指针,发送者号)
typedef struct messagetp *message; 指向消息块指针类型 struct semaphorel{ 信号量类型(信号量,等待队头号) int value; int firstwr; }; struct procb pcb[3]; PCB表 struct semaphorel sem[2]; 信号量表 char addr; 当前进程地址 int i,seed,exe; 运行次数,随机变量,当前运行进程号
void receive(int receiver)
接收
{ message p,q; 工作指针 p=pcb[receiver].mess; p指向接收者消息等待队列首 while(p!=NULL) { 显示发送者和接收者信息 printf(“receive message from process %d”,p->pro); printf(“process %d is already run %d times”,p>pro, p->num); q=p; 陆续将接收过的的消息块删除并释放 p=p->next; free(q); } pcb[receiver].mess=NULL; 接收完后消息等待队列置
}
func p( );， func v(ad) ); wait操作 int p(intse char { sem[se].value=sem[se].value-1; 信号量减1 if sem[se].value>=0 return false； 有资源不等待 else { block(se); 阻塞到 se 等待队列 pcb[exe].inum=i; pcb[exe].addr=ad; 保护现场 exe=NIL; return true; 执行进程置空,等待标志
数据结构
（1）每个进程有一个进程控制块PCB，内容包括： id 进程标识号，id＝0，1，2； status 进程状态，可为e，r，t，w，c； priority 进程优先数； nextwr 等待链指针，指示在同一信号量上等待的 下一个进程的标识号。 （2）信号量semaphore，对应于临界资源S1和S2分别 有sem1和sem2，均为互斥信号量，内容包括： value 信号量，初值为1； firstwr 等待链首指针，指示在同一信号量上等待 的下一个进程的标识数。
if (pcb[j].priority<w){ w=pcb[j].priority; pd=j; }
if (pd==NIL) for(j=1;j<=3;j++) 再在低就绪态中找优先数最小的进程 if (pcb[j].status=='t')
if(pcb[j].priority<w){ w=pcb[j].priority; pd=j; }
{
pcb[n].status='c'; 本进程置为完成态 printf("process %d is completed\n",n); exe=NIL; 当前执行进程号置空
}
int find()
选进程
{ int j,pd,w; pd=NIL; w=MAXPRI; for(j=1;j<=3;j++) 先在高就绪态中找优先数最小的进程 if (pcb[j].status=='r')
支持多个进程并发运行的简单进程 管理模拟系统
题目
本系统的同步机构采用信号量上的P、V操作的机制； 控制机构包括： （1)阻塞和唤醒操作； （2)时间片中断处理程序模拟时间片中断； （3)进程调度程序负责为各进程分配处理机。 系统中涉及了3个并发进程。它们之间的关系是： （1) 3个进程需要互斥使用临界资源S2。 （2)进程1和进程2又需互斥使用临界资源S1． 本系统在运行过程中随机打印出各进程的状态变换过 程，系统的调度过程及公共变量的变化情况。
读入优先数 运行次数, 地址
} sem[1].value=1; sem[1].firstwr=NIL; 对信号量初始化 sem[2].value=1; sem[2].firstwr=NIL; exe=NIL; 当前执行进程号置为空
}
func proc eexit(n:integer); float random:real; random( ) 产生 0~1之间的随机数 {int m; seed为int 型,实际值在-32768到32767之间 if seed<0 m=-seed; else m=seed; seed=(25171*seed+13841)%65536; return(m/32767.0); } void eexit(int n); 退出
相关文档
最新文档