Process Scheduling Algorithms (FCFS, SJF, RR, PSA)

已于 2022-11-12 20:52:08 修改
阅读量210 收藏 1
点赞数
分类专栏： 笔记 文章标签： c语言 linux ubuntu
于 2022-11-12 20:31:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63047274/article/details/127824970
版权 
#pragma warning (disable : 4996)
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>

#define NameLength 4
#define ProcessNumberLimit 8
#define TimeLimit 16
#define PriorityLimit 8

enum statusType {
	Arrival = 0, Wait, Run, Finish
};

typedef struct process {
	char name[NameLength];
	enum statusType status;
	int arrivalTime;
	int needTime;
	int burstTime;
	int startTime;
	int endTime;
	int priority;
	int round;
}PCB;

typedef struct {
	PCB data[ProcessNumberLimit];
	int first;
	int last;
}list;

char algorithmType = '0';
int processNumber = 0;
list arrivalList;
list waitList;
list finishList;
int Round = 0;

void selectAlgorithm();
void initialList();
void createProcess();
void createTypeFAndS();
void createTypeR();
void createTypeP();
void insertInArrivalList(PCB p);
void sortArrivalListToAscending();
void titleTypeFAndS();
void showTypeFAndS(PCB pi);
void titleTypeR();
void showTypeR(PCB pi);
void titleTypeP();
void showTypeP(PCB pi);
int scheduleIsFinish();
void schedule();
void scheduleTypeF(int* time);
void scheduleTypeS(int* time);
void scheduleTypeR(int* time);
void scheduleTypeP(int* time);
void insertInWaitList(int time);
void insertInFinishList(PCB p);
void displayCurrentCondition(int time);
void firstWaitInSJF();
void firstWaitInPSA();

int main() {
	selectAlgorithm();
	initialList();
	createProcess();
	schedule();
	return 0;
}

void selectAlgorithm() {
	do {
		printf("The character 'f' represents FCFS, 's' represents SJF, 'r' represents RR and 'p' represents PSA.\n");
		printf("Input the character which represents the algorithm you want to select: ");
		scanf("%c", &algorithmType);
		char temp;
		while ('\n' != (temp = getchar()) && EOF != temp);//Replace fflush(stdin) with this because GCC does not support the former;
	} while ('f' != algorithmType && 's' != algorithmType && 'r' != algorithmType && 'p' != algorithmType);
	printf("The algorithm you select is ");
	switch (algorithmType) {
	case 'f': {
		printf("FCFS.\n");
		break;
	}
	case 's': {
		printf("SJF.\n");
		break;
	}
	case 'r': {
		printf("RR.\n");
		break;
	}
	case 'p': {
		printf("PSA.\n");
		break;
	}
	default: {
		exit(-1);
		break;
	}
	}
	return;
}

void initialList() {
	arrivalList.first = 0;
	arrivalList.last = 0;
	waitList.first = 0;
	waitList.last = 0;
	finishList.first = 0;
	finishList.last = 0;
	return;
}

void createProcess() {
	do {
		printf("Input the number of process (from 1 to %d) : ", ProcessNumberLimit);
		scanf("%d", &processNumber);
		char temp;
		while ('\n' != (temp = getchar()) && EOF != temp);//Replace fflush(stdin) with this because GCC does not support the former;
	} while (processNumber < 1 || processNumber > ProcessNumberLimit);
	printf("The number of process is %d\n", processNumber);
	switch (algorithmType) {
	case 'f': {
		createTypeFAndS();
		printf("Condation at time 0 is:\n");
		titleTypeFAndS();
		for (int i = arrivalList.first; arrivalList.last != i; i = (i + 1) % ProcessNumberLimit) {
			showTypeFAndS(arrivalList.data[i]);
		}
		break;
	}
	case 's': {
		createTypeFAndS();
		printf("Condation at time 0 is:\n");
		titleTypeFAndS();
		for (int i = arrivalList.first; arrivalList.last != i; i = (i + 1) % ProcessNumberLimit) {
			showTypeFAndS(arrivalList.data[i]);
		}
		break;
	}
	case 'r': {
		createTypeR();
		printf("Condation at time 0 is:\n");
		titleTypeR();
		for (int i = arrivalList.first; arrivalList.last != i; i = (i + 1) % ProcessNumberLimit) {
			showTypeR(arrivalList.data[i]);
		}
		break;
	}
	case 'p': {
		createTypeP();
		printf("Condation at time 0 is:\n");
		titleTypeP();
		for (int i = arrivalList.first; arrivalList.last != i; i = (i + 1) % ProcessNumberLimit) {
			showTypeP(arrivalList.data[i]);
		}
		break;
	}
	default: {
		exit(-1);
		break;
	}
	}
	return;
}

void createTypeFAndS() {
	printf("Now create as type FAndS.\n");
	printf("########\n");
	for (int i = 1; i <= processNumber; i++) {
		PCB p;
		printf("Input process name (max length is %d) : ", NameLength);
		scanf("%s", p.name);
		do {
			printf("Input arrival time (from 0 to %d) : ", TimeLimit);
			scanf("%d", &(p.arrivalTime));
		} while (p.arrivalTime < 0 || p.arrivalTime > TimeLimit);
		do {
			printf("Input need time (from 1 to %d) : ", TimeLimit);
			scanf("%d", &(p.needTime));
		} while (p.needTime < 1 || p.needTime > TimeLimit);
		char temp;
		while ('\n' != (temp = getchar()) && EOF != temp);//Replace fflush(stdin) with this because GCC does not support the former;
		printf("########\n");
		p.burstTime = 0;
		p.startTime = 0;
		p.endTime = 0;
		insertInArrivalList(p);
	}
	sortArrivalListToAscending();
	return;
}

void createTypeR() {
	printf("Now create as type R.\n");
	do {
		printf("Input round (from 1 to %d) : ", TimeLimit / 2);
		scanf("%d", &Round);
	} while (Round < 1 || Round > TimeLimit / 2);
	printf("OK, round will be %d.\n", Round);
	printf("########\n");
	for (int i = 1; i <= processNumber; i++) {
		PCB p;
		printf("Input process name (max length is %d) : ", NameLength);
		scanf("%s", p.name);
		do {
			printf("Input arrival time (from 0 to %d) : ", TimeLimit);
			scanf("%d", &(p.arrivalTime));
		} while (p.arrivalTime < 0 || p.arrivalTime > TimeLimit);
		do {
			printf("Input need time (from 1 to %d) : ", TimeLimit);
			scanf("%d", &(p.needTime));
		} while (p.needTime < 1 || p.needTime > TimeLimit);
		char temp;
		while ('\n' != (temp = getchar()) && EOF != temp);//Replace fflush(stdin) with this because GCC does not support the former;
		printf("########\n");
		p.burstTime = 0;
		p.startTime = 0;
		p.endTime = 0;
		p.round = Round;
		insertInArrivalList(p);
	}
	sortArrivalListToAscending();
	return;
}

void createTypeP() {
	printf("Now create as type P.\n");
	printf("########\n");
	for (int i = 1; i <= processNumber; i++) {
		PCB p;
		printf("Input process name (max length is %d) : ", NameLength);
		scanf("%s", p.name);
		do {
			printf("Input arrival time (from 0 to %d) : ", TimeLimit);
			scanf("%d", &(p.arrivalTime));
		} while (p.arrivalTime < 0 || p.arrivalTime > TimeLimit);
		do {
			printf("Input need time (from 1 to %d) : ", TimeLimit);
			scanf("%d", &(p.needTime));
		} while (p.needTime < 1 || p.needTime > TimeLimit);
		do {
			printf("Input the priority (from 0 to %d) : ", PriorityLimit);
			scanf("%d", &(p.priority));
		} while (p.priority < 0 || p.priority > PriorityLimit);
		char temp;
		while ('\n' != (temp = getchar()) && EOF != temp);//Replace fflush(stdin) with this because GCC does not support the former;
		printf("########\n");
		p.burstTime = 0;
		p.startTime = 0;
		p.endTime = 0;
		insertInArrivalList(p);
	}
	sortArrivalListToAscending();
	return;
}

void insertInArrivalList(PCB p) {
	p.status = Arrival;
	arrivalList.data[arrivalList.last] = p;
	arrivalList.last = (arrivalList.last + 1) % ProcessNumberLimit;
	return;
}

void sortArrivalListToAscending() {
	int latest;
	for (int i = arrivalList.first; arrivalList.last != (i + 1) % ProcessNumberLimit; i = (i + 1) % ProcessNumberLimit) {
		latest = i;
		for (int j = (i + 1) % ProcessNumberLimit; arrivalList.last != j; j = (j + 1) % ProcessNumberLimit) {
			if (arrivalList.data[j].arrivalTime < arrivalList.data[latest].arrivalTime) {
				latest = j;
			}
		}
		if (i != latest) {
			PCB temp = arrivalList.data[i];
			arrivalList.data[i] = arrivalList.data[latest];
			arrivalList.data[latest] = temp;
		}
	}
	return;
}

void titleTypeFAndS() {
	printf("ProcessName\tStatus\t\tArrivalTime\tNeedTime\tBurstTime\tStartTime\tEndTime\n");
	return;
}

void showTypeFAndS(PCB pi) {
	printf("%s\t\t%d\t\t%d\t\t%d\t\t%d\t\t%d\t\t%d\n", pi.name, pi.status, pi.arrivalTime, pi.needTime, pi.burstTime, pi.startTime, pi.endTime);
	return;
}

void titleTypeR() {
	printf("ProcessName\tStatus\t\tArrivalTime\tNeedTime\tBurstTime\tStartTime\tEndTime\t\tRound\n");
	return;
}

void showTypeR(PCB pi) {
	printf("%s\t\t%d\t\t%d\t\t%d\t\t%d\t\t%d\t\t%d\t\t%d\n", pi.name, pi.status, pi.arrivalTime, pi.needTime, pi.burstTime, pi.startTime, pi.endTime, pi.round);
	return;
}

void titleTypeP() {
	printf("ProcessName\tStatus\t\tArrivalTime\tNeedTime\tBurstTime\tStartTime\tEndTime\t\tPriority\n");
	return;
}

void showTypeP(PCB pi) {
	printf("%s\t\t%d\t\t%d\t\t%d\t\t%d\t\t%d\t\t%d\t\t%d\n", pi.name, pi.status, pi.arrivalTime, pi.needTime, pi.burstTime, pi.startTime, pi.endTime, pi.priority);
	return;
}

int scheduleIsFinish() {
	if (processNumber == finishList.last - finishList.first) {//totally in finishList;
		return 1;
	}
	else {
		return 0;
	}
}

void schedule() {
	int time = 0;
	insertInWaitList(time);
	while (0 == scheduleIsFinish()) {
		switch (algorithmType) {
		case 'f': {
			scheduleTypeF(&time);
			break;
		}
		case 's': {
			scheduleTypeS(&time);
			break;
		}
		case 'r': {
			scheduleTypeR(&time);
			break;
		}
		case 'p': {
			scheduleTypeP(&time);
			break;
		}
		default: {
			exit(-1);
			break;
		}
		}
	}
	return;
}

void scheduleTypeF(int* time) {
	printf("Scheduling Algorithm: FCFS.\n");
	if (waitList.last == waitList.first) {//current have nothing in waitList, try next second;
		(*time)++;
	}
	else {
		if (Run != waitList.data[waitList.first].status) {//need to choose a new one to run;
			waitList.data[waitList.first].startTime = (*time);
			waitList.data[waitList.first].status = Run;
		}
		waitList.data[waitList.first].burstTime++;
		(*time)++;
		if (waitList.data[waitList.first].needTime == waitList.data[waitList.first].burstTime) {
			waitList.data[waitList.first].endTime = (*time);
			insertInFinishList(waitList.data[waitList.first]);
			waitList.first = (waitList.first + 1) % ProcessNumberLimit;
		}
	}
	insertInWaitList(*time);
	displayCurrentCondition(*time);
	return;
}

void scheduleTypeS(int* time) {
	printf("Scheduling Algorithm: SJF.\n");
	if (waitList.last == waitList.first) {//current have nothing in waitList, try next second;
		(*time)++;
	}
	else {
		if (Run != waitList.data[waitList.first].status) {//need to choose a new one to run;
			firstWaitInSJF();
			waitList.data[waitList.first].startTime = (*time);
			waitList.data[waitList.first].status = Run;
		}
		waitList.data[waitList.first].burstTime++;
		(*time)++;
		if (waitList.data[waitList.first].needTime == waitList.data[waitList.first].burstTime) {
			waitList.data[waitList.first].endTime = (*time);
			insertInFinishList(waitList.data[waitList.first]);
			waitList.first = (waitList.first + 1) % ProcessNumberLimit;
		}
	}
	insertInWaitList(*time);
	displayCurrentCondition(*time);
	return;
}

void scheduleTypeR(int* time) {
	printf("Scheduling Algorithm: RR.\n");
	if (waitList.last == waitList.first) {//current have nothing in waitList, try next second;
		(*time)++;
	}
	else {//have something;
		if (Run != waitList.data[waitList.first].status) {//first not run;
			if (Round == waitList.data[waitList.first].round) {//first time;
				waitList.data[waitList.first].startTime = (*time);
			}
			else {//not first time;
				waitList.data[waitList.first].round = Round;//initial round;
			}
			waitList.data[waitList.first].status = Run;
		}
		else {//first is run;
			if (0 == waitList.data[waitList.first].round) {
				waitList.data[waitList.first].status = Wait;
				waitList.data[waitList.last] = waitList.data[waitList.first];
				waitList.last = (waitList.last + 1) % ProcessNumberLimit;
				waitList.first = (waitList.first + 1) % ProcessNumberLimit;
				printf("Round is zero, next one.\n");
				return;
			}
		}
		waitList.data[waitList.first].burstTime++;
		waitList.data[waitList.first].round--;
		(*time)++;
		if (waitList.data[waitList.first].needTime == waitList.data[waitList.first].burstTime) {
			waitList.data[waitList.first].round = 0;//finish;
			waitList.data[waitList.first].endTime = (*time);
			insertInFinishList(waitList.data[waitList.first]);
			waitList.first = (waitList.first + 1) % ProcessNumberLimit;
		}
	}
	insertInWaitList(*time);
	displayCurrentCondition(*time);
	return;
}

void scheduleTypeP(int* time) {
	printf("Scheduling Algorithm: PSA.\n");
	if (waitList.last == waitList.first) {//current have nothing in waitList, try next second;
		(*time)++;
	}
	else {
		if (Run != waitList.data[waitList.first].status) {//need to choose a new one to run;
			firstWaitInPSA();
			waitList.data[waitList.first].startTime = (*time);
			waitList.data[waitList.first].status = Run;
		}
		waitList.data[waitList.first].burstTime++;
		(*time)++;
		if (waitList.data[waitList.first].needTime == waitList.data[waitList.first].burstTime) {
			waitList.data[waitList.first].endTime = (*time);
			insertInFinishList(waitList.data[waitList.first]);
			waitList.first = (waitList.first + 1) % ProcessNumberLimit;
		}
	}
	insertInWaitList(*time);
	displayCurrentCondition(*time);
	return;
}

void insertInWaitList(int time) {
	for (int i = arrivalList.first; (arrivalList.data[i].arrivalTime <= time) && (arrivalList.last != i); i = (i + 1) % ProcessNumberLimit) {
		arrivalList.data[i].status = Wait;
		waitList.data[waitList.last] = arrivalList.data[i];
		waitList.last = (waitList.last + 1) % ProcessNumberLimit;
		arrivalList.first = (arrivalList.first + 1) % ProcessNumberLimit;
	}
	return;
}

void insertInFinishList(PCB p) {
	p.status = Finish;
	finishList.data[finishList.last] = p;
	finishList.last = (finishList.last + 1) % ProcessNumberLimit;
	return;
}

void displayCurrentCondition(int time) {
	printf("Now, time is %d.\n", time);
	switch (algorithmType) {
	case 'f': {
		titleTypeFAndS();
		if (arrivalList.last != arrivalList.first) {
			for (int i = arrivalList.first; arrivalList.last != i; i = (i + 1) % ProcessNumberLimit) {
				showTypeFAndS(arrivalList.data[i]);
			}
		}
		if (waitList.last != waitList.first) {
			for (int i = waitList.first; waitList.last != i; i = (i + 1) % ProcessNumberLimit) {
				showTypeFAndS(waitList.data[i]);
			}
		}
		if (finishList.last != finishList.first) {
			for (int i = finishList.first; finishList.last != i; i = (i + 1) % ProcessNumberLimit) {
				showTypeFAndS(finishList.data[i]);
			}
		}
		break;
	}
	case 's': {
		titleTypeFAndS();
		if (arrivalList.last != arrivalList.first) {
			for (int i = arrivalList.first; arrivalList.last != i; i = (i + 1) % ProcessNumberLimit) {
				showTypeFAndS(arrivalList.data[i]);
			}
		}
		if (waitList.last != waitList.first) {
			for (int i = waitList.first; waitList.last != i; i = (i + 1) % ProcessNumberLimit) {
				showTypeFAndS(waitList.data[i]);
			}
		}
		if (finishList.last != finishList.first) {
			for (int i = finishList.first; finishList.last != i; i = (i + 1) % ProcessNumberLimit) {
				showTypeFAndS(finishList.data[i]);
			}
		}
		break;
	}
	case 'r': {
		titleTypeR();
		if (arrivalList.last != arrivalList.first) {
			for (int i = arrivalList.first; arrivalList.last != i; i = (i + 1) % ProcessNumberLimit) {
				showTypeR(arrivalList.data[i]);
			}
		}
		if (waitList.last != waitList.first) {
			for (int i = waitList.first; waitList.last != i; i = (i + 1) % ProcessNumberLimit) {
				showTypeR(waitList.data[i]);
			}
		}
		if (finishList.last != finishList.first) {
			for (int i = finishList.first; finishList.last != i; i = (i + 1) % ProcessNumberLimit) {
				showTypeR(finishList.data[i]);
			}
		}
		break;
	}
	case 'p': {
		titleTypeP();
		if (arrivalList.last != arrivalList.first) {
			for (int i = arrivalList.first; arrivalList.last != i; i = (i + 1) % ProcessNumberLimit) {
				showTypeP(arrivalList.data[i]);
			}
		}
		if (waitList.last != waitList.first) {
			for (int i = waitList.first; waitList.last != i; i = (i + 1) % ProcessNumberLimit) {
				showTypeP(waitList.data[i]);
			}
		}
		if (finishList.last != finishList.first) {
			for (int i = finishList.first; finishList.last != i; i = (i + 1) % ProcessNumberLimit) {
				showTypeP(finishList.data[i]);
			}
		}
		break;
	}
	default: {
		exit(-1);
		break;
	}
	}
	return;
}

void firstWaitInSJF() {
	int index = waitList.first;
	for (int i = waitList.first + 1; waitList.last != i; i = (i + 1) % ProcessNumberLimit) {
		if (waitList.data[index].needTime > waitList.data[i].needTime) {
			index = i;
		}
	}
	if (waitList.first != index) {
		PCB temp = waitList.data[index];
		waitList.data[index] = waitList.data[waitList.first];
		waitList.data[waitList.first] = temp;
	}
	return;
}

void firstWaitInPSA() {
	int index = waitList.first;
	for (int i = waitList.first + 1; waitList.last != i; i = (i + 1) % ProcessNumberLimit) {
		if (waitList.data[index].priority < waitList.data[i].priority) {
			index = i;
		}
	}
	if (waitList.first != index) {
		PCB temp = waitList.data[index];
		waitList.data[index] = waitList.data[waitList.first];
		waitList.data[waitList.first] = temp;
	}
	return;
}

The above is an independent creation completely from the NUC programming god, all rights reserved, and the infringer must be sanctioned by the tiger security.

2022/11/12 20:30 from NUC 11-513, college no.7.

Operating System · Process and Scheduling(操作系统 · 进程与调度策略)(三)
victorieskkkk的博客
09-05 594
Process（进程） 文章目录Process（进程）前言一、程序并发执行二、进程1. 进程控制块PCB (Process Control Block)二、使用步骤1.引入库2.读入数据总结 前言 通过上一章节操作系统的历史演进我们知道，为了提高资源利用率和系统吞吐量，人们发明了多道批处理操作系统，将多个程序同时装入内存，并使之并发运行，传统意义上的程序不再独立运行。此时，作为资源分配和独立运行的基本单位我们称之为进程(process)。在操作系统中，进程是非常重要的概念，可以说掌握了进程就掌握了操作系
操作系统（五）：FCFS/SJF/非抢占优先级/RR
热门推荐
weixin_43531643的博客
09-22 1万+
操作系统（五）：FCFS/SJF/非抢占优先级/RR 一、题目1（书上170页5.7） 5.4 5.4 Consider the following set of processes, with the length of the CPU burst time given in milliseconds: The processes are assumed to have arrived in ...
操作系统03进程管理Process_Scheduling
weixin_37289816的博客
02-17 1831
2 Process Scheduling >Type of scheduling >Scheduling Criteria (准则) >Scheduling Algorithm >Real-Time Scheduling (嵌入式系统)   2.1 Learning Objectives By the end of this lecture you should be able to
ProcessSchedulingRules:各种进程调度的算法
05-12
ProcessSchedulingRules 各种进程调度的算法 FCFS 先来先服务算法 过程 结果 SPF 短进程优先算法 过程 结果 RFPF & AFPF (非)抢占式优先权算法 结果
操作系统学习笔记（六）---CPU调度
雲的博客
01-19 5457
目录 一、例题 二、调度准则 三、调度算法（Scheduling algorithm） 附：线程调度 一、例题 1.Explain the difference between preemptive and nonpreemptive scheduling. Answer: 如果调度方案是非抢占的（nonpreemptive），一旦CPU分配给一个进程，那么该进程会一直使用CPU直...
ch8 CPU Scheduling Algorithms
期待幸福
04-26 1037
文章目录Overview调度准则CPU的调度策略抢占式调度非抢占式调度如何确定调度是抢占式还是非抢占式？程序执行模型调度指标比较算法的准则公平的目标调度算法基本调度算法先到先服务最短作业优先最高响应比优先HRRN的特点轮训性能RR的特点多级反馈队列公平共享调度实时调度RTS分类:RTS相关时间参数实时系统要求EDFRM多处理器调度多处理器调度方法亲和度负载均衡优先级反转 Overview CPU调度 (cpu scheduling )，是决定在一个时间窗口内，哪个进程可以拥有CPU而另外一个个进程会被暂停的
!!!Chapter 5 Process Scheduling
b_end_an的专栏
09-18 1099
5.1 Basic Concepts 5.1.1 CPU - I/O Burst Cycle The success of CPU scheduling depends on an observed property of processes: process execution consists of a cycle of CPU execution and I/O wait. 5.1.2
CPT104操作系统笔记（scheduling I）
Lynn_806的博客
04-05 914
Basic Concepts CPU –I/O Burst Cycle • Process execution consists of a cycle of CPU execution and I/O wait. • Process execution begins with a CPU burst, followed by an I/O burst, then another CPU burst ... etc • The duration of these CPU bursts h.
cpu scheduling cpu调度
weixin_74400487的博客
06-25 1609
SJF（最短作业优先）调度算法可以被视为一种特殊的优先级调度算法，优先级的分配是基于预测的CPU突发时间（即进程下一次需要CPU的时间长度）预测的CPU突发时间越短，进程的优先级就越高，这样它就越有可能被调度器选中执行。如果就绪队列中有 n 个进程，而时间量子为 q，那么每个进程都会一次性获得 1/n 的 CPU 时间，每块最多 q 个时间单位。过了这段时间后，进程就会被抢占并加入就绪队列的末尾。SJF算法从就绪队列中选择当前优先级最高的进程（如果有多个进程具有相同的优先级，则选择当前优先级最高的进程）。
Scheduling_algo：操作系统调度算法，FCFS和SJF
02-04
先来先服务（FCFS）和最短作业优先（SJF）调度 此代码是非抢占式的 这些算法是非抢占式或抢占式的。 非抢占式算法的设计使进程一旦进入运行状态，就无法抢占它，直到它完成其分配的时间为止，而抢占式调度基于优先级...
schedulelab：在OS中模拟FCFS，RR，SJF，HPRN调度算法
02-03
2. RR (Round Robin) 3. SJF (Shortest Job First) 4. HPRN (Highest Penalty Ratio Next) 建立 要运行此程序，您需要python3 。 它不使用外部库。 下载/克隆此存储库或将CD克隆到存储库中。 来自Gottlieb教授网站的...
Process-scheduling-algorithms.zip_algorithms
09-20
"Process-scheduling-algorithms.zip_algorithms"这个压缩包包含了关于进程调度算法的资料，尤其对理解这些算法的工作原理和应用场景非常有帮助。 1. **先来先服务(FCFS, First-Come, First-Served)**: 这是最简单...
process-scheduling-algorithms：C ++中的调度算法程序
02-04
在"process-scheduling-algorithms"项目中，C++代码可能包含了上述各种调度算法的实现，通过分析源码，我们可以更深入地了解这些算法的工作原理和优化技巧。此外，对于学习操作系统原理和C++编程的人来说，这是一个...
OS_deadlock_scheduling_algorithms：调度算法（Round Robin，SJF，Priority，FCFS）和避免死锁算法（Banker's Algorithm）的实现
02-04
在"OS_deadlock_scheduling_algorithms-master"这个项目中，开发者可能提供了这些算法的C语言实现，让学习者和研究者能够更好地理解和模拟各种调度策略及死锁避免方法。通过实际操作，可以深入理解每种算法的工作...
第十二届蓝桥杯 2021 C/C++组 直线
2301_80558092的博客
04-26 805
用pair<int,int>类型来存储两个值，即在枚举的时候表示平面直角坐标系中的点。再用pair<PII,int>类型来存储三个值，PII来表示直线的前两个参数A和B，int表示直线的最后一个参数C。定义一个vector容器vec,用于存储给定平面上的所有整点的坐标,元素类型是PII，定义一个set容器s,用于存储不同的直线,set容器会自动对元素进行去重,这里的元素类型是PIII,即每一条直线用PIII来表示。然后就是从vec中提取出两个点的横纵坐标并计算得到直线参数A，B，C。这里注意：为了避免同一条
Linux软硬链接和动静态库(20)
tan180°的博客
04-25 1092
我有款非常喜欢玩的游戏，叫做《饥荒》，现在我下载了这一款游戏，但我不会跑到游戏所在目录中双击 .exe 打开游戏，大多数人都会通过桌面的快捷方式直接打开文件，而这个快捷方式实际就是对 .exe 的 软链接 文件；当你在游戏中加载地图、道具等资源时，这些数据是存在 .exe 文件中的吗？答案是当然不是，这些资源文件都以 库 的方式与 .exe 位于同一目录中，通常为动态库，在 Windows 中后缀为 dll，那么这些神奇的辅助文件是如何产生的？其本质又是如何？本篇将带你一起揭晓。
Linux 服务管理两种方式service和systemctl
最新发布
lza20001103的博客
04-29 400
Linux 服务管理两种方式service和systemctl
io_uring概述：现代 Linux 异步 IO 的新范式
2401_84703565的博客
04-26 749
io_uring 是由 Jens Axboe 主导开发的异步 I/O 框架，它设计的核心是：用户态与内核共享两个环形队列（SQ & CQ）来提交和获取 I/O 请求，从而避免频繁的系统调用，提高性能。其工作机制如下：SQ（Submission Queue）：用户将 I/O 请求写入 SQ（实际上是 struct io_uring_sqe）。CQ（Completion Queue）：内核完成请求后，将结果写入 CQ（struct io_uring_cqe）。
Linux常用指令
ya3288426755的博客
04-23 1811
最近在进行操作系统的实验，涉及到Linux系统的使用，下面总结一些常用指令，涵盖文件管理、系统信息、进程管理、用户与权限、网络工具、文本处理、压缩与归档、系统维护等核心功能。：将前一个命令的输出作为后一个命令的输入。：将命令输出保存到文件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值