进程调度算法

最新推荐文章于 2023-05-09 11:50:01 发布
最新推荐文章于 2023-05-09 11:50:01 发布
阅读量488 收藏 1
点赞数
文章标签： c++ visual studio 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sheasqq/article/details/122278725
版权
本文介绍了实现的六个进程调度算法：FCFS（先来先服务）、SRR（短进程优先）、RR（时间片轮转）、SR（静态优先）、SJF（短进程优先）和QSJF（强占式短进程优先），展示了每个算法的原理与代码实现。
摘要由CSDN通过智能技术生成

​

实现了六个进程调度算法，即取即用。ps:程序只是为了通过验收，可能仍然存在问题，不保证完全正确。

//主控选择算法
//ConsoleApplication7.cpp
#include <iostream>
#include "SRR.h"
#include"fcfs.h"
#include"RR.h"
#include"SR.h"
#include"SJF.h"
#include"QSJF.h"
using namespace std;
int sel;
int main()
{
	while (true) {
		cout << "请选择算法：";
		cin >> sel;
		switch (sel)
		{
		case 1:
			fcfs();
			break;
		case 2:
			SRR();
			break;
		case 3:
			RR();
			break;
		case 4:
			SR();
			break;
		case 5:
			SJF();
			break;
		case 6:
			QSJF();
			break;
		}
	}
    
}

//进程父结构体头文件
//fa_pro.h
#pragma once
#pragma once
#include <string>
#ifndef fa_pro
#define fa_pro
class process
{
public:
	int num;
	std::string name;
	int start;
	int tim;
	int nst;
};
#endif // !HEAD_h

先来先服务

//定义头文件
//fcfs.h
#pragma once
#include <string>
#ifndef HEAD_h
#define HEAD_h
void fcfs();
#endif // !HEAD_h

//fcfs.cpp
#include<iostream>
#include<queue>
#include"fcfs.h"
#include"fa_pro.h"
using namespace std;
static int num;
static int tim = 0;
static int done;
static int stim;
static double sqtim;
static process ndo;
static struct processt
{
	process t;
	bool operator<(const processt& dir)const {
		return t.start > dir.t.start;//我们以val值为键值进行建堆。自己可以定义
	}
};
static struct processt1
{
	process t;
	bool operator<(const processt& dir)const {
		return t.start+t.tim > dir.t.start+t.tim;//我们以val值为键值进行建堆。自己可以定义
	}
};
static priority_queue<processt> pq;
static priority_queue<processt1> tpq;
void fcfs() {
	cin >> num;
	for (int i = 0; i < num; i++) {
		processt tmp;
		cin >> tmp.t.name >>tmp.t.start>> tmp.t.tim;
		pq.push(tmp);
	}
	done = true;
	do {
		if (!done && ndo.nst + ndo.tim == tim) {
			done = true;
			cout << "时间" << tim << "完成进程" << ndo.name << endl;
			cout << "开始时间" << ndo.nst << "周转时间" << tim - ndo.start << "带权周转时间" << (double)(tim - ndo.start) / (double)(ndo.tim) << endl;
			stim += tim - ndo.start;
			sqtim += (double)(tim - ndo.start) / (double)(ndo.tim);
		}
		if (done&&!pq.empty()&&pq.top().t.start <= tim) {
			done = false;
			ndo = pq.top().t;
			ndo.nst = tim;
			pq.pop();
		}
		tim++;
	} while (!done||!pq.empty());
	cout << "平均周转时间" << stim / (double)num << "平均带权周转时间" << sqtim / (double)num;
	cout << endl;
}

线性优先法

//SRR.h
#pragma once
#include <string>
#ifndef SRR_h
#define SRR_h
void SRR();
#endif // !HEAD_h

//SRR.cpp
#include<iostream>
#include<queue>
#include"SRR.h"
#include"fa_pro.h"
using namespace std;
static int num;
static int tim;
static int a, b;
static int unittim;
static int stim;
static double sqtim;
static class processs {
public:
	process t;
	int nowtim;
	int Round() {
		int k;
		if (nowtim == -1) {
			k=a * (tim - this->t.start);
		}
		else {
			k=a * (this->t.nst - this->t.start) + b * (tim - this->t.nst);
		}
		return k;
	}
};
static class processt
{
public:
	processs t;
	bool operator<(const processt& dir)const {
		return t.t.start > dir.t.t.start;//我们以val值为键值进行建堆。自己可以定义
		
	}
};
static priority_queue<processt> pq;
static queue<processs> waitq;
static queue<processs> q;
void SRR() {
	stim = 0; sqtim = 0;
	tim = 0;
	cout << "进程数";
	cin >> num;
	cout << "增长速率";
	cin >> a >> b;
	cout << "时间片长度";
	cin >> unittim;
	processt tmp[100];
	for (int i = 0; i < num; i++) {
		tmp[i].t.nowtim = -1;
		cin >> tmp[i].t.t.name >> tmp[i].t.t.start >> tmp[i].t.t.tim;
		tmp[i].t.t.num = i;
		pq.push(tmp[i]);
	}
	while (!pq.empty() || !q.empty()||!waitq.empty()) {
		cout << "时间" << tim<<endl;
		while (!pq.empty()&&pq.top().t.t.start == tim) {
			waitq.push(pq.top().t);
			pq.pop();
			cout << "进程" << waitq.back().t.name << "进入等待队列" << endl;
		}
		while (!waitq.empty()&&(q.empty() || q.back().Round() <= waitq.front().Round())) {
			waitq.front().t.nst = tim;
			waitq.front().nowtim = 0;
			q.push(waitq.front());
			waitq.pop();
			cout << "进程" << q.back().t.name << "进入享受队列" << endl;
			cout << "进程" << q.back().t.name << "开始执行" << endl;
		}
		if (!q.empty()&&q.front().nowtim == q.front().t.tim) {
			processs tp = q.front();
			cout << "进程" << tp.t.name << "执行完毕" << endl;
			cout << "开始时间" << tp.t.nst << "周转时间" << tim - tp.t.start << "带权周转时间" << (double)(tim - tp.t.start) / (double)(tp.t.tim) << endl;
			stim += tim - tp.t.start;
			sqtim += (double)(tim - tp.t.start) / (double)(tp.t.tim);
			q.pop();
			if(!q.empty())cout << "进程" << q.front().t.name << "开始执行"<<endl;
		}
		if (!q.empty() && q.front().nowtim!=0&& q.front().nowtim % unittim == 0) {
			processs tp = q.front();
			cout << "进程" << tp.t.name << "轮转"<<endl;
			q.pop();
			q.push(tp);
			cout << "进程" << q.front().t.name << "开始执行" << endl;
		}
		if (!q.empty()) {
			q.front().nowtim++;
		}
		tim++;
	}
	cout << "平均周转时间" << stim / (double)num << "平均带权周转时间" << sqtim / (double)num;
	cout << endl;
}

非抢占式短进程优先

//头文件
//SJF.h
#pragma once
#include <string>
#ifndef SJF_h
#define SJF_h
void SJF();
#endif // !HEAD_h

//SJF.cpp
#include<iostream>
#include<queue>
#include<vector>
#include"fa_pro.h"

using namespace std;
static int num;
static int tim;
static int a, b;
static int unittim;
static int stim, sqtim;
static bool done;
static class priprocess {
public:
	process t;
};
struct cmpt {
	bool operator()(priprocess a, priprocess b) {
		if (a.t.start == b.t.start)
			return a.t.name > b.t.name;///时间相等时按照id升序排列
		return a.t.start > b.t.start;///按照时间升序排列，成为最小堆
	}
};
struct cmpp {
	bool operator()(priprocess a, priprocess b) {
		return a.t.tim > b.t.tim;///按照时间升序排列，成为最小堆
	}
};
static priority_queue<priprocess, vector<priprocess>, cmpt> qt;
static priority_queue<priprocess, vector<priprocess>, cmpp> qp;
void SJF() {
	done = true;
	stim = 0; sqtim = 0;
	tim = 0;
	cout << "进程数";
	cin >> num;
	priprocess tmp[100];
	for (int i = 0; i < num; i++) {
		cin >> tmp[i].t.name >> tmp[i].t.start >> tmp[i].t.tim;
		tmp[i].t.num = i;
		qt.push(tmp[i]);
	}
	while (!qt.empty() || !qp.empty() || !done) {
		cout << "时间" << tim << endl;
		while (!qt.empty() && qt.top().t.start == tim) {
			tmp[0] = qt.top();
			qp.push(tmp[0]);
			qt.pop();
			cout << "进程" << tmp[0].t.name << "进入等待队列" << endl;
		}
		if (done && !qp.empty()) {
			done = false;
			tmp[99] = qp.top();
			tmp[99].t.nst = tim;
			qp.pop();
			cout << "进程" << tmp[99].t.name << "开始执行" << endl;
		}
		if (!done && tmp[99].t.tim + tmp[99].t.nst == tim) {
			done = true;
			cout << "进程" << tmp[99].t.name << "执行完毕" << endl;
			cout << "开始时间" << tmp[99].t.nst << "周转时间" << tim - tmp[99].t.start << "带权周转时间" << (double)(tim - tmp[99].t.start) / (double)(tmp[99].t.tim) << endl;
			stim += tim - tmp[99].t.start;
			sqtim += (double)(tim - tmp[99].t.start) / (double)(tmp[99].t.tim);
		}
		tim++;
	}
	cout << "平均周转时间" << stim / (double)num << "平均带权周转时间" << sqtim / (double)num;
	cout << endl;
}

强占式短进程优先
//QSJF.h
#pragma once
#include <string>
#ifndef QSJF_h
#define QSJF_h
void QSJF();
#endif // !HEAD_h

//QSJF.cpp
#include<iostream>
#include<queue>
#include<vector>
#include"fa_pro.h"

using namespace std;
static int num;
static int tim;
static int a, b;
static int unittim;
static int stim;
static double sqtim;
static string name;
static bool done;
static class priprocess {
public:
	process t;
	int nowtime;
	int stt;
};
struct cmpt {
	bool operator()(priprocess a, priprocess b) {
		if (a.t.start == b.t.start)
			return a.t.name > b.t.name;///时间相等时按照id升序排列
		return a.t.start > b.t.start;///按照时间升序排列，成为最小堆
	}
};
struct cmpp {
	bool operator()(priprocess a, priprocess b) {
		return a.stt > b.stt;///按照时间升序排列，成为最小堆
	}
};
static priority_queue<priprocess, vector<priprocess>, cmpt> qt;
static priority_queue<priprocess, vector<priprocess>, cmpp> qp;
void QSJF() {
	done = true;
	stim = 0; sqtim = 0;
	tim = 0;
	cout << "进程数";
	cin >> num;
	priprocess tmp[100];
	for (int i = 0; i < num; i++) {
		cin >> tmp[i].t.name >> tmp[i].t.start >> tmp[i].t.tim;
		tmp[i].nowtime = 0;
		tmp[i].t.num = i;
		tmp[i].t.nst = -1;
		tmp[i].stt = tmp[i].t.tim;
		qt.push(tmp[i]);
	}
	while (!qt.empty() || !qp.empty() ||!done) {
		cout << "时间" << tim << endl;
		if (!qp.empty()) {
			name = qp.top().t.name;
		}
		while (!qt.empty() && qt.top().t.start == tim) {
			tmp[0] = qt.top();
			qt.pop();
			cout << "进程" << tmp[0].t.name << "进入等待队列" << endl;
			if (!done && tmp[99].t.tim-tmp[99].nowtime > tmp[0].t.tim) {
				cout << "进程" << tmp[99].t.name << "被抢占" << endl;
				qp.push(tmp[99]);
				tmp[99] = tmp[0];
				if (tmp[99].t.nst == -1)tmp[99].t.nst = tim;
				cout << "进程" << tmp[99].t.name << "开始执行" << endl;
			}
			else {
				qp.push(tmp[0]);
			}
		}
		if (done && !qp.empty()) {
			done = false;
			tmp[99] = qp.top();
			tmp[99].t.nst = tim;
			qp.pop();
			cout << "进程" << tmp[99].t.name << "开始执行" << endl;
		}
		if (!done && tmp[99].nowtime == tmp[99].t.tim) {
			done = true;
			cout << "进程" << tmp[99].t.name << "执行完毕" << endl;
			cout << "开始时间" << tmp[99].t.nst << "周转时间" << tim - tmp[99].t.start << "带权周转时间" << (double)(tim - tmp[99].t.start) / (double)(tmp[99].t.tim) << endl;
			stim += tim - tmp[99].t.start;
			sqtim += (double)(tim - tmp[99].t.start) / (double)(tmp[99].t.tim);
			if (!qp.empty()) {
				done = false;
				tmp[99] = qp.top();
				qp.pop();
				tmp[99].t.nst = tim;
				cout << "进程" << tmp[99].t.name << "开始执行" << endl;
			}
		}
		if (!done) {
			tmp[99].nowtime++;
			tmp[99].stt--;
		}
		tim++;
	}
	cout << "平均周转时间" << stim / (double)num << "平均带权周转时间" << sqtim / (double)num;
	cout << endl;
}

时间片轮转法

//RR.h
#pragma once
#pragma once
#include <string>
#ifndef RR_h
#define RR_h
void RR();
#endif // !HEAD_h

//RR.cpp
#include<iostream>
#include<queue>
#include"RR.h"
#include"fa_pro.h"
using namespace std;
static int num;
static int tim;
static int a, b;
static int unittim;
static int stim;
static double sqtim;
static class processs {
public:
	process t;
	int nowtim;
};
static class processt
{
public:
	processs t;
	bool operator<(const processt& dir)const {
		return t.t.start > dir.t.t.start;//我们以val值为键值进行建堆。自己可以定义

	}
};
static priority_queue<processt> pq;
static queue<processs> q;
void RR() {
	stim = 0; sqtim = 0;
	tim = 0;
	cout << "进程数";
	cin >> num; 
	cout << "时间片长度";
	cin >> unittim;
	processt tmp[100];
	for (int i = 0; i < num; i++) {
		tmp[i].t.nowtim = -1;
		cin >> tmp[i].t.t.name >> tmp[i].t.t.start >> tmp[i].t.t.tim;
		tmp[i].t.t.num = i;
		pq.push(tmp[i]);
	}
	while (!pq.empty() || !q.empty()) {
		cout << "时间" << tim << endl;
		while (!pq.empty() && pq.top().t.t.start == tim) {
			q.push(pq.top().t);
			q.back().nowtim = 0;
			pq.pop();
			cout << "进程" << q.back().t.name << "进入队列" << endl;
		}
		if (!q.empty() && q.front().nowtim != 0 && q.front().nowtim % unittim == 0) {
			processs tp = q.front();
			cout << "进程" << tp.t.name << "轮转" << endl;
			q.pop();
			q.push(tp);
			cout << "进程" << q.front().t.name << "开始执行" << endl;
		}
		if (!q.empty() && q.front().nowtim == q.front().t.tim) {
			processs tp = q.front();
			cout << "进程" << tp.t.name << "执行完毕" << endl;
			cout << "开始时间" << tp.t.nst << "周转时间" << tim - tp.t.start << "带权周转时间" << (double)(tim - tp.t.start) / (double)(tp.t.tim) << endl;
			stim += tim - tp.t.start;
			sqtim += (double)(tim - tp.t.start) / (double)(tp.t.tim);
			q.pop();
			if (!q.empty()) {
				cout << "进程" << q.front().t.name << "开始执行" << endl;
			}
		}
		if (!q.empty()) {
			if (q.front().nowtim == 0) {
				q.front().t.nst = tim;
			}
			q.front().nowtim++;

		}
		tim++;
	}
	cout << "平均周转时间" << stim / (double)num << "平均带权周转时间" << sqtim / (double)num;
	cout << endl;
}

静态优先法

//SR.h
#pragma once
#pragma once
#include <string>
#ifndef SR_h
#define SR_h
void SR();
#endif // !HEAD_h

//SR.cpp
#include<iostream>
#include<queue>
#include<vector>
#include"fa_pro.h"

using namespace std;
static int num;
static int tim;
static int a, b;
static int unittim;
static int stim, sqtim;
static bool done;
static class priprocess {
public:
	process t;
	int pri;
};
struct cmpt {
    bool operator()(priprocess a, priprocess b) {
        if (a.t.start == b.t.start)
            return a.t.name > b.t.name;///时间相等时按照id升序排列
        return a.t.start > b.t.start;///按照时间升序排列，成为最小堆
    }
};
struct cmpp {
    bool operator()(priprocess a, priprocess b) {
        return a.pri > b.pri;///按照时间升序排列，成为最小堆
    }
};
static priority_queue<priprocess, vector<priprocess>, cmpt> qt;
static priority_queue<priprocess, vector<priprocess>, cmpp> qp;
void SR() {
	done = true;
	stim = 0; sqtim = 0;
	tim = 0;
	cout << "进程数";
	cin >> num;
	priprocess tmp[100];
	for (int i = 0; i < num; i++) {
		cin >> tmp[i].t.name >> tmp[i].t.start >> tmp[i].t.tim >> tmp[i].pri;
		tmp[i].t.num = i;
		qt.push(tmp[i]);
	}
	while (!qt.empty() || !qp.empty()||!done) {
		cout << "时间" << tim << endl;
		while (!qt.empty() && qt.top().t.start == tim) {
			tmp[0]=qt.top();
			qp.push(tmp[0]);
			qt.pop();
			cout << "进程" << tmp[0].t.name << "进入等待队列" << endl;
		}
		if (done&&!qp.empty()) {
			done = false;
			tmp[99] = qp.top();
			tmp[99].t.nst = tim;
			qp.pop();
			cout << "进程" << tmp[99].t.name << "开始执行" << endl;
		}
		if (!done && tmp[99].t.tim + tmp[99].t.nst == tim) {
			done = true;
			cout << "进程" << tmp[99].t.name << "执行完毕" << endl;
			cout << "开始时间" << tmp[99].t.nst << "周转时间" << tim - tmp[99].t.start << "带权周转时间" << (double)(tim - tmp[99].t.start) / (double)(tmp[99].t.tim) << endl;
			stim += tim - tmp[99].t.start;
			sqtim += (double)(tim - tmp[99].t.start) / (double)(tmp[99].t.tim);
		}
		tim++;
	}
	cout << "平均周转时间" << stim / (double)num << "平均带权周转时间" << sqtim / (double)num;
	cout << endl;
}
​```
sheasqq
关注
Linux进程调度算法分析
05-04
Linux 进程调度算法分析 基于 X86 平台 Linux2.6.26 内核进程调度部分代码，刨析 Linux 进程调度算法，对算法的原理，实现和复杂度进行了分析并提出了算法改进措施。 Linux 进程调度概述： Linux 系统支持用户态...
C/C++实现操作系统进程调度算法，FCFS, RR, SPN, SRT, HRRN
最新发布
crazybobo1207的博客
10-02 898
进程信息定义在方法InitProcedureInfo中，包括：procedureID（进程ID）, arriveTime（进程到达时间）, serviceTime（服务时间）, eclapsedTime（已服务时间）, remainTime（剩余服务时间）, accumulateTime（累计服务时间）。本程序的优点在于，一旦实现了其中一个调度算法，比如实现了最基本的FCFS之后，只要增加一个排序逻辑，即在重载
模拟文件系统的设计与实现
刘映辰的博客
06-10 6897
模拟文件系统的实现的基本功能，了解文件系统的基本结构和文件系统的管理方法,加深了解文件系统的内部功能的实现。通过高级语言编写和实现一个简单的文件系统，模拟文件管理的工作过程，从而对各种文件操作系统命令的实质内容和执行过程有比较深入的了解。通过编程实现这些算法,更好地掌握操作系统的原理及实现方法,提高综合运用各专业课知识的能力。 本文是在学习完操作系统课程后所完成的课程设计，文中就模拟文件管理系统进行了简单的研究。文件系统的目录结构采用类似 Linux 的树状结构。 在此文件管理系统中,可实现的操作有: 改变
模拟进程调度
Max316121的博客
12-05 192
大学实验作业，仅供参考
SRR, WRR,DWRR, WDRR, SDWRR调度算法的区别
热门推荐
RaymondAmos的技术专栏
09-24 3万+
在QoS队列调度中有如下算法，分别如下：  1、SP     SP:Strict Priority(严格优先级)， SP调度严格按照优先级从高到低的次序优先发送较高优先级队列中的分组，当较高优先级队列为空时，再发送较低优先级队列中的分组。队列7优先级最高，队列0优先级最低.     报文P1~P11~P…按照分类后进入不同的优先级队列，分类指根据报文本地优先级映射到端口队列。报文如果按照
FCFS、SJF、HRRN调度算法
xzy的博客
06-19 1万+
文章目录FCFS、SJF、HRRN调度算法知识总览图先来先服务(FCFS,First Come First Serve)短作业优先(SJF,Shortest Job First)对FCFS和SJF两种算法的思考高响应比优先算法(HRRN,Highest Response Ratio Next) FCFS、SJF、HRRN调度算法 知识总览图 什么叫做饥饿？就是进程一直不被CPU处理。FCFS算法不会导致饥饿是因为，它的所有的进程按到来的时间先后顺序依次执行，所以每个进程都会被执行到。SJF/SPF算法会导
进程调度算法的设计
04-13
### 进程调度算法的设计 #### 一、设计目的 本次课程设计的主要目的是深化学生对操作系统资源管理模块的理解，特别是进程调度部分。通过动手实践，学生可以更好地掌握操作系统的基本原理和功能，具备一定的分析、...
操作系统课程设计大作业C++进程调度算法的模拟实现源码.zip
06-17
操作系统课程设计大作业C++进程调度算法的模拟实现源码，实现了 动态优先级、先来先服务、时间片轮转 三个算法 安装教程 下载到本地，然后直接用VS打开运行即可 操作系统课程设计大作业C++进程调度算法的模拟实现...
进程调度算法的模拟实现
06-17
进程调度算法的模拟实现 进程调度是操作系统中的一种机制，旨在将系统资源分配给不同的进程以提高系统的效率和性能。进程调度算法是操作系统中的一种核心算法，它决定了进程的执行顺序和时间。在本文中，我们将对五...
进程调度算法模拟程序设计C++.docx
05-29
进程调度算法模拟程序设计 C++ 在操作系统中，进程调度算法是核心组件之一，负责分配系统资源和管理进程的执行顺序。下面我们将对进程调度算法的模拟程序设计进行详细的分析和解释。 进程调度算法 进程调度算法...
c++实现进程调度的模拟
04-22
利用c++模拟进程的调度。模拟操作系统内核对进程的控制和管理：包括进程的创建和撤销、进程状态的切换和简单的内存空间管理。  能够模拟进程的创建与撤销过程；（4 分）  对进程的状态进行全面的控制；（4 分）  按先进先出方式管理就绪和阻塞队列，按队列输出进程状态 （2 分）  完成可变分区的分配与回收 （3 分）  界面清晰友好 （2 分）  实验结束后撰写实验报告（5 分）。
《操作系统》进程调度算法模拟
05-28
《操作系统》进程调度算法模拟 在操作系统中，进程调度算法是指操作系统将 CPU 资源分配给多个进程的算法。动态优先权调度算法是指根据进程的优先权来确定其执行顺序的算法。下面是对《操作系统》进程调度算法模拟...
实验一进程及其管理进程调度算法模拟,用动态优先数及时间片轮转法实现进程调度.pdf
09-30
进程管理和进程调度算法模拟 进程管理 在操作系统中，进程管理是指操作系统对进程的创建、执行、同步、通信和调度的管理。进程是操作系统中最基本的执行单元，它是资源分配和独立运行的基本单位。进程管理主要包括...
操作系统进程调度算法
01-13
本文将深入探讨四种常见的进程调度算法：先来先服务（FCFS）、短进程优先（SPF）、高响应比优先（HRN）以及时间片轮转（RR），并结合提供的文件名，我们可以推测这可能是一个关于这些算法实现的编程项目。...
Java模拟操作系统实验之四种进程调度算法实现（FCFS,SJF,RR,HRN）
01-01
本文将深入探讨Java环境下实现的四种进程调度算法：先来先服务(FCFS)、短作业优先(SJF)、时间片轮转(RR)以及高响应比优先(HRN)。这些算法在多任务环境中用于决定哪个进程应该获得CPU的执行权，以达到资源分配的公平...
短作业优先调度算法（SJF）、时间片轮转（RR）
weixin_42421252的博客
05-09 6917
调度算法。
调度算法——先来先服务(FCFS)、短作业优先(SJF)、高响应比优先(HRRN) 例题详细！！！
CHEN的博客笔记
08-23 8509
文章目录前言知识总览先来先服务（FCFS, First Come First Serve)短作业优先（SJF, Shortest Job First)对FCFS和SJF两种算法的思考高响应比优先算法（HRRN）知识回顾与重要考点 前言 此篇文章是我在B站学习时所做的笔记，大部分图片都是课件老师的PPT，方便复习用。此篇文章仅供学习参考。 提示：以下是本篇文章正文内容 知识总览 先来先服务（FCFS, First Come First Serve) 由带权周转时间可以看出，P3的时间最长，由此可看出
调度算法—SJF调度算法详解
清梦的博客
06-12 2万+
详述我自身理解的SJF算法实现的思路，先按到达时间排序，再比较服务时间，附完整代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值