使用C语言二维数组实现进程调度，先来先服务和时间片轮转发

已于 2023-02-01 19:01:57 修改
阅读量760 收藏 3
点赞数
文章标签： c语言 开发语言
于 2021-12-06 16:22:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jinjin510623/article/details/121749616
版权

① 设计PCB及其数据结构：

    进程标识数：ID

    进程优先数：PRIORITY（优先数越大，优先级越高）

    进程已占用时间片：CPUTIME，每得到一次调度，值加1；

    进程还需占用时间片：ALLTIME，每得到一次调度，该值减1，一旦运行完毕，ALLTIME为0）

    进程队列指针：NEXT，用来将PCB排成队列

    进程状态：STATE（一般为就绪，可以不用）

② 设计进程就绪队列及数据结构；

③ 设计进程调度算法，并画出程序流程图；

④ 设计输入数据和输出格式；

   结构格式：当前正运行的进程：0

             当前就绪队列：2，1，3，4

⑤ 编程上机，验证结果。

#pragma once
// ConsoleApplication6.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#include<string>
using namespace std;
#include <iostream>
#include "标头.h"
//定义结构体
typedef struct pcb
{
	int id;
	unsigned int arrivetime;
	unsigned int alltime;
	unsigned int usetime;
	int finishtime;
}pcb;  //初始化执行表，和就绪表
//根据到达时间排序
void listsorted(pcb list[]) {
	int i=0,j=0;
	pcb temp[1];
	for (i; i < 5; i++) {
		for (j=i+1 ; j < 5; j++) {
			if (list[j].arrivetime < list[i].arrivetime) {
				temp[0] = list[i];
				list[i] = list[j];
				list[j] = temp[0];
			}
		}
	}
}
//输出先来先服务
void listprint(pcb list[], int i)
{
	printf("\n正在执行的进程：\n");
	cout << "进程ID\t\t到达时间\t需求时间\t使用cup时间 \t\t完成时间" << endl;
	cout << int(list[0].id )<< "\t\t" << int(list[0].arrivetime) << "\t\t" << list[0].alltime << "\t\t" << list[0].usetime << "\t\t\t" << list[0].finishtime << endl;

	printf("\n排队进程：\n");
	cout << "\t\t进程ID\t\t到达时间\t需求时间\t使用cup时间 \t\t完成时间" << endl;
	for (int t = 0; t < i; t++) {
		if (list[t].finishtime == 0) {
			cout << "\t\t" << list[t].id << "\t\t" << list[t].arrivetime << "\t\t" << list[t].alltime << "\t\t" << list[t].usetime << "\t\t\t" << list[t].finishtime << endl;
		}
	}
}

// 使用先来先服务算法,根据到达时间的先后顺序对进程进行调度
void Fifo(pcb pcblist[],int &listtime,int i) {
	listsorted(pcblist);
	
	pcblist[0].finishtime = pcblist[0].arrivetime + pcblist[0].alltime;
	pcblist[0].usetime = pcblist[0].alltime;
	listtime += pcblist[0].usetime;
	listprint(pcblist, i);
	pcblist[0].arrivetime = -99;
	
}



#pragma once
// ConsoleApplication6.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#include<string>
using namespace std;
#include <iostream>
#include "标头.h"
//定义结构体
typedef struct pcb
{
	int id;
	unsigned int arrivetime;
	unsigned int alltime;
	unsigned int usetime;
	int finishtime;
}pcb;  //初始化执行表，和就绪表
//根据到达时间排序
void listsorted(pcb list[]) {
	int i=0,j=0;
	pcb temp[1];
	for (i; i < 5; i++) {
		for (j=i+1 ; j < 5; j++) {
			if (list[j].arrivetime < list[i].arrivetime) {
				temp[0] = list[i];
				list[i] = list[j];
				list[j] = temp[0];
			}
		}
	}
}
//输出先来先服务
void listprint(pcb list[], int i)
{
	printf("\n正在执行的进程：\n");
	cout << "进程ID\t\t到达时间\t需求时间\t使用cup时间 \t\t完成时间" << endl;
	cout << int(list[0].id )<< "\t\t" << int(list[0].arrivetime) << "\t\t" << list[0].alltime << "\t\t" << list[0].usetime << "\t\t\t" << list[0].finishtime << endl;

	printf("\n排队进程：\n");
	cout << "\t\t进程ID\t\t到达时间\t需求时间\t使用cup时间 \t\t完成时间" << endl;
	for (int t = 0; t < i; t++) {
		if (list[t].finishtime == 0) {
			cout << "\t\t" << list[t].id << "\t\t" << list[t].arrivetime << "\t\t" << list[t].alltime << "\t\t" << list[t].usetime << "\t\t\t" << list[t].finishtime << endl;
		}
	}
}

// 使用先来先服务算法,根据到达时间的先后顺序对进程进行调度
void Fifo(pcb pcblist[],int &listtime,int i) {
	listsorted(pcblist);
	
	pcblist[0].finishtime = pcblist[0].arrivetime + pcblist[0].alltime;
	pcblist[0].usetime = pcblist[0].alltime;
	listtime += pcblist[0].usetime;
	listprint(pcblist, i);
	pcblist[0].arrivetime = -99;
	
}
#pragma once
// ConsoleApplication6.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#include<string>
using namespace std;
#include <iostream>
#include "标头.h"
//定义结构体
typedef struct pcb
{
	int id;
	unsigned int arrivetime;
	unsigned int alltime;
	unsigned int usetime;
	int finishtime;
}pcb;  //初始化执行表，和就绪表
//根据到达时间排序
void listsorted(pcb list[]) {
	int i=0,j=0;
	pcb temp[1];
	for (i; i < 5; i++) {
		for (j=i+1 ; j < 5; j++) {
			if (list[j].arrivetime < list[i].arrivetime) {
				temp[0] = list[i];
				list[i] = list[j];
				list[j] = temp[0];
			}
		}
	}
}
//输出先来先服务
void listprint(pcb list[], int i)
{
	printf("\n正在执行的进程：\n");
	cout << "进程ID\t\t到达时间\t需求时间\t使用cup时间 \t\t完成时间" << endl;
	cout << int(list[0].id )<< "\t\t" << int(list[0].arrivetime) << "\t\t" << list[0].alltime << "\t\t" << list[0].usetime << "\t\t\t" << list[0].finishtime << endl;

	printf("\n排队进程：\n");
	cout << "\t\t进程ID\t\t到达时间\t需求时间\t使用cup时间 \t\t完成时间" << endl;
	for (int t = 0; t < i; t++) {
		if (list[t].finishtime == 0) {
			cout << "\t\t" << list[t].id << "\t\t" << list[t].arrivetime << "\t\t" << list[t].alltime << "\t\t" << list[t].usetime << "\t\t\t" << list[t].finishtime << endl;
		}
	}
}

// 使用先来先服务算法,根据到达时间的先后顺序对进程进行调度
void Fifo(pcb pcblist[],int &listtime,int i) {
	listsorted(pcblist);
	
	pcblist[0].finishtime = pcblist[0].arrivetime + pcblist[0].alltime;
	pcblist[0].usetime = pcblist[0].alltime;
	listtime += pcblist[0].usetime;
	listprint(pcblist, i);
	pcblist[0].arrivetime = -99;
	
}





#pragma once


//排序,row行数，m根据某一列排序
void sorted(int a[5][5], int row, int m)
{
	int n,j,t;
	int temp[10];
	for (n = 0; n < row - 1; n++) {
		for (j = n + 1; j < row; j++)
			if (a[j][m] > a[n][m])
			{
				for (t = 0; t < row ; t++) {
					temp[t] = a[n][t];
					a[n][t] = a[j][t];
					a[j][t] = temp[t];
				}
			}
	}
}
//打印元素a二维数组，
void print_f(int a[][5],int row,int column,string s[])
{	
	int n, m;
	printf("\n\n\t\t\t各进程状态\n");
	cout <<s[0]<<"\t\t" << s[1]<<"\t" << s[2] << "\t\t" << s[3] << "\t\t" << s[4];
	printf("\n");
	for (n = 0; n < row; n++) {
		for (m = 0; m < column; m++) {
			printf("%d\t\t",a[n][m]);
			if (m == column - 1) printf("\n");
		}
	}
}
//调度算法,a二维数组，row行键，column列键，arr就绪队列
void process_manege(int a[][5],int row,int column, int* arr,int &arr_count)
{	
	int check, temp_i = 0, id_count = 0;
	int temp[5] = { -1,-1,-1,-1,-1 };
	for (check = 0; check < row; check++) {
		if (a[check][4] == 0) {         //判断进程是否结束
			printf("\n第%d号进程已结束", a[check][0]);
			for (int m = 1; m < column-1; m++)	a[check][m] = -99;
			//arr_count = arr_count-1;
		}
	}
	sorted(a, row, 1);
	for (id_count ,temp_i; id_count <row;id_count++) //添加至就绪队列
	{
		if (a[id_count][4] != 0) {
			temp[temp_i] = a[id_count][0];
			temp_i++;
		}
		arr = temp;
	}
	printf("\n当前正运行的进程：%d",arr[0]);
	printf("\n当前就绪队列：");
	for (int state_id = 1; state_id < row;state_id++)  
		printf(" %d ", arr[state_id]);
	a[0][1]-=3,a[0][2]+=1,a[0][3]-=1;     //对正在运行进程进行更改
	if (a[0][3] == 0) { a[0][4] = 0; arr_count = arr_count - 1; }
}


#include<string>
using namespace std;
#include <iostream>
#include "标头.h"
#include "标头1.h"

int main1()
{	
	int timepip = 2;
	
	int row=5;     //进程数
	int column = 5;//属性数
	int arr[5] = { NULL };//就绪队列
	int arr_count = 5;    //计数arr里元素个数
	int flag = 1;
	//初始化静态数组,ID,PRIORITY,CPUTIME,ALLTIME,STATE(ready=1,finish=0)
	string pcb[15] = { "ID","PRIORITY","CPUTIME","ALLTIME","STATE" };
	int process_id[5][5] = { { 0,9,0,3,1 },{ 1,38,0,2,1 }, { 2,30,0,6,1 }, { 3,29,0,3,1 },{ 4,0,0,4,1 } };
	printf("初始进程队列\n");
	print_f(process_id, row, column, pcb);
	printf("\n");
	while (flag) {
		printf("已用时间：%ds", timepip);
		process_manege(process_id, row, column, arr,arr_count);
		printf("\t剩余进程%d个",arr_count);
		print_f(process_id, row, column, pcb);
		timepip += 2;
		if(arr_count == 0) flag = 0;
		printf("\n\n");
	}
	return 0;
}

int main2()
{	
	int listtime = 0;
	int i = 5,j =5;  //i=j表示进程个数
	pcb pcblist[5] = { NULL };
	pcblist[0].id = 1, pcblist[0].arrivetime = 4, pcblist[0].alltime = 4, pcblist[0].usetime = 0, pcblist[0].finishtime = 0;
	pcblist[1].id = 2, pcblist[1].arrivetime = 9, pcblist[1].alltime = 6, pcblist[1].usetime = 0, pcblist[1].finishtime = 0;
	pcblist[2].id = 3, pcblist[2].arrivetime = 1, pcblist[2].alltime = 45, pcblist[2].usetime = 0, pcblist[2].finishtime = 0;
	pcblist[3].id = 4, pcblist[3].arrivetime = 3, pcblist[3].alltime = 5, pcblist[3].usetime = 0, pcblist[3].finishtime = 0;
	pcblist[4].id = 5, pcblist[4].arrivetime = 2, pcblist[4].alltime = 22, pcblist[4].usetime = 0, pcblist[4].finishtime = 0;
	
	while (j>0)
	{	
		Fifo(pcblist, listtime, i);
		printf("总花销时间：%d\n\n",listtime);
		j--;
	}
	return 0;
}

int main()
{
	printf("使用优先级时间片算法:\n");
	main2();
	printf("使用先来先服务算法:\n");
	main1();
}

孑立—耶
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
进程调度 时间片轮转调度算法源代码（C语言）
12-18
进程调度 时间片轮转调度算法源代码（C语言）
“时间片轮转”调度算法（C语言）
热门推荐
qq_51673383的博客
04-17 1万+
编写并调试一个模拟的进程调度程序，以加深对进程的概念及进程调度算法的理解． 1.调试运行“时间片轮转”调度算法，给出运行结果。 2.采用“时间片轮转”调度算法对进程进行调度。每个进程有一个进程控制块（ PCB）表示。进程控制块可以包含如下信息：进程名、到达时间、需要运行时间、已用CPU时间、进程状态等等 3.显示进程运行过程，以及进程的带权周转时间和系统的平均带权周转时间。。
【操作系统】基于动态优先级的进程调度算法-C语言实现（有代码）
peng_lv的博客
11-14 6860
基于动态优先级的进程调度算法-C语言实现（有代码）
进程控制与进程调度 —— 时间片轮转调度算法（C++版）
最新发布
qq_66095714的博客
05-29 2197
C++实现时间片轮转调度算法
C语言实现优先级调度算法
weixin_46447549的博客
04-22 9803
一、问题描述 采用C语言实现优先级调度算法。编制进程调度模拟程序，并计算每个进程的周转时间，带权周转时间，以及所有进程的平均周转时间和平均带权周转时间。 二、源代码 #include <iostream> #include <iomanip> //格式化输出 using namespace std; //最大进程数 #define MAXSIZE_N 10 //定义数据结构 struct PCB{ int number;//进程代号 int arrive_time
jinchen.zip_先来先服务_先来先服务C++_时间片_时间轮_进程调度
09-14
进程调度，先来先服务，最优先服务，时间轮片算法
操作系统进程调度算法 先来先服务 短作业优先 时间片轮转 优先级。
11-18
操作系统进程调度算法 先来先服务 短作业优先 时间片轮转 优先级。有大量注释，帮助理解。目前没有错误
Java模拟最短作业优先、时间片轮转、最高响应比和先来先服务进程调度算法
06-21
Java模拟最短作业优先、时间片轮转、最高响应比和先来先服务进程调度算法 rar中有四种算法和俩个对进程用时和周转时间制图的java源代码，另外有jcommon-1.0.23.jar和jfreechart-1.0.19.jar俩个制图包
操作系统编程进程或作业先来先服务、高优先权、按时间片轮转调度算法
03-29
操作系统编程进程或作业先来先服务、高优先权、按时间片轮转调度算法
进程调度和作业调度算法C语言实现
04-13
操作系统os进程调度，作业调度以及请求分页系统的实现，其中进程调度涉及FCFS算法，时间片轮转法以及多级反馈队列实现。作业调度涉及FCFS以及短作业优先等。有源代码以及文档解释
时间片轮转算法的是想用C语言
12-31
时间片轮转算法的是想用C语言实现的，与操作系统的实验啊。
C语言模拟单处理器时间片轮转调度算法
06-10
用C语言模拟单处理器时间片轮转调度算法 数据结构..pcb进程控制模块
优先级和时间片轮转调度实验算法（c语言）
05-17
进程调度算法有优先数调度算法，时间片轮转调度算法，分级调度算法。选两种种算法实现。进程调度算法的数据结构主要有：进程函数定义，建立进程函数，进程调度函数。
时间片轮转调度模拟程序.c
11-26
操作系统课程时间片轮转调度模拟程序，程序相对简单，通过这个模拟程序能够帮助学习者会更好的学习os，供有需要的人学习使用。
操作系统实验一模拟优先级调度算法（C语言实现附带详细注释）
轻舟终过万重山
10-20 9971
操作系统实验：使用C语言模拟优先级调度算法过程，加深理解
时间片轮转法（c语言）
赵四司机的博客
08-16 6717
C语言实现调度策略中的时间片轮转法
进程调度模拟算法C语言（数组方式）最高优先级算法以及短作业算法
ly's Blog
05-10 1866
#include&lt;stdio.h&gt;struct PCB    //表示每一个进程控制块 { char name[30];    //进程的名字 int number;       //进程的编号  float run_time;     //进程运行时间  float run_begin_time;   //进程开始运行时间  int youxianji;    //进程优先级 flo...
c语言之——指针与二维数组
wwwlyj123321的博客
03-24 3912
一、数组的行优先和列优先 对于二维数组，有行优先顺序和列优先顺序两种不同的存储方式。由于计算机内存是一维的，多维数组的元素应排成线性序列后存人存储器。 数组一般不做插入和删除操作，即结构中元素个数和元素间关系不变化。一般采用顺序存储方法表示数组。 这两种方式在数学上的直观描述如下，给定如下矩阵： 根据行优先的原则，其排序方式为 根据列优先的原则，其排序方式为 行优先或者列优先没有好坏，但其直接涉及到对内存中数据的最佳存储访问方式。因为在内存使用上，程序访问的内存地址之间连续性越好，程序
【操作系统】使用C语言实现轮转法进程调度（有代码）
peng_lv的博客
11-05 1031
使用C语言实现轮转法进程调度
用c语言的时间片转轮调度算法实现单处理机系统的进程调度
03-30
以下是使用C语言实现时间片转轮调度算法的单处理机系统进程调度的示例代码： ```c #include #include // 定义进程结构体 typedef struct { int pid; // 进程ID int burst; // 进程的执行时间 int remaining; //...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值