进程管理实验报告源代码
进程管理源代码
}
else return(1);
printf("process%d executing\n",ep);
i=pcb[pd].stack[1];
addr=pcb[pd].stack[2];
printf("wakeup rocess%d\n",w);
}
pcb[p].stack[1]=i;
pcb[p].stack[2]=ad;
return(0);
}
process1()
{ if(addr=='m') goto m;
printf("\n process3 printing 2^i=%d\n\n",m2);
m1=m2;
getchar();
printf("process3 calls v on sem2!\n");
if(v(2,3,'m')==0) return(0);
i=i+10;
goto a;
}
process3()
{ if(addr=='m')goto m;
if(addr=='n')goto n;
i=1;
a: printf("\n=>process3 i=%d\n",i);
if(i>=num)goto b;
pcb[j].waiter1=0;
pcb[j].priority=j;
for(k=0;k<=4;k++)
pcb[j].stack[k]='0';
(完整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)然后根据你选择的不同,出现不同的结果。
linux进程管理的实验报告
实验报告:Linux进程管理1. 引言本实验报告将详细介绍Linux系统中进程管理的相关知识和操作。
进程管理是操作系统中的一个重要组成部分,它负责控制和调度系统中运行的各个进程,确保系统资源的合理分配和进程的正常运行。
在本实验中,我们将通过一系列步骤来了解Linux系统中进程的创建、监控和控制。
2. 实验环境为了完成本实验,我们需要在一台运行Linux操作系统的计算机上进行操作。
本实验报告基于Ubuntu 20.04 LTS操作系统进行撰写,但是适用于大多数Linux 发行版。
3. 实验步骤步骤一:创建新进程在Linux系统中,可以通过fork()系统调用来创建新的进程。
以下是一个简单的示例代码:#include <stdio.h>#include <unistd.h>int main() {pid_t pid = fork();if (pid == 0) {// 子进程逻辑printf("这是子进程\n");} else if (pid > 0) {// 父进程逻辑printf("这是父进程\n");} else {// 进程创建失败printf("进程创建失败\n");}return0;}步骤二:查看进程信息Linux系统提供了多种命令来查看系统中运行的进程信息。
以下是一些常用的命令:•ps:显示当前终端下的进程列表。
•top:实时显示进程的CPU、内存等资源占用情况。
•pstree:以树状结构显示进程的层次关系。
步骤三:杀死进程有时候我们需要终止一个运行中的进程,可以使用kill命令来发送终止信号给目标进程。
以下是一个示例:kill <PID>请将<PID>替换为目标进程的进程ID。
步骤四:进程优先级调整通过调整进程的优先级,可以影响进程在系统中的调度顺序。
在Linux系统中,可以使用nice命令来调整进程的优先级。
进程管理实验报告_共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族调用可以执行给定程序。
进程管理实验报告代码
一、实验目的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;}```五、实验结果与分析通过以上实验,我们了解了进程状态转换、进程同步与互斥、信号量实现进程同步与互斥以及进程调度算法。
北邮操作系统进程管理实验报告及源代码
进程管理实验报告1. 实验目的:(1)加深对进程概念的理解, 明确进程和程序的区别;(2)进一步认识并发执行的实质;(3)分析进程争用资源的现象, 学习解决进程互斥的方法;(4)了解Linux系统中进程通信的基本原理。
2. 实验预备内容(1)阅读Linux的sched.h源码文件, 加深对进程管理概念的理解;(2)阅读Linux的fork()源码文件, 分析进程的创建过程。
3.环境说明本次实验使用的是win7下的VMWare workstation虚拟机, 安装了ubuntu系统在ubuntu系统下使用code::blocks IDE编写代码并执行程序的4.实验内容:1.进程的创建:(1)实验题目和要求:编写一段程序, 使用系统调用fork() 创建两个子进程。
当此程序运行时, 在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示一个字符:父进程显示字符“a”, 子进程分别显示字符“b”和“c”。
试观察记录屏幕上的显示结果, 并分析原因。
(2)程序设计说明:参照书上的例子进行设计, 详见源代码(3)程序运行结果截图:(4)程序分析:a,b,c随机出现, 因为父进程与两个子进程之间并没有同步措施, 所以a,b,c随机打印出来, 也就是三个进程的活动次序是随机进行的, 不同的系统可能有不同的进程调度方式。
(5)源程序:#include<sys/types.h>#include<stdio.h>#include<unistd.h>int main(){pid_t pid1,pid2;if((pid1=fork())<0){printf("Fork Failed.\n");exit(-1);}else if((pid1=fork())==0)printf("b\n");else{if((pid2=fork())<0){printf("Fork Failed.\n");exit(-1);}else if((pid2=fork())==0)printf("c\n");else{wait(NULL);printf("a\n");exit(0);}}return 0;}2.进程的控制:要求一:(1)实验题目和要求:修改已经编写的程序, 将每个进程输出一个字符改为每个进程输出一句话, 再观察程序执行时屏幕上出现的现象, 并分析原因。
操作系统实验之进程管理实验报告
操作系统实验之进程管理实验报告一、实验目的本次操作系统实验的主要目的是深入理解进程管理的概念和原理,通过实际操作和观察,掌握进程的创建、调度、同步与互斥等关键机制。
二、实验环境本次实验使用的操作系统为 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 进程终止。
进程调度实验报告源码
一、实验目的本次实验旨在通过模拟进程调度过程,加深对进程调度算法的理解,并掌握进程调度程序的设计与实现方法。
实验内容主要包括:创建进程、进程调度、进程执行、进程结束等。
二、实验环境操作系统:Linux编程语言:C/C++三、实验内容1. 进程调度算法本实验采用三种进程调度算法:FIFO(先进先出)、时间片轮转法、多级反馈队列调度算法。
2. 进程调度程序设计进程调度程序主要由以下部分组成:(1)进程控制块(PCB)PCB用于描述进程的基本信息,包括进程名、到达时间、需要运行时间、已运行时间、进程状态等。
(2)就绪队列就绪队列用于存储处于就绪状态的进程,按照进程的优先级或到达时间进行排序。
(3)进程调度函数进程调度函数负责从就绪队列中选择一个进程进行执行,并将CPU分配给该进程。
(4)进程执行函数进程执行函数负责模拟进程的执行过程,包括进程的创建、执行、结束等。
四、实验源码```c#include <stdio.h>#include <stdlib.h>#include <time.h>#define MAX_PROCESSES 10typedef struct PCB {int pid;int arrival_time;int need_time;int used_time;int priority;int state; // 0: 等待 1: 运行 2: 完成} PCB;PCB processes[MAX_PROCESSES];int process_count = 0;typedef struct Queue {PCB queue;int front;int rear;int size;} Queue;Queue ready_queue;void init_queue(Queue q) {q->queue = (PCB )malloc(sizeof(PCB) MAX_PROCESSES); q->front = q->rear = 0;q->size = 0;}void enqueue(Queue q, PCB p) {if (q->size == MAX_PROCESSES) {printf("Queue is full.\n");return;}q->queue[q->rear] = p;q->rear = (q->rear + 1) % MAX_PROCESSES; q->size++;}PCB dequeue(Queue q) {if (q->size == 0) {printf("Queue is empty.\n");return NULL;}PCB p = &q->queue[q->front];q->front = (q->front + 1) % MAX_PROCESSES; q->size--;return p;}int is_empty(Queue q) {return q->size == 0;}void print_queue(Queue q) {printf("Queue: ");for (int i = 0; i < q->size; i++) {PCB p = &q->queue[(q->front + i) % MAX_PROCESSES];printf("PID: %d, Arrival Time: %d, Need Time: %d, Used Time: %d, Priority: %d, State: %d\n",p->pid, p->arrival_time, p->need_time, p->used_time, p->priority, p->state);}}void init_processes() {for (int i = 0; i < MAX_PROCESSES; i++) {processes[i].pid = i;processes[i].arrival_time = rand() % 10;processes[i].need_time = rand() % 10 + 1;processes[i].used_time = 0;processes[i].priority = rand() % 3;processes[i].state = 0;}}void schedule() {int time = 0;while (process_count > 0) {for (int i = 0; i < process_count; i++) {PCB p = &processes[i];if (p->arrival_time == time) {enqueue(&ready_queue, p);p->state = 1;}}if (!is_empty(&ready_queue)) {PCB p = dequeue(&ready_queue);p->used_time++;printf("Process %d is running.\n", p->pid);if (p->used_time == p->need_time) {p->state = 2;printf("Process %d is finished.\n", p->pid); }}time++;}}int main() {srand(time(NULL));init_queue(&ready_queue);init_processes();process_count = rand() % MAX_PROCESSES + 1;schedule();print_queue(&ready_queue);return 0;}```五、实验结果与分析1. FIFO调度算法实验结果表明,FIFO调度算法按照进程的到达时间进行调度,可能导致短作业等待时间长,效率较低。
进程管理实验报告
进程管理实验报告一、引言进程管理是操作系统中的重要概念之一,它负责分配和调度计算机资源,确保多个程序能够同时运行,并通过合理的资源管理提高系统的效率和性能。
本实验旨在对进程管理进行深入研究和实践,通过编写相关代码并进行测试,探索进程管理的原理和实现方式。
二、实验背景在一个多道程序设计的环境中,操作系统需要管理系统中的各个进程,分配对应的资源,并处理进程之间的竞争条件。
进程管理的核心任务包括进程的创建、运行、阻塞、唤醒和终止等操作,以及资源的调度和分配。
三、实验目标本实验旨在通过编写一个简单的进程管理程序,实现进程的创建和调度,演示进程间的合作与竞争情况,以及资源的请求和释放。
具体目标包括:1.实现进程的创建和调度算法;2.模拟进程之间的竞争条件,如互斥、死锁等;3.模拟进程的请求和释放资源的过程;4.评估不同调度算法对系统性能的影响。
四、实验设计和方法1.进程创建和调度根据操作系统的调度算法,我们可以设计一个简单的进程调度器。
首先,需要定义进程的数据结构,包括进程ID、状态、优先级等信息。
其次,实现进程的创建函数,根据用户输入的参数来创建新的进程,并将其添加到进程队列中。
最后,根据调度算法,选择一个进程进行执行,并更新进程的状态。
2.进程间的竞争条件为了模拟进程间的竞争条件,我们可以使用互斥锁和信号量等同步机制。
通过在进程中设置临界区,限定同时只有一个进程可以访问临界资源,从而避免竞争和冲突。
另外,还可以模拟不同进程之间的死锁情况,观察系统的行为和响应。
3.进程的资源请求和释放在进程管理过程中,进程需要向系统申请资源,如内存、磁盘等。
为了模拟这一过程,我们可以设计一个简单的资源管理器,并在进程中调用相应的函数来请求和释放资源。
同时,可以设置资源的使用限制和优先级,观察不同策略对系统的影响。
4.评估系统性能为了比较不同调度算法对系统性能的影响,我们可以通过测量系统的响应时间、资源利用率和吞吐量等指标来评估。
进程调度模拟实验--源代码
#include "stdio.h"#include "stdlib.h"#include "string.h"typedef struct node /*创建PCB*/{ char name[10]; /*进程标识*/int prio; /*进程优先数*/int cputime; /*进程占用CPU时间*/int needtime; /*进程完成所需时间*/int count; /*计数器*/char state; /*进程的状态*/struct node *next; /*链指针*/}PCB;PCB *finish,*ready,*tail,*run;int N;//************************************************************************* void firstin() /*创建就绪队列对头指针*/{run=ready;run->state='R';ready=ready->next;}//************************************************************************* void prt(char algo) /*演示进程调度*/{PCB *p;printf(" 标识占用CPU时间完成所需时间优先数状态\n");if(run!=NULL)printf(" %-6s%-14d%-14d%-8d %c\n",run->name,run->cputime,run->needtime,run->prio,run->state);p=ready;while(p!=NULL){ printf(" %-6s%-14d%-14d%-8d %c\n",p->name,p->cputime,p->needtime,p->prio,p->state);p=p->next;}p=finish;while(p!=NULL){ printf(" %-6s%-14d%-14d%-8d %c\n",p->name,p->cputime,p->needtime,p->prio,p->state);p=p->next;}getchar();}//*************************************************************************void insert(PCB *q){PCB *p1,*s,*r;int b;s=q;p1=ready;r=p1;b=1;while((p1!=NULL)&&b)if(p1->prio>=s->prio){r=p1;p1=p1->next;}elseb=0;if(r!=p1){r->next=s;s->next=p1;}else{s->next=p1;ready=s;}}//************************************************************************* void create(char alg) /*创建各个进程*/{PCB *p;int i,time;char na[10];ready=NULL;finish=NULL;run=NULL;for(i=1;i<=N;i++){p=(PCB *)malloc(sizeof(PCB));printf("输入进程的标识:\n");scanf("%s",na);printf("输入进程的时间(不要超过50):\n");scanf("%d",&time);strcpy(p->name,na);p->cputime=0;p->needtime=time;p->state='w';p->prio=50-time; /*假设优先级与耗时之和为50*/if(ready!=NULL)insert(p);else{p->next=ready;ready=p;}}// clrscr();printf(" 显示进程\n");printf("************************************************\n");prt(alg);run=ready;ready=ready->next;run->state='R';}//************************************************************************* void priority(char alg) /*优先级算法调度*/{while(run!=NULL&&run->prio>=0){run->cputime=run->cputime+1;run->needtime=run->needtime-1;run->prio=run->prio-3;if(run->needtime==0){run->next=finish;finish=run;run->state='F';run=NULL;if(ready!=NULL)firstin();}elseif((ready!=NULL)&&(run->prio<ready->prio)){run->state='W';insert(run);firstin();}prt(alg);}}//************************************************************************* void main(){ char algo;// clrscr();loop: printf("输入进程的总数(不要超过10个):\n");scanf("%d",&N);if(N>10){printf("输入的数字太大,请重新输入.\n");goto loop;}create(algo);priority(algo);}。
操作系统实验报告实验一进程管理
实验一进程管理一、目的进程调度是处理机管理的核心内容。
本实验要求编写和调试一个简单的进程调度程序。
通过本实验加深理解有关进程控制块、进程队列的概念,并体会和了解进程调度算法的具体实施办法。
二、实验内容及要求1、设计进程控制块PCB的结构(PCB结构通常包括以下信息:进程名(进程ID)、进程优先数、轮转时间片、进程所占用的CPU时间、进程的状态、当前队列指针等。
可根据实验的不同,PCB结构的内容可以作适当的增删)。
为了便于处理,程序中的某进程运行时间以时间片为单位计算。
各进程的轮转时间数以及进程需运行的时间片数的初始值均由用户给定。
2、系统资源(r1…r w),共有w类,每类数目为r1…r w。
随机产生n进程P i(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为时间片大小(毫秒)//对进程进行初始化,建立就绪数组、阻塞数组。
实验进程调度源代码
实验进程调度源代码实验2 进程调度(一)目的和要求进程调度是处理机管理的核心内容。
本实验要求用高级语言编写和调试一个简单的进程调度程序。
通过本实验可以加深理解有关进程控制块、进程队列的概念,并体会和了解优先数和时间片轮转调度算法的具体实施方法。
(二)实验内容(1)设计进程控制块PCB结构,分别适用于优先数调度算法和循环轮转调度算法。
PCB结构包括以下信息:进程标识符,进程优先数(或轮转时间片),进程所占用的CPU时间、进程状态,当前队列指针等。
根据调度算法不同,PCB结构的内容可适当做增删。
(2)建立进程就绪队列。
对两种不同算法编制入链子程序。
(3)编制两种进程调度算法:1)优先数调度;2)循环轮转调度。
(三)实验环境用BORLAND C语言(四)范例说明采用C语言编写程序,选用优先数法或简单轮转法对五个进程进行调度,每个进程处于运行(RUN),就绪(READY)和完成(FINISH)三种状态之一,并假定起始状态为就绪状态。
1.数据结构PCB结构如下:NAME 进程标识符PRIO / ROUND 优先数/ 时间片CPUTIME 进程已占用的CPU时间NEEDTIME 进程到完成还需要的CPU时间NEXT 处于同一状态的下一进程的地址STATUS 进程所处的状态“R”进程处于运行状态“W”进程处于就绪状态“F”进程处于完成状态2.程序说明(1)在优先数算法中,进程每执行一次,优先数减3,CPU时间片加1,进程还需要的时间片数减1。
在轮转法中,采用固定时间片,时间片数为2,进程每执行一次,CPU时间片数加2,进程还需要的时间片数减2,并排在就绪队列的队尾。
(2)程序结构说明如下:①INSERT1:把未完成且优先数小于别的进程的进程PCB按进程优先数的顺序插入到就绪队列中。
②INSERT2:轮转法中使用的过程,将执行一个单位时间片数(为2)且还未完成的进程的PCB插入到就绪队列队尾。
③FIRSTIN:将就绪队列中的第一个进程投入运行。
进程管理_实验报告
一、实验目的1. 理解Linux操作系统中进程的概念,明确进程与程序的区别。
2. 掌握Linux下进程的创建、调度、同步与通信等基本操作。
3. 学会使用Linux命令查看和管理进程。
二、实验环境1. 操作系统:Linux2. 编程语言:C/C++3. 开发工具:gcc、gdb三、实验内容1. 进程创建与调度2. 进程同步与互斥3. 进程通信4. 进程控制四、实验步骤1. 进程创建与调度(1)编写一个C程序,创建一个子进程,并在父进程中打印出子进程的进程标识符(PID)。
```c#include <stdio.h>#include <unistd.h>#include <sys/types.h>int main() {pid_t pid;pid = fork(); // 创建子进程if (pid == 0) { // 子进程printf("子进程的PID:%d\n", getpid());} else if (pid > 0) { // 父进程printf("父进程的PID:%d,子进程的PID:%d\n", getpid(), pid); } else {printf("创建子进程失败\n");}return 0;}```(2)编译并运行程序,观察结果。
2. 进程同步与互斥(1)编写一个C程序,使用互斥锁(mutex)实现两个进程的同步。
```c#include <stdio.h>#include <stdlib.h>#include <pthread.h>pthread_mutex_t mutex;void thread_func(void arg) {pthread_mutex_lock(&mutex); // 获取互斥锁printf("线程 %ld 获取了互斥锁\n", pthread_self());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;}```(2)编译并运行程序,观察结果。
进程的管理和控制实验报告
进程的管理和控制实验报告实验目的:本实验旨在了解进程的管理和控制,掌握进程的创建、终止和状态转换等操作,并通过实际的代码编写和运行实验,加深对进程管理的理解。
实验原理:在操作系统中,进程是执行中的程序的实例。
进程管理涉及到创建新进程、终止现有进程、管理进程的状态等操作。
进程的创建:进程的创建可以通过系统调用fork()来完成。
fork()系统调用会创建一个新的进程,称为子进程,子进程将继承父进程的代码、数据和资源。
通过fork()的返回值来区分父子进程,父进程返回子进程的进程ID,子进程返回0。
进程的终止:进程的终止可以通过系统调用exit()来完成。
exit()系统调用会终止当前进程的执行,并返回一个退出状态码。
一个进程的终止也可以由其他进程通过发送终止信号来实现。
进程的状态转换:进程在执行过程中会经历不同的状态,包括就绪态、运行态、阻塞态等。
进程的状态转换可以通过系统调用来实现。
例如,当进程被阻塞时,可以通过系统调用sleep()将其状态转换为阻塞态,当等待的事件发生时,再将其状态转换为就绪态。
实验步骤:1. 编写一个简单的程序,包含进程的创建、终止和状态转换等操作。
2. 使用fork()系统调用创建子进程,并在子进程中执行一段代码。
3. 在父进程中对子进程进行管理,包括等待子进程的终止和获取子进程的退出状态码。
4. 在子进程中通过exit()系统调用终止进程的执行。
5. 在父进程中通过wait()系统调用等待子进程的终止,并获取子进程的退出状态码。
6. 在子进程中通过系统调用sleep()将进程的状态转换为阻塞态。
7. 在父进程中发送终止信号给子进程,观察子进程的终止情况。
实验结果与分析:经过实验,我们成功地创建了子进程并在子进程中执行了一段代码。
父进程能够正确地等待子进程的终止并获取子进程的退出状态码。
在子进程中使用sleep()系统调用后,观察到子进程的状态转换为阻塞态。
当父进程发送终止信号给子进程时,子进程能够正确地终止执行。
进程管理实验报告
实验名称: 进程管理实验要求:阅读后面的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]为下一条指令地址。
计算机操作系统课程设计 进程管理 API C++ 实验报告 源代码
计算机学院网络工程专业《操作系统课程设计》报告——进程管理(2012/2013学年第一学期)学生姓名:张斌学生班级:网络工程102001班学生学号:201020030122指导教师:赵静2012年12月30日目录第一章课程设计的目的和意义 (1)1.1 目的 (1)1.2 意义 (1)第二章课程设计概述 (2)2.1 实验名称 (2)2.2 实验目的 (2)2.3 实验要求 (2)2.4 实验内容 (2)第三章 A PI函数简介 (3)3.1 API定义 (3)3.2 wi nd o ws A P I (3)3.3A P I的类型 (3)3.4 开放A P I平台 (4)第四章相关API函数 (5)4.1 CreateProcess (5)4.1.1 定义 (5)4.1.2 函数原型 (5)4.1.3 函数参数 (5)4.1.4 返回值 (7)4.2 GetVersion (7)4.2.1 VB声明 (7)4.2.2 说明 (7)4.2.3 返回值 (7)4.3 GetCurrentProcessId (8)4.3.1 V C声明 (8)4.3.2说明 (8)4.3.3返回值 (8)4.4 ExitProcess (8)4.4.1 V B声明 (8)4.4.2 说明 (8)4.4.3 参数类型及说明 (8)4.4.4 在VB中使用 (8)4.5 GetSystemTime (8)4.5.1 VB声明 (8)4.5.2 说明 (8)4.5.3参数表 (9)4.5.4 A d a声明 (9)第五章实验结果 (10)5.1系统运行说明 (10)5.2 实验结果分析 (11)结束语 (12)参考文献 (13)附录 (14)第一章课程设计的目的和意义1.1 目的本课程设计是为了配合操作系统课程的理论教学而设置的,目的是通过课程设计的综合训练,加强学生对操作系统概念的实际应用技能的训练,提高学生分析问题和解决问题的能力。
进程管理实验设计报告
实验1 进程管理班级:xxxx 学号:xxxxxxxxxxxxxxxxxxx 姓名:xxxxx上级日期:2018年9月20日成绩:一、实验目的:1、理解进程的概念,明确进程和程序的区别。
2、理解并发执行的实质。
3、掌握进程的创建、睡眠、撤销等进程控制方法二、实验内容1、源代码#include "stdio.h" /*标准输入输出*/#include "conio.h" /*控制台输入输出*/#include "stdlib.h" /*标准库头文件,包含 C 常用函数*/ struct PCB_type{ int pid;int youxianji;int daxiao;char neirong[10];int state; /* 0 表示不在内存,1 表示在内存,2 表示挂起*/ };struct PCB_type neicun[20];int num=0,guaqi=0,bj,i,j,pid;/*定义相关参数变量*//*********************创建新进程*************************/ void create(){if(num>=20) /*判断是否有存储空间*/printf("\n 内存已满,请删除或挂起其他程序");else{for(i=0;i<20;i++)if(neicun[i].state==0) break; /*按顺序在内存中寻找创建新进程的空间*/printf("\n 请输入新建进程的 pid 值\n");scanf("%d",&neicun[i].pid);for(j=0;j<i;j++) /*判断是否之前已存储相同 pid 进程*/if(neicun[j].pid==neicun[i].pid){ printf("\n 该进程已存在于内存中");return;}printf("\n 请输入新进程的优先级 \n" );scanf("%d",&neicun[i].youxianji);printf("\n 请输入新进程的大小\n" );scanf("%d",&neicun[i].daxiao);printf("\n 请输入新进程的内容\n" );scanf("%s",&neicun[i].neirong);neicun[i].state=1; /*将进程状态设为 1,表示在内存中*/num++;/*内存中进程数目加一*/}}/********************查看当前运行进程**************************/void run(){ bj=0;for(i=0;i<20;i++)if(neicun[i].state==1) /*若进程状态设为 1,表示在内存中,输出查看*/{printf("\n pid=%d",neicun[i].pid);printf(" youxianji=%d",neicun[i].youxianji);printf(" daxiao=%d",neicun[i].daxiao);printf(" neirong=%s",neicun[i].neirong);bj=1;/*存在于内存中的进程标记为 1 */}if(bj==0)printf("\n 当前没有运行该进程\n" );/*标记为 0,表示该进程未创建于内存中*/}/********************换出进程***************************/ void huanchu(){if(num==0) /*num=0,表示内存中无进程*/{ printf("\n 当前没有运行的进程\n" );return;}printf("\n 请输入要换出的进程的 pid 值\n" );scanf("%d",&pid);bj=0;for(i=0;i<20;i++){if(pid==neicun[i].pid){ if(neicun[i].state==1){neicun[i].state=2; /*将该进程的状态设为挂起*/guaqi++;printf("\n 该进程已成功挂起换出\n" );}else if(neicun[i].state==0)printf("\n 要换出的进程不存在\n" );else printf("\n 要换出的进程已经被挂起\n" );bj=1;break;}}if(bj==0) printf("\n 要换出的进程不存在\n" );}/********************杀死进程***************************/ void kill(){if(num==0){ printf("\n 当前没有运行的进程\n" );return;}printf("\n 请输入要杀死的进程的 pid 值\n" );scanf("%d",&pid);bj=0;for(i=0;i<20;i++){if(pid==neicun[i].pid){ if(neicun[i].state==1){neicun[i].state=0; /*将该进程的状态设为不在内存中*/num--; /*内存中的进程数目减少一个*/printf("\n 该进程已成功杀死\n" );}else if(neicun[i].state==0)printf("\n 要杀死的进程不存在\n" );else printf("\n 要杀死的进程已经被挂起\n" );/*剩余状态为 2,挂起*/bj=1;break;}}if(bj==0) printf("\n 要杀死的进程不存在\n" );}/********************唤醒进程***************************/ void huanxing(){if(num==0){ printf("当前没有运行的进程\n");return;}if(guaqi==0) /*guaqi=0,表示没有挂起的进程*/{ printf("\n 当前没有换出的进程\n");return;}printf("\n 请输入要唤醒的进程的 pid 值:\n");scanf("%d",&pid);for(i=0;i<20;i++){if(pid==neicun[i].pid){if(neicun[i].state==2){neicun[i].state=1; /*将该进程的状态设为挂起*/guaqi--;num++;printf("\n 该进程已成功唤醒\n" );}else if(neicun[i].state==0)printf("\n 要唤醒的进程不存在\n" );else printf("\n 要唤醒的进程已经在内存中\n" );}}}/********************主程序***************************/ void main(){int xuhao,n=1,i;for(i=0;i<20;i++)neicun[i].state=0; /*使所有进程都初始设为不在内存中*/ while(n){printf("\n**********************************************"); printf("\n* 进程演示系统 *");printf("\n**********************************************"); printf("\n 1.创建新的进程 2.查看运行进程");printf("\n 3.换出某个进程 4.杀死运行进程");printf("\n 5.唤醒某个进程 6.退出程序 ");printf("\n**********************************************"); printf("\n 请选择(1~6):");scanf("%d",&xuhao);switch(xuhao){case 1: create( ); break;case 2 :run(); break;case 3 :huanchu();break;case 4 :kill();break;case 5 :huanxing();break;case 6 :exit(0);default: n=0;break;}}}2、流程图分:①创建进程②查看进程合:三、实验结果1、创建进程2、查看运行进程3、换出进程4、杀死运行进程5、唤醒进程。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
}
}
}
create( ) /*创建一个进程的示例(不完整的程序)*/
{
if(shumu>=20)
{
printf("\n内存已满,请先结束或换出进程\n");
}
else
{
printf("\n请输入新进程的pid\n");
scanf("%d",&neicun[shumu+1].pid);
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;
实验一进程管理
1
通过实验理解进程的概念,进程的组成(PCB结构),进程的并发执行和操作系统进行进程管理的相关原语(主要是进程的创建、执行、撤消)。
2
用C语言编程模拟进程管理,至少要有:创建新的进程;查看运行进程;换出某个进程;杀死运行进程以及进程之间通信等功能。
3
Windows操作系统、VC++6.0
}
else
{
printf("\n所查看运行进程不存在\n");
}
printf("\n请按回车退出进程通信\n");
d=getch();
return;
}
5
********************************************
*进程演示系统*
********************************************
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);
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)
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)
printf("被替换进程的消息是:%d\n",waicun[20].msg);
}
else
{
printf("\n进程优先级不够大");
}
}
else
{
printf("所查看运行进程不存在");
}
printf("请按回车退出换出进程\n");
c=getche();
return;
}
kill()/*杀死运行进程*/
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;
1.创建新的进程2.查看运行进程
3.换出某个进程4.杀死运行进程
5.进程之间通信6.退出系统
********************************************
请选择(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': exit(0);
printf("\n 1.创建新的进程2.查看运行进程");
printf("\n 3.换出某个进程4.杀死运行进程");
printf("\n 5.进程之间通信6.退出");
printf("\n********************************************");
printf("\n请选择(1~6) ");
{
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);
{
system("cls");
printf("\n********************************************");
printf("\n*进程演示系统*");
printf("\n********************************************");
}
else
{
printf("\n所查看运行进程不存在\n");
}
printf("请按回车退出查看\n");
vpid=getch();
}
huanchu()/*换出某个进程*/
{
int pid1,pid2;
char c;
printf("\n请输入第一个替换进程的pid\n");
scanf("%d",&pid1);
C语言
4
PCB结构通常包括以下信息:进程名,进程优先数,轮转时间片,进程所占用的CPU时间,进程的状态,当前队列指针等。可根据实验的不同,PCB结构的内容可以作适当的增删。
主体程序
#include "conio.h"
#include "stdio.h"
#include "stdlib.h"
struct jincheng_type
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);
{
int pid;
int youxian;
int daxiao;
int msg;
int live;
};
struct jincheng_typeneicun[20],waicun[20];
int shumu=0,pid_l;
main()
{
int n,m,i;
char a;
n=1;
while(n==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);
printf("\n请输入第二个替换进程的pid\n");
scanf("%d",&pid2);