精华内容
下载资源
问答
  • 操作系统调度算法

    2015-10-08 12:41:18
    操作系统作业的调度算法 供伙伴们们交流学习
  • 操作系统:操作系统调度算法
  • 操作系统调度算法,银行家算法,各大高校操作系统实验都可使用
  • 嵌入式Linux操作系统调度算法改进.pdf
  • 操作系统调度算法.zip

    2021-03-04 20:01:32
    操作系统作业调度算法C代码实现,进程入队与出队模拟,FCFS调度算法,时间片轮转调度算法
  • 操作系统调度算法C#实现.pdf
  • 操作系统关于系统调度算法的实验报告:包括先来先服务调度算法、短作业优先调度算法和响应比高者优先调度算法在单道以及多道环境下的优劣势比较。
  • 该资源包含了操作系统的几种调度算法,对于学生理解调度算法具有一定程度的作用。当然,也能更加清晰地了解调度算法地原理
  • 操作系统调度算法java源代码,包括FCFS,SJF,静态优先权调度算法.
  • 模拟实现操作系统调度算法

    千次阅读 2016-04-06 22:01:14
    结合自己所学知识(数据结构)以及对操作系统调度算法的理解,模拟实现了一下操作系统的调度算法,主要包括先来先服务和短作业优先调度。

      之前学习操作系统的时候对操作系统的一些调度算法比较感兴趣,所以自己模拟实现了一下操作系统算法的调度,我主要模拟实现了短作业优先和先来先服务调度算法。代码有点长,加上测试代码估计有300行左右吧,放在这里的话看起来也不方便(算了,还是放在下面吧,免得看的人觉得麻烦)。我先把实现的结果截图放在下面吧,然后再附上代码,其实在我的github上面也有这些代码的,地址: https://github.com/admin-zou/DS/tree/master/scheduling





    头文件: //scheduling.h

    #ifndef _SCHEDULING_
    #define _SCHEDULING_
    
    #include <iostream>
    #include <stdlib.h>
    using namespace std;
    
    enum Tag{UNSHD,SHD}; //标记是否被调度过
    
    struct PCB
    {
    	int      pcbid;			//进程号
    	size_t  arrtime;			//到达时间
    	size_t  sertime;			//服务时间
    	size_t  begtime;			//开始时间
    	size_t  endtime;			//完成时间
    	size_t  turntime;		//周转时间
    	float    weighttime;		//带权周转时间
    	PCB *   next;			//指向下个节点的指针
    	Tag     tag;				//标记是否被调度过
    	
    	PCB(int n=0,size_t a=0,size_t s=0)
    		:pcbid(n),arrtime(a),sertime(s),begtime(0),endtime(0)
    		,turntime(0),weighttime(0),next(NULL),tag(UNSHD)
    	{}
    };
    
    class scheduling
    {
    public:
    	scheduling():_curtime(0),_tasknum(0)
    	{
    		_head = new PCB();
    	}
    
    /先来先服务算法
    	void FIFS()
    	{
    		if(empty())
    		{
    			cout<<"没有任务";
    			exit(-1);
    		}
    		_clear();  //清理一下,可重复计算
    		_sort_t(); //按到达时间排序
    		PCB* cur = _head->next;
    		while(NULL != cur)
    		{
    			if(_curtime < cur->arrtime)
    			{ 
    				_curtime = cur->arrtime; 
    			}
    			cur->begtime = _curtime; 
    			cur->endtime = _curtime + cur->sertime;		//完成时间等于开始时间加服务时间
    			cur->turntime = cur->endtime - cur->arrtime;	 //周转时间=完成时间-到达时间
    			cur->weighttime  = (float)cur->turntime / (float)cur->sertime;  //带权周转时间=周转时间/服务时间
    			cur->tag = SHD; //标记为已经服务
    			_curtime += cur->sertime;
    			cur = cur->next;
    		}
    	}
    
    /短作业
    
    	void Short()
    	{
    		if (empty())
    		{
    			cout << "没有任务";
    			exit(-1);
    		}
    		_clear();  //清理一下,可重复计算
    		_sort_t(); //按到达时间排序
    		
    		PCB* cur = _head->next;
    		while (NULL != cur)
    		{
    			if (_curtime < cur->arrtime)
    			{
    				_curtime = cur->arrtime;
    			}
    			cur->begtime = _curtime;
    			cur->endtime = _curtime + cur->sertime;		//完成时间等于开始时间加服务时间
    			cur->turntime = cur->endtime - cur->arrtime;	 //周转时间=完成时间-到达时间
    			cur->weighttime = (float)cur->turntime / (float)cur->sertime; //带权周转时间=周转时间/服务时间
    			cur->tag = SHD; //标记为已经服务
    			_curtime += cur->sertime;
    			cur = cur->next;
    		
    			//将该进程调度完的时刻已经到达的进程按短作业优先排序	
    			_sort_l(cur,_curtime);  //从该进程开始进行短作业排序
    
    		}
    	}
    
    	void Init_task()
    	{
    		int tasknum=0;
    		size_t id=0;
    		size_t atime=0;
    		size_t stime=0;
    		cout<<"请输入任务的个数:";
    		cin>>tasknum;	
    		for(int i = 0; i<tasknum;i++)
    		{
    			cout<<"请分别输入任务的编号,到达时间,运行时间:";
    			cin>>id>>atime>>stime;
    			push(id,atime,stime);
    		}
    	}
    
    	void Push()
    	{	
    		size_t id=0;
    		size_t atime=0;
    		size_t stime=0;
    		cout<<"请分别输入任务的编号,到达时间,运行时间:";
    		cin>>id>>atime>>stime;
    		push(id,atime,stime);
    	}
    	
    	void Print()
    	{
    		if(empty())
    			return ;
    		PCB* cur = _head->next;
    		printf("进程号 到达时间 服务时间 开始时间 完成时间 周转时间 带权周转时间 \n");
    		while(NULL != cur)
    		{
    			printf("%4d %6d %8d %9d %7d  %8d\t %0.2f\n",cur->pcbid, cur->arrtime ,cur->sertime ,cur->begtime, cur->endtime ,cur->turntime ,cur->weighttime);
    			cur = cur->next;
    		}
    	}
    
    	
    protected:
    	bool empty()
    	{
    		return _tasknum == 0;
    	}
    	
    	bool push(int n,size_t a,size_t s) //插入到链表尾部
    	{
    		PCB * newtask = new PCB(n,a,s);
    		PCB * cur = _head;
    		while(NULL != cur->next)
    			cur =cur->next;
    		cur->next=newtask;
    		_tasknum++;
    		return true;
    	}
    	
    	void _clear()
    	{
    		if(empty())
    			return ;
    		PCB* cur = _head->next;
    		while(NULL != cur)
    		{
    			cur->begtime = 0;
    			cur->endtime = 0;
    			cur->turntime = 0;
    			cur->weighttime = 0;
    			cur->tag = UNSHD;
    			cur = cur->next ;
    		}
    		_curtime = 0;
    	}
    
    // 按照到达时间排序
    	void _sort_t() 
    	{
    		if(empty() || _tasknum == 1)
    			return;
    		PCB* prev = _head->next;
    		PCB* cur = prev->next;
    		for(int i = 0; i< _tasknum-1; i++)
    		{
    			for(int j = 0; j<_tasknum-i-1; j++)
    			{
    				if (prev->arrtime > cur->arrtime)
    				{
    					_Swap(prev, cur);
    				}
    				prev = cur;
    				cur = cur->next;
    			}
    			prev=_head->next;
    			cur = prev->next;
    		}
    	}
    
    // 按照作业长短排序
    	void _sort_l(PCB*& head,size_t curtime)
    	{
    		if (NULL == head || NULL == head->next)
    			return;
    		PCB* prev = head;
    		PCB* cur = prev->next;
    		int size = 0;  //计算进程的数目
    		PCB* tmp = head;
    		while (tmp)
    		{
    			++size;
    			tmp = tmp->next;
    		}
    
    		for (int i = 0; cur->arrtime < curtime && i < size - 1; i++)
    		{
    			if (prev->arrtime > curtime)
    			{//作业还没到达就不排序
    				return;
    			}
    			for (int j = 0; j < size - i - 1; j++)
    			{
    				if (cur && cur->arrtime <= curtime)
    				{
    					int ptime = prev->sertime;
    					int ctime = cur->sertime;
    					if (ptime > ctime)
    					{
    						_Swap(prev, cur);
    					}
    				}
    				prev = cur;
    				cur = cur->next;
    			}
    			prev = head;
    			cur = prev->next;
    		}
    	}
    
    	void _Swap(PCB * prev,PCB * cur)
    	{
    		swap(prev->arrtime,cur->arrtime);
    		swap(prev->pcbid ,cur->pcbid );
    		swap(prev->sertime ,cur->sertime );
    	}
    
    private:
    	PCB *	_head;
    	size_t  _curtime;	
    	size_t  _tasknum;	//作业个数
    };
    
    #endif

    测试文件:

    #define	_CRT_NOWANRINGS
    #include"scheduling.h"
    
    int main()
    {
    	int select=1;
    	scheduling mytask;
    	while(select)
    	{
    		cout<<"****************************"<<endl;
    		cout<<"*   1.初始化               *"<<endl;
    		cout<<"*   2.新插入一个进程       *"<<endl;
    		cout<<"*   3.先来先服务调度算法   *"<<endl;
    		cout<<"*   4.短作业调度算法       *"<<endl;
    		cout<<"*   5.显示调度情况         *"<<endl;
    		cout<<"*   0.退出                 *"<<endl;
    		cout<<"****************************"<<endl;
    		int item=0;
    		cout<<"请输入:";
    		cin>>select;
    		switch(select)
    		{
    		case 1:
    			mytask.Init_task();		
    			break;
    		case 2:
    			mytask.Push();
    			break;
    		case 3:
    			mytask.FIFS();
    			break;
            case 4:
    			mytask.Short();
    			break;
    		case 5:
    			mytask.Print();
    			cout << endl;
    			break;
    		default:
    			break;
    		}
    	}
    	return 0;
    }
    
    //测试条件
    /*
    5
    1 0 4
    2 2 4
    3 3 3
    4 5 6
    5 6 3
    */

       总结:

           1.上面的程序基于是我对操作系统调度算法的理解所写出来的,主要模拟了先来先服务和短作业优先调度两种调度算法,其中涉及到了c++,数据结构以及操作系统和算法等方面的只是,实现它确实大有所益。

           2.在上面的小项目中我是通过计算出各种调度算法的周转时间,带权周转时间等等来评价调度算法的效率的,能够在一定范围内评估调度算法的性能,以及某些场景适合于使用哪种调度算法。

          3.我是通过单链表来组织相关的作业的调度需要的数据的,这样确实有好处,也有缺陷,这和链表的优缺点相对应。不过在数据量较小的时候还是很不错的。

        其中主要的难点在于很难分析出所有可能出现的情况,以及各种情况下的行为。还有就是,需要对操作系统的调度算法有一定的理解,否则就容易出现于实际不符的结果,比如说短作业优先调度,怎样理解这种调度方式呢,我举个例子吧:一开始时只有一个作业在调度,但是其所需时间比较长,在他执行过程中来了其他作业,但是作业时间很短,先调度这个短作业可能会更优,那么我们需要怎么处理呢,这就涉及到了是否允许抢占资源的问题(当然在我的实现中是不可抢占资源的)。最后说明一下在开发的时候一定要多调试,减少bug,增加程序的健壮性。



    展开全文
  • 操作系统调度算法——先来先工作调度算法和短作业调度算法
  • 算法 操作系统 实验课程 大学操作系统进程调度算法
  • 操作系统调度算法实现的又一算法 作业先来先服务、高优先权、按时间片轮转调度算法
  • 计算机曹醉哦系统调度器与处理器,计算机学习入门教程
  • 基于ARM9的嵌入式控制操作系统调度算法分析与改进的研究.pdf
  • 操作系统调度算法.ppt

    2019-12-27 00:02:37
    调度算法 1.先来先服务调度算法 先来先服务的作业调度算法优先从后备队列中选择一个或多个位于队列头部的作业把他们调入内存分配所需资源创建进程然后放入就绪队列 先来先服务的进程调度算法从就绪队列中选择一个...
  • 实时操作系统:优先级调度算法 非抢占式 抢占式优先级调度算法:新进程来的时候判断一下是不是要抢占只有第1级队列所以的运行完了才会把CPU给第2级队列,P2在第二级队列运行到1个时间片后 P3到达第1级队列,此时P2就...


    分时操作系统:


    当时间片为5的时候

    实时操作系统:优先级调度算法
    非抢占式

    抢占式优先级调度算法:新进程来的时候判断一下是不是要抢占


    只有第1级队列所以的运行完了才会把CPU给第2级队列,P2在第二级队列运行到1个时间片后
    P3到达第1级队列,此时P2就立马不运行了,重新进入第2级队列排着,第1级队列去运行

    展开全文
  • 操作系统调度算法 先来先服务(FCFS)和最短作业优先(SJF)调度 此代码是非抢占式的 这些算法是非抢占式或抢占式的。 非抢占式算法的设计使进程一旦进入运行状态,就无法抢占它,直到它完成其分配的时间为止,而...
  • 利用C#模拟操作系统的CPU调度 包括先进先出算法等 另外实现了一个银行家算法
  • 操作系统调度算法简介

    万次阅读 2015-10-30 15:52:05
    这几次课操作系统S老师讲了不少算法,感觉自己好混乱,自己总结一下理理思绪,也算是为期末做准备了。 低级调度算法的基本类型在理解调度算法之前要先理解两个很重要的概念,有助于对算法的理解。

    操作系统调度算法

    这几次课操作系统S老师讲了不少算法,感觉自己好混乱,自己总结一下理理思绪,也算是为期末做准备了。

    广告时间:
    无意中发现了一个巨牛的人工智能教程,忍不住分享一下给大家。教程不仅是零基础,通俗易懂,而且非常风趣幽默,像看小说一样!觉得太牛了,所以分享给大家。点这里可以跳转到教程。



    低级调度算法的基本类型

    在理解调度算法之前要先理解两个很重要的概念,有助于对算法的理解。

    • 剥夺方式: 当一个进程正在处理器上执行时,系统可以根据规定的原则剥夺分配给它的处理器,而把处理器分配给其他进程使用。有两种常见的剥夺原则:高优先级剥夺原则时间片剥夺原则,前者高优先级进程或线程可以剥夺低优先级进程或线程运行,后者当运行进程时间用完后被剥夺处理器。
    • 非剥夺方式: 一旦某个进程或线程开始执行后便不再出让处理器,除非该进程或线程运行结束或发生了某个事件不能继续执行。

    两种策略一般组合使用:内核关键程序是非剥夺式的,用户进程是剥夺式的。


    先来先服务算法(FCFS)

    策略: 按照作业进入系统的先后次序来挑选作业,先进入系统的作业优先被挑选。为非剥夺式调度算法。
    效果: 算法容易实现,效率不高,只顾及作业等候时间,没考虑作业要求服务时间的长短,不利于短作业而优待了长作业。有利于CPU繁忙型作业不利于I/O繁忙型作业。

    Linux采用了先来先服务算法以及时间片轮转算法


    最短作业优先算法(SJF:Shortest Job First)

    策略: 最短作业优先算法以进入系统的作业所要求的CPU时间为标准,总选取估计计算时间最短的作业投入运行。为非剥夺式调度算法。
    性能: 算法易于实现,效率不高,弱点是需要预先知道作业所需CPU时间,而这个时间只能靠估计,估计值很难精确,若估计过低,系统可能提前终止该作业;忽视了作业等待时间,会出现饥饿现象;由于缺少剥夺机制,对分时、实时处理很不理想。

    SJF的平均作业周转时间比FCFS要小,所以它的调度性能比FCFS好。

    实现SJF调度算法需要知道作业所需要的时间,否则调度就没有依据,要精确知道一个作业的运行时间是办不到的。


    最短剩余时间优先算法(SRTF)

    最短剩余时间优先SRTF算法把SJF算法改为剥夺式调度算法

    当一个作业正在执行时,一个新作业进入就绪状态,如果新作业需要的CPU时间比当前正在执行的作业剩余下来还需的CPU时间短,SRTF强行赶走当前正在执行的作业。此算法不仅适用于作业调度,同样也适用于进程调度。


    响应比最高者优先算法(HRRF)

    FCFS、SJF算法的缺点: 先来先服务算法FCFS与最短作业优先SJF算法都是片面的调度算法。FCFS只考虑作业等候时间而忽视了作业的计算时间,SJF算法只考虑用户估计的作业计算时间而忽略了作业等待时间。

    响应比调度思想: 响应比最高者优先(HRRF)算法是介乎这两者之间的折中算法,既考虑作业等待时间,又考虑作业的运行时间,既照顾短作业又不使长作业的等待时间过长,改善了调度性能。

    缺点: 每次计算各道作业的响应比会有一定的时间开销,性能比SJF略差。

    响应比定义: 作业进入系统后的等待时间与处理时间之和称作该作业的响应时间,作业的响应时间除以作业处理时间称作响应比,即:

    • 响应比 = 1+已等待时间/作业处理时间

    作业处理时间由用户给出,是一个常量。

    响应比的计算时机: 每当调度一个作业运行时,都要计算后备作业队列中每个作业的响应比,选择响应比最高者投入运行。

    响应比最高优先(HRRF)算法效果:

    • 短作业容易得到较高的响应比
    • 长作业等待时间足够长后,也将获得足够高的响应比
    • 饥饿现象不会发生

    优先级调度算法

    算法思想: 根据确定的优先级来选取进程/线程,每次总是选择就绪队列中优先级最高者运行。是变相的FCFS。

    剥夺和非剥夺优先级调度: 如果就绪队列中出现优先级更高的进程/线程,则可立即调度该进程运行(剥夺式调度)或者待当前运行进程结束或者出现等待事件主动让出处理器后,调度该高优先级进程投入运行(非剥夺式调度)。

    规定用户进程/线程优先级的方法:

    • 一种是由用户自己提出优先级,称为外部指定法,优先级越高,费用越高。
    • 另一种是由系统综合考虑有关因素来确定用户进程/线程的优先级,称为内部指定法

    优先级通常用0~4095的整数表示,该整数成为优先数。UNIX/Linux规定优先数越小,优先级越高,有些系统规定相反。

    进程/线程优先级的确定方法

    • 静态方法: 静态优先级在进程/线程创建时确定(外部指定或内部指定),此后不再改变。会产生饥饿现象,低优先级进程/线程被无限期推迟执行。
    • 动态方法: 动态优先级随时间而变,其基本原则是:
    • 正在运行的进程/线程随着占有CPU时间的增加优先级逐渐降低。
    • 就绪队列中等待CPU的进程/线程随着等待的时间的增加优先级逐渐提高。

    轮转调度算法

    算法思想: 轮转法调度也称为时间片调度,其做法是:调度程序每次把CPU分配给就绪队列首进程/线程使用一个时间间隔(时间片),就绪队列中的每个进程/线程轮流地运行一个时间片。当这个时间片耗尽时,强迫当前进程/线程让出处理器,让它排列到就绪队列的尾部,等候下一轮调度。

    实现原理: 需要使用一个间隔时钟。当一个进程开始运行时,就将时间片的值置入间隔时钟内,当发生间隔时钟中断时,终端处理程序就通知处理器调度进行处理器的切换工作。为剥夺式调度。

    算法效果: 其可防止那些很少使用外围设备的进程过长的占用处理器而使得要使用外围设备的那些进程没有机会去启动外围设备。


    多级反馈队列调度(反馈循环队列或多队列策略)

    算法思想: 是将就绪进程分为两级或多级,系统相应建立两个或多个就绪进程队列,较高优先级的队列一般分配给较短的时间片。

    处理器调度每次先从高级就绪队列中选取可占有处理器的进程,只有在选不到时,才从较低级的就绪进程队列中选取。

    同一队列中的进程按先来先服务原则排队。

    效果: 性能较好,能满足各类用户的需要。

    • 对分时交互式作业: 通常可在最高优先级队列规定的一个时间片内完成,响应时间快。
    • 对于长批处理型作业: 可以从高到低在各优先级队列中运行一个时间片直到在某个级别队列中执行完毕或者在最后一个队列中经过若干个时间片执行完毕,绝不会发生长批处理型作业长期得不到调度的情况。

    不足:会存在饥饿问题。当新进程不断到来,进入较高优先级队列,CPU忙于运行高优先级队列中的进程,低优先级队列中的进程将长时间得不到调度,产生饥饿现象。


    彩票调度算法

    基本思想: 为进程发放针对各种资源(如CPU时间)的彩票。调度程序随机选择一张彩票,持有该彩票的进程获得系统资源。

    进程都是平等的,有相同的运行机会。如果某些进程需要更多的机会,可被给予更多彩票,增加其终将机会。


    实际操作系统中使用的算法:

    • 先来先服务算法
    • 轮转法
    • 优先级调度算法
    展开全文
  • 操作系统调度算法理解

    千次阅读 2019-10-27 11:47:16
    根据作业到达的先后次序来进行调度,先来的先执行。 进程名 A B C D E 到达时间 0 2 4 6 8 服务时间 3 6 4 5 2 解释:作业到达的顺序为A,B,C,D,E。因此,执行的顺序也是A,B,C,D,E. 二、SJF (Short Job ...

    一、FCFS (First-Come First-Served)——先来先服务算法

    算法思想:

    根据作业到达的先后次序来进行调度,先来的先执行

    特点:
    • 有利于长作业,不利于短作业。
    • 既可以用于作业调度,也可以用于进程调度。
    进程名ABCDE
    到达时间02468
    服务时间36452

    在这里插入图片描述
    解释:作业到达的顺序为A,B,C,D,E。因此,执行的顺序也是A,B,C,D,E.

    二、SJF (Short Job First)——短作业优先算法

    算法思想:
    • 以作业运行时间的长短来计算优先级,作业越短,优先级越高。
    • 注意:在运行短时间算法之前,要判断它是否已经到达。
    特点:
    • 既可以用于作业调度,也可以用于进程调度。
    缺点:
    • 必须预知作业的运行时间。
    • 对长作业非常不利,长作业的周转时间会明显增长。
    • 无法进行人机交互。
    • 不能保证紧迫性作业能及时得到处理。
    进程名ABCDE
    到达时间02468
    服务时间36452

    在这里插入图片描述
    解释:A到达后首先运行,之后,因为在第 3 秒时,只有 B 到达,所以只能运行 B。等到 B 运行完以后,C, D, E 都已经到达,这时就先运行作业时间最短的 E ,然后是 C, 最后是 D。

    三、SRTF ——最短剩余时间优先算法

    算法思想:
    • 当一个作业正在执行时,到达一个新作业,如果新作业所需要的运行时间比正在执行的作业剩余下来所需要的执行时间短,就赶走正在执行的作业,执行新作业。
    • 如果遇到新来作业的执行时间和前面未完成作业的剩余时间相等,则执行先到达的作业。
    进程名ABCDE
    到达时间02468
    服务时间36452

    在这里插入图片描述
    解释:A首先运行,然后B到达,运行一个时间片后,C到达。此时 B 的剩余执行时间为 5,而 C 只需要 4 个时间片,所以先执行 C。在 第 6 个时间片时, D 到达,但 D需要的时间为 5,此时rest(B) = 5,rest( C) = 2,还是C的剩余执行时间最小,故继续执行 C。到第 8 个时间片,C执行完毕退出队列。此时 E 到达,E只需要 2 个时间片,剩余执行时间最小,先执行 E,这样 A, C, E 都执行完毕,剩余的 B 的D 的剩余时间一样,都为 5,但由于B先到达,所以先执行 B, 最后执行 D。

    四、HRRN(Highest Response Ratio Next)——高响应比优先算法

    FCFS算法考虑的只是作业的等待时间,忽视了作业的运行时间。而SJF算法只考虑用户估计的作业计算时间而忽略了作业等待时间。高响应比优先调度算法(HRRN)则即考虑了作业等待时间,有考虑了作业运行时间。

    算法思想:
    • 每次进行调度之前,都要计算未调度作业的响应比,响应比高的作业优先调度。
    • 响应比:(等待时间 + 要求服务时间)/ 要求服务时间
    • 注意:计算响应比等待时间不要错。
    进程名ABCDE
    到达时间02468
    服务时间36452

    在这里插入图片描述
    解释:A首先执行,然后只有B到达,所以执行B。B执行完毕后,C , D , E都已经到达。这时要分别计算C ,D,E 的相应比。C :(5 + 4 ) / 4 = 2.25;D:(3 + 5) / 5 = 1.6;E:(1 + 2 ) / 2 = 1.5。所以响应比:C > D > E,C最大,就先调度C。C运行完毕后,再计算 D, E 的相应比。 D:( 7 + 5) / 5 = 2.4;E:(5 + 2) / 2 = 3.5;所以 E > D,先调度E,最后调度 D。

    五、RR(Round Robin)——轮转调度算法(设时间片为1)

    算法思想:让就绪队列上的每个进程每次仅运行一个。
    • 进程运行完一个时间片,就把它送往队列的队尾。运行完毕的从队列中删除。
    • 若在前面进程送进队尾时有新进程到达,则刚到达的新进程优先排队
    进程名ABCDE
    到达时间02468
    服务时间36452

    在这里插入图片描述
    解释:设置一个队列,首先运行的是A,下面给出了1 ~ 20 和时间片中队列情况:
    0:A——执行A。a = 1
    1:A —— 此时B进程还没有到达。执行A。a = 2
    2:BA——B进程到达,排在A前面,执行B。b = 1
    3:AB——B执行一个时间片后排在队尾,执行A。a = 3 此时A执行完毕,从队列中删除。
    4:BC——C进程到达,排在队尾,先执行B。b = 2
    5:CB——执行C。c = 1。
    6:BDC——此时D进程到达,先排在队尾,遵循到达优先,C则排在D后面。执行B。b = 3
    7:DCB——执行D。d = 1
    8:CBED——此时E到达,先排在队尾,遵循到达优先,D则排在E的后面。执行C。c = 2
    9:BEDC——执行B。b = 4
    10:EDCB——执行E. e = 1
    11:DCBE——执行D。d = 2
    12:CBED——执行C。 c = 3
    13:BEDC——执行B。b = 5
    14:EDCB——执行E。e = 2。E执行完毕,从队列中删除。
    15:DCB——执行D。d = 3
    16:CBD——执行C。c = 4。C执行完毕,从队列中删除。
    17:BD——执行B。b = 6。B执行完毕,从队列删除。
    18:D——执行D。d = 4。
    19:D——执行D。d = 5。
    20:D执行完毕。删除D.

    六、FB——多级反馈队列调度算法 ( 时间片qi = 2i-1)

    算法思想:设置多个就绪队列,每个队列有不同的时间片;每个队列都采用FCFS算法,先来先服务;调度按照队列优先级调度。
    • 每次调度运行都从优先级队列高的开始。
    • 刚到的任务放到第一级队列的队尾。
    • 在该级队列中,运行了对应级数时间片的任务,放到下一级队列的队尾。
    • 运行完的任务从队列中删除。
    优点:
    • 资源利用率高
    • 响应速度快
    • 系统开销小
    缺点:
    • 当不断有新进程到来,时间长的进程可能会饥饿。
    进程名ABCDE
    到达时间02468
    服务时间36452

    在这里插入图片描述
    解释:设置三个就绪队列,具体就不阐述了,按照上面算法执行步骤即可。
    在这里插入图片描述

    七、Preemption FB——抢占FB算法

    算法思想:新来的进程立即运行。只有完整的执行一个时间片,才向下一个队列转移。否则,排在所在队列的队尾。

    与FB相同点

    • 每次调度从优先级队列高的开始。
    • 刚到达的任务放到第一级队列的队尾。
    • 在该级队列中,运行了对应级数时间片的任务,放到下一级队列的队尾。
    • 运行完的任务从队列中删除。

    与FB不同点

    • 有新进程到达时,立即执行新进程。(因为新来的进程在第一级队列中。)
    • 当某一队列中的进程(设为A)正在执行时,若还没运行完该队列的时间片(也就是执行到一半),就有新进程(设为B)到达,则当前进程A停止。新进程B先运行对应队列的时间片(其实也就是第一级队列的),但是A进程不向下一级队列转移(因为它没有运行完当前所属队列的时间片),而是排在队尾(此时类似于RR)。只有当进程A运行完一个完整的时间片后,才向下一队列转移。
    进程名ABCDE
    到达时间02468
    服务时间36452

    在这里插入图片描述

    展开全文
  • 通过设计先来先服务调度算法、短作业优先调度算法和高响应比调度算法,模拟多个进程调度方式,进一步理解先来先服务和短作业优先调度算法的实质,掌握周转时间、带权周转时间以及动态优先级等基本概念,并对三种算法...
  • CPU_Scheduling_Simulation:模拟两种操作系统调度算法:先到先服务(FCFS)和循环调度(RR)
  • 操作系统调度算法分析

    千次阅读 2015-07-27 16:53:31
    当然这个过程免不了去收集实时系统调度算法的相关资料,以及了解各种实时系统算法的实现和调度算法应用的范围。 接下来我会从以下几个方面来讨论计算机系统的调度算法: 首先是计算机为什么需要调度算法?计算机为...
  • 几种操作系统调度算法

    千次阅读 2018-10-23 16:53:38
    先来先服务(FCFS)调度算法是一种最简单的调度算法,该算法既可用于作业调度,也可用于进程调度。当在作业调度中采用该算法时,每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业,将它们...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 170,095
精华内容 68,038
关键字:

操作系统调度算法