时间片轮转_时间片轮转调度 - CSDN
精华内容
参与话题
  • 操作系统 时间片轮转调度算法

    万次阅读 2018-03-29 16:51:29
    时间片轮转法(RR) 算法描述:用于分时系统中的进程调度。每次调度时,总是选择就绪队列的队首进程,让其在CPU上运行一个系统预先设置好的时间片。一个时间片内没有完成运行的进程,返回到绪队列末尾重新排队,...

    转自https://blog.csdn.net/u013630349/article/details/47732731

    时间片轮转法(RR)

    算法描述:用于分时系统中的进程调度。每次调度时,总是选择就绪队列的队首进程,让其在CPU上运行一个系统预先设置好的时间片。一个时间片内没有完成运行的进程,返回到绪队列末尾重新排队,等待下一次调度。

    【例】进程A、B、C、D需要运行的时间分别为20ms、10 ms、15 ms、5 ms,均在0时刻到达。到达的先后次序为A、B、C、D。如果时间片分别为1 ms和5ms,计算各个进程的带权周转时间和平均带权周转时间。

    分析 在掌握了时间片轮转法概念的基础上,我们可以用一个执行时间图来形象地表示作进程的执行情况,帮助我们理解此题。具体如下:
    这里写图片描述
    根据执行时间图就可以计算各个进程的带权周转时间和平均带权周转时间了。这里要注意的是,要记住带权周转时间和平均带权周转时间的算术公式:

    带权周转时间W,即:

    W = T/R

    其中T为周转时间,R为实际运行时间。

    平均带权周转时间为:
    这里写图片描述
    解:采用时间片轮转法进行调度,算法的性能指标如下:
    这里写图片描述

    展开全文
  • 时间片轮转算法

    千次阅读 2018-11-12 21:39:41
    时间片轮转算法:主要用于分时系统中的进程调度。为了实现轮转调度,系统把所有就绪进程按先入先出的原则排成一个队列。新来的进程加到就绪队列末尾。每当执行进程调度时,进程调度程序总是选出就绪队列的队首进程,...

    时间片轮转算法:主要用于分时系统中的进程调度。为了实现轮转调度,系统把所有就绪进程按先入先出的原则排成一个队列。新来的进程加到就绪队列末尾。每当执行进程调度时,进程调度程序总是选出就绪队列的队首进程,让它在CPU上运行一个时间片的时间。时间片是一个小的时间单位,通常为10~100ms数量级。当进程用完分给它的时间片后,系统的计时器发出时钟中断,调度程序便停止该进程的运行,把它放入就绪队列的末尾;然后,把CPU分给就绪队列的队首进程,同样也让它运行一个时间片,如此往复。

    测试案例:任务A和任务B的周期时间分别为2s和5s,每个周期的处理时间为1s和2.5s

    代码:

    #include<cstdio>
    #include<cstdlib>
    #include<ctime>
    #include<iostream>
    #include<queue>
    #include<list>
    #include<thread>
    #include<mutex>
    #include<Windows.h>
    using namespace std;
    #define A_RUN_TIME 10
    #define B_RUN_TIME 25
    #define A_STOP_TIME 20
    #define B_STOP_TIME 50
    #define time_film  10 //时间片
    #define MAX_TIME 99999
    int g_time = 0;
    mutex g_mutex_time;
    
    
    
    struct process_node
    {
    	int prcess_id;  //进程编号
    	int _start;  //进入时间
    	void(*main_doing)(int args, char *ptr_argv[]);//本进程完成的任务
    	int begin;   //开始时间
    	int finish;  //完成时间
    	int _function; //需要运行时间
    	int function; //已经运行的时间
    	bool complete;	 //是否完成   true 完成
    };
    
    list<process_node*>q_list;//进程队列
    
    void main_doing(int args, char *ptr_argv[])
    {
    	cout << args << "这是一个运行的实例" << endl;
    	Sleep(50);
    }
    
    void Come_Init_Prcess(void(*main_doing)(int args, char *ptr_argv[]),  int _function) //模拟进程到来并且初始化
    {
    	static int id = 0;
    	process_node *p = new process_node;
    	p->prcess_id = ++id;
    	p->_start = g_time;
    	p->main_doing = main_doing;
    	p->_function = _function;
    	p->begin = MAX_TIME;
    	p->finish = MAX_TIME;
    	p->function = 0;
    	p->complete = false;
    	q_list.push_back(p);
    }
    void Time_End_Work(process_node & current_process)//时间片结束的前的工作
    {
    
    
    
    	if (current_process.function >= current_process._function)//判断是否完成
    	{
    		current_process.complete = true;
    		current_process.finish = g_time;
    		cout << "***********进程" << current_process.prcess_id << "完成任务*********" << endl;
    		cout << "***********进入时间:" << current_process._start << endl;
    		cout << "***********开始时间:" << current_process.begin << endl;
    		cout << "***********完成时间:" << current_process.finish << endl;
    		q_list.remove(&current_process);
    	}
    	else
    	{
    		cout << "\t\t\t\t\t\t未完成放到队尾" << current_process .prcess_id<<"***********"<< endl;
    		q_list.remove(&current_process);
    		cout << "\t\t\t\t\t\t放入的是"<< current_process.prcess_id << endl;
    		q_list.push_back(&current_process);
    	}
    }
    
    void Ahead_Of_Time(process_node & current_process)//进程提前完成 让出时间片
    {
    	int current_point = g_time;
    	cout << "当前时间" << current_point << endl;
    	while (current_point + current_process._function - current_process.function > g_time)
    	{
    		current_process.main_doing(current_process.prcess_id, NULL);
    	}
    	current_process.function += g_time - current_point;
    	Time_End_Work(current_process);
    }
    void One_Of_Time(process_node & current_process)
    {
    	int current_point = g_time;
    	cout << "当前时间" << current_point << endl;
    	while (current_point + time_film > g_time)
    	{
    		current_process.main_doing(current_process.prcess_id, NULL);
    	}
    	current_process.function += g_time - current_point;
    	Time_End_Work(current_process);
    }
    void Time_File_Doing(process_node & current_process) //时间片完成的工作
    {
    	//cout << "+++++++++++++++++" << current_process._function - current_process.function<<"+++++++++++++++++++++++" << endl;
    	if (current_process._function - current_process.function < time_film)//不到一个时间片的处理
    	{
    		Ahead_Of_Time(current_process);
    	}
    	else
    	{
    		One_Of_Time(current_process);
    	}
    }
    
    
    process_node& Obtain_Obtain()//获取优先者
    {
    	process_node *p_temp = nullptr;
    	while (q_list.size() == 0);
    	p_temp = q_list.front();
    	cout << "优先的是程序" << p_temp->prcess_id << endl;
    	cout << "\t\t\t队列中的元素有" << q_list.size() << endl;
    	if (p_temp->begin==MAX_TIME)
    	{
    		p_temp->begin = g_time;
    	}
    	return *p_temp;
    }
    void Run_begin()
    {
    
    	while (1)
    	{
    		process_node &p_temp = Obtain_Obtain();
    		Time_File_Doing(p_temp);
    	}
    }
    //时间实例到达
    void pthread_model()
    {
    	while (1)
    	{
    		lock_guard<mutex>ldg(g_mutex_time);
    		cout << g_time << endl;
    		if (g_time % 20 == 0)
    		{
    			Come_Init_Prcess(main_doing,  A_RUN_TIME);
    			cout << "A实例到达" << endl;
    		}
    		if (g_time % 50 == 0)
    		{
    			Come_Init_Prcess(main_doing,  B_RUN_TIME);
    			cout << "B实例到达" << endl;
    		}
    		Sleep(100);
    		g_time++;
    	}
    }
    int main()
    {
    	thread th_model(pthread_model);
    	thread th_main(Run_begin);
    	th_model.join();
    	th_main.join();
    	cin.get();
    }

    测试结果

     

    展开全文
  • 时间片轮转

    千次阅读 2018-12-10 20:33:27
    时间片轮转法(Round-Robin,RR)主要用于分时系统中的进程调度。为了实现轮转调度,系统把所有就绪进程按先入先出的原则排成一个队列。新来的进程加到就绪队列末尾。每当执行进程调度时,进程调度程序总是选出就绪...

    时间片轮转法(Round-Robin,RR)主要用于分时系统中的进程调度。为了实现轮转调度,系统把所有就绪进程按先入先出的原则排成一个队列。新来的进程加到就绪队列末尾。每当执行进程调度时,进程调度程序总是选出就绪队列的队首进程,让它在CPU上运行一个时间片的时间。时间片是一个小的时间单位,通常为10~100ms数量级。当进程用完分给它的时间片后,系统的计时器发出时钟中断,调度程序便停止该进程的运行,把它放入就绪队列的末尾;然后,把CPU分给就绪队列的队首进程,同样也让它运行一个时间片,如此往复。






    比如.我以一天的时间为一个单位时间.今天你必须为我辅导.明天你就为第二个人辅导.后天你就为第三个人辅导.假如只有三个人.那么第四天你有又转回来为我辅导一天了.第五天有为第二人辅导.如此类推.

    展开全文
  • 调度算法:时间片轮转

    千次阅读 2018-01-28 21:29:34
    时间片轮转法:每个进程被分配一时间段,称作它的时间片,即该进程允许运行的时间。  如果在时间片结束时进程还在运行,则CPU将被剥夺并分配给另一个进程。如果进程在时间片结束前阻塞或结束,则CPU当即进行切换...
    

    
    
    时间片轮转法:每个进程被分配一时间段,称作它的时间片,即该进程允许运行的时间。

     如果在时间片结束时进程还在运行,则CPU将被剥夺并分配给另一个进程。如果进程在时间片结束前阻塞或结束,则CPU当即进行切换。调度程序所要做的就是维护一张就绪进程列表,当进程用完它的时间片后,它被移到队列的末尾。

     时间片设得太短会导致过多的进程切换,降低了CPU效率;而设得太长又可能引起对短的交互请求的响应变差。将时间片设为100毫秒通常是一个比较合理的折中。

    展开全文
  • 操作系统进程调度算法 先来先服务 短作业优先 时间片轮转 优先级。有大量注释,帮助理解。目前没有错误
  • 调度算法之时间片轮转算法

    千次阅读 多人点赞 2019-07-05 10:12:57
    根据先来先服务的原则,将需要执行的所有进程按照到达时间的大小排成一个升序的序列,每次都给一个进程同样大小的时间片,在这个时间片内如果进程执行结束了,那么把进程从进程队列中删去,如果进程没有结束,那么把...
  • 时间片轮转算法实现

    2019-10-04 17:51:55
    时间片轮转算法的进程调度模拟程序 要求以文件的形式给出进程的ID、到达时间和估计运行时间,设计一个模拟单处理机调度的时间片轮转算法,实现处理机的调度,在屏幕上打印每次调度的相关信息,包括:进程占用处理机...
  • 时间片轮转

    2020-07-27 23:31:23
    作为一名编程小菜鸟,实验课作业不能好好完成,发布到上面,望指正。
  • 时间片轮转调动算法

    2020-07-24 23:32:48
    时间片轮转调度是一种最古老,最简单,最公平且使用最广的算法。每个进程被分配一个时间段,称作它的时间片,即该进程允许运行的时间。如果在时间片结束时进程还在运行,则CPU将被剥夺并分配给另一个进程。如果进程...
  • 【操作系统 - 2】时间片轮转RR进程调度算法

    万次阅读 多人点赞 2018-01-08 12:57:25
    【操作系统 - 2】时间片轮转RR进程调度算法。学习至此,发现很多学了但很久没用的知识,久而久之,慢慢遗忘。等哪天还需要的话,却发现已经忘得差不多了,即使整理了文档(word等),还是得从头再学一遍。读研第一...
  • 按照时间片轮转调度进程| 动态地输入进程(key,run_time,message),按照输入次序建立就绪队列l 输入CPU运行的单位时间片(cpu_base_time)l 按照时间片轮转方式模拟进程逐个被调度并执行单位时间片(运行结束进程结束,...
  • 实验1 进程调度 一、实验目的 通过实验加强对进程调度算法的理解和掌握。 二、实验内容 编写程序实现基于优先级的时间片轮转调度算法。
  • 时间片轮转调度算法的C语言模拟实现

    万次阅读 多人点赞 2016-08-20 10:32:57
    时间片轮转调度是一种最古老,最简单,最公平且使用最广的算法。每个进程被分配一个时间段,称作它的时间片,即该进程允许运行的时间。如果在时间片结束时进程还在运行,则CPU将被剥夺并分配给另一个进程。如果进程...
  • 进程调度:时间片轮转调度算法

    万次阅读 2017-06-07 19:21:00
    (4) 掌握时间片轮转法进程调度算法 二、实验原理 (1)建立进程控制块 (2)设计两个链队列,分别表示就绪队列和完成队列 (3)用户输入进程标识符,进程到达时间,进程所需的时间,申请空间存放进程,PCB...
  • 基于优先数的时间片轮转调度算法调度处理器一、实验目的 在采用多道程序设计的系统中,同时处于就绪态的进程往往有多个,当就绪态的进程数大于处理器的个数时,就需按照某种策略进行分配处理器。本次设计模拟在单...
  • 7-时间片轮转调度

    2019-11-10 11:15:49
    UCOSIII 时间片轮转调度 在UCOS中,任务调度可以理解为任务切换,当心跳时钟到来时,系统就会把当前任务的现场保存起来,放到本任务的堆栈中,这个步骤和进中断前的push压栈很相似,不过现场状态是保存在本任务...
  • Java语言时间片轮转算法

    热门讨论 2020-07-30 23:32:39
    Java语言实现时间片轮转调度算法,有界面,有解释
  • 时间片轮转算法c语言实现

    千次阅读 2018-05-12 22:48:10
    时间片轮转调度是一种最古老,最简单,最公平且使用最广的算法。每个进程被分配一个时间段,称作它的时间片,即该进程允许运行的时间。如果在时间片结束时进程还在运行,则CPU将被剥夺并分配给另一个进程。如果进程...
  • 一个小程序,自己写的进程调度,采用时间片轮转法 调度进程,操作系统的实验作业。其中包括 源代码,可执行文件和 实验报告还有演示PPT
  • 时间片轮转调度算法(C++实现)

    千次阅读 多人点赞 2019-06-05 20:54:24
    时间片轮转调度算法: (1)假设系统中有5个进程,每个进程有一个进程控制块(PCB)来标识。进程控制块内容包括:进程名,链接指针,到达时间,估计运行时间,进程状态。 进程名即进程标识。 链接指针:按照...
1 2 3 4 5 ... 20
收藏数 19,345
精华内容 7,738
关键字:

时间片轮转