时间片轮转调度算法的算法

时间片轮转调度算法的基本原理~

在早期的时间片轮转法中,系统将所有的就绪进程按先来先服务的原则,排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片.时间片的大小从几ms到几百ms.当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片.这样就可以保证就绪队列中的所有进程,在一给定的时间内,均能获得一时间片的处理机执行时间.

-----------------PCB.java
public class PCB extends Work{
public PCB(String name, int t1, int t2 ) {
super(name, t1, t2);
// TODO Auto-generated constructor stub
}
/** 下一个进程*/
private PCB next=null;
/**已运行的时间*/
private int usedTime;
/** 进程的状态ready 和 done两种*/
private Status status=Status.ready;
private int proir;
/**
* 得到下一个进程
* @return
*/
public PCB getNext(){
return this.next;
}
/**
* 执行一个时间片
*/
public void goOneStep(){
this.usedTime++;
}
/**
* 设置优先数
* @param p
*/
public void setProir(int p){
this.proir=p;
}
/**
* 取优先数
* @return
*/
public int getProir(){
return this.proir;
}
/**
* 判断一下是否该进程是否完成
* @return
*/
public boolean isDone(){
if(this.usedTime==this.getServiceTime()){
this.status=Status.done;
return true;
}
return false;
}
}
-----------------------Status.java

//进程的状态（ready（就绪）,done（完成））
public enum Status {
ready,done;
}
------------------Test.java

import java.util.ArrayList;
import java.util.List;

/*例如一组进程如下表：
进程名 A B C D E F G H J K L M
到达时间 0 1 2 3 6 8 12 12 12 18 25 25
服务时间 6 4 10 5 1 2 5 10 4 3 15 8
*/

public class Test {

/**
* @param args
*/
public static void main(String[] args) {
List jobs = new ArrayList();
PCB A = new PCB("A", 0, 6);
PCB B = new PCB("B", 1, 4);
PCB C = new PCB("C", 2, 10);
PCB D = new PCB("D", 3, 5);
PCB E = new PCB("E", 6, 1);
PCB F = new PCB("F", 8, 2);
PCB G = new PCB("G", 12, 5);
PCB H = new PCB("H", 12, 10);
PCB J = new PCB("J", 12, 4);
PCB K = new PCB("K", 18, 3);
PCB L = new PCB("L", 25, 15);
PCB M = new PCB("M", 25, 8);
jobs.add(A);
jobs.add(B);
jobs.add(C);
jobs.add(D);
jobs.add(E);
jobs.add(F);
jobs.add(G);
jobs.add(H);
jobs.add(J);
jobs.add(K);
jobs.add(L);
jobs.add(M);
for (int i = 0; i < jobs.size(); i++) {
jobs.get(i).setProir((int) (Math.random() * 100));
}
System.out.println("main");
doWork(jobs);
// 下面就从队列中一个个选出进程执行
}
/**
* 在每个时钟i的时刻都检测是否有新的进程到达，如果有则添加，
* 直到进程队列都全都加入系统的就绪队列
* @param i
* @param jobs
* @param ins
* @return
*/
public static List checkAddPCB(int i,Listjobs,List ins){
List contain=new ArrayList();
contain.add(jobs);
contain.add(ins);
while (jobs.size() != 0 && i >= jobs.get(0).getArrivalTime()) {
System.out.println(jobs.get(0).getName());
ins.add(jobs.get(0));
System.out.println("adding--" + jobs.get(0).getName()+"--process into System Queue");
// 从加入系统的队列中移除j
jobs.remove(0);
//return contain;
}
return contain;
}
public static void doWork(List jobs) {
//int i = 0;
// 从已经加入系统中选择优先级别高的
List ins = new ArrayList();
for (int i = 0; true; i++) {
//i是一个时钟器的作用，
//每次加1，相当于系统每次都执行一个时间片，
//直到所有进程都执行完，才跳出循环
List con=checkAddPCB(i, jobs, ins);
jobs=con.get(0);
ins=con.get(1);
PCB now = sortByProir(ins).get(0);
while (now != null) {
// 执行一个时间片
System.out.println("第\"" + (i + 1) + "\"个周期中执行的是" + now.getName());
now.goOneStep();
// 判断now在执行一个时间片后是否全部执行完
now.setProir(now.getProir() - 3);
if (now.isDone()) {
System.out.println("" + now.getName() + "进程执行完");
ins.remove(now);
}
i++;
con=checkAddPCB(i, jobs, ins);
jobs=con.get(0);
ins=con.get(1);
if(ins.isEmpty()){
break;
}
now=sortByProir(ins).get(0);
}
if(ins.size()==0){
break;
}
}
}

public static List sortByProir(List jobs) {
for (int i = 0; i < jobs.size(); i++) {
for (int j = i + 1; j < jobs.size(); j++) {
PCB ja = jobs.get(i);
int a = ja.getProir();
PCB jb = jobs.get(j);
int b = jb.getProir();
if (b < a) {
jobs.remove(j);
jobs.add(i, jb);
}
}
}
return jobs;
}

}

多级反馈队列调度算法
(1) 设置多个就绪队列,并为各个队列赋予不同的优先级. 第一个队列的优先级最高,第二个队列次之,其余各队列的优先权逐个降低.
该算法赋予各个队列中进程执行时间片的大小也各不相同:
在优先权愈高的队列中,为每个进程所规定的执行时间片就愈小.
例如:第二个队列的时间片要比第一个队列的时间片长一倍,……,第i+1个队列的时间片要比第i个队列的时间片长一倍.
(2) 当一个新进程进入内存后,首先将它放入第一队列的末尾,按FCFS原则排队等待调度.当轮到该进程执行时,如它能在该时间片内完成,便可准备撤离系统;如果它在一个时间片结束时尚未完成,调度程序便将该进程转入第二队列的末尾,再同样地按FCFS原则等待调度执行;如果它在第二队列中运行一个时间片后仍未完成,再依次将它放入第三队列,……,如此下去,当一个长作业(进程)从第一队列依次降到第n队列后,在第n队列中便采取按时间片轮转的方式运行.
(3) 仅当第一队列空闲时,调度程序才调度第二队列中的进程运行; 仅当第1~(i-1) 队列均空时,才会调度第i队列中的进程运行.如果处理机正在第i队列中为某进程服务时,又有新进程进入优先权较高的队列(第1~(i-1)中的任何一个队列),则此时新进程将抢占正在运行进程的处理机,即由调度程序把正在运行的进程放回到第i队列的末尾,把处理机分配给新到的高优先权进程.?
性能
(1)终端型作业用户
(2) 短批处理作业用户
(3) 长批处理作业用户
满足了多数用户的需求 优先权调度算法
1,优先权调度算法的类型
非抢占式优先权算法
在这种方式下,系统一旦把处理机分配给就绪队列中优先权最高的进程后,该进程便一直执行下去,直至完成; 或因发生某事件使该进程放弃处理机时,系统方可再将处理机重新分配给另一优先权最高的进程.这种调度算法主要用于批处理系统中;也可用于某些对实时性要求不严的实时系统中.
抢占式优先权调度算法
系统同样把处理机分配给优先权最高的进程,使之执行.但在其执行期间,只要又出现了另一个其优先权更高的进程,进程调度程序就立即停止当前进程(原优先权最高的进程)的执行,重新将处理机分配给新到的优先权最高的进程.
这种抢占式的优先权调度算法,能更好地满足紧迫作业的要求,常用于要求比较严格的实时系统中, 以及对性能要求较高的批处理和分时系统中.
2,优先权的类型
(1) 静态优先权
静态优先权是在创建进程时确定的,且在进程的整个运行期间保持不变.
一般地,优先权是利用某一范围内的一个整数来表示的,例如,0~7或0~255中的某一整数, 又把该整数称为优先数.只是具体用法各异:有的系统用0表示最高优先权,当数值愈大时,其优先权愈低;而有的系统恰恰相反.
确定进程优先权的依据有如下三个方面:
1.进程类型.(系统进程/用户进程)
2.进程对资源的需求.(需求量的大小)
3.用户要求.(用户进程紧迫程度)
(2) 动态优先权
动态优先权是指在创建进程时所赋予的优先权,可以随进程的推进或随其等待时间的增加而改变的,以便获得更好的调度性能.
例如,我们可以规定,在就绪队列中的进程,随其等待时间的增长,其优先权以速率a提高.若所有的进程都具有相同的优先权初值,则显然是最先进入就绪队列的进程,将因其动态优先权变得最高而优先获得处理机,此即FCFS算法.
优先权的变化规律可描述为:
由于等待时间与服务时间之和,就是系统对该作业的响应时间,故该优先权又相当于响应比RP.据此,又可表示为:
3,高响应比优先调度算法
由上面的式子可以得到以下结论:
(1) 如果作业的等待时间相同,则要求服务的时间愈短,其优先权愈高,因而该算法有利于短作业.
(2) 当要求服务的时间相同时,作业的优先权决定于其等待时间,等待时间愈长,其优先权愈高,因而它实现的是先来先服务.
(3) 对于长作业,作业的优先级可以随等待时间的增加而提高,当其等待时间足够长时,其优先级便可升到很高, 从而也可获得处理机.
该算法照顾了短作业,且不会使长作业长期得不到服务 1. 非抢占式调度算法
为每一个被控对象建立一个实时任务并将它们排列成一轮转队列,调度程序每次选择队列中的第一个任务投入运行.该任务完成后便把它挂在轮转队列的队尾等待下次调度运行.
2. 非抢占式优先调度算法.
实时任务到达时,把他们安排在就绪队列的对首,等待当前任务自我终止或运行完成后才能被调度执行.
3. 抢占式调度算法
1）基于时钟中断的抢占式优先权调度算法.
实时任务到达后,如果该任务的优先级别高于当前任务的优先级并不立即抢占当前任务的处理机,而是等到时钟中断到来时,调度程序才剥夺当前任务的执行,将处理机分配给新到的高优先权任务.
2）立即抢占的优先权调度算法.
在这种调度策略中,要求操作系统具有快速响应外部时间中断的能力.一旦出现外部中断,只要当前任务未处于临界区便立即剥夺当前任务的执行,把处理机分配给请求中断的紧迫任务，实时进程调度，实时进程抢占当前。 1 实现实时调度的基本条件
1-1. 提供必要的信息-就绪时间.
1-2. 开始截止时间和完成截止时间.
1-3. 处理时间.
1-4. 资源要求.
1-5. 优先级.
2. 系统处理能力强
在实时系统中,通常都有着多个实时任务.若处理机的处理能力不够强,则有可能因处理机忙不过来而使某些实时任务不能得到及时处理, 从而导致发生难以预料的后果.假定系统中有m个周期性的硬实时任务,它们的处理时间可表示为Ci,周期时间表示为Pi,则在单处理机情况下,系统可调度必须满足下面的限制条件:
当系统不可调度时解决的方法是提高系统的处理能力,其途径有二:
其一仍是采用单处理机系统,但须增强其处理能力, 以显著地减少对每一个任务的处理时间;
其二是采用多处理机系统.假定系统中的处理机数为N,则应将上述的限制条件改为:
3. 采用抢占式调度机制
当一个优先权更高的任务到达时,允许将当前任务暂时挂起,而令高优先权任务立即投入运行.采用这种方式去满足那些开始截止时间即将到来的任务.?
4. 具有快速切换机制
应具有的能力:
(1) 对外部中断的快速响应能力.为使在紧迫的外部事件请求中断时系统能及时响应,要求系统具有快速硬件中断机构,还应使禁止中断的时间间隔尽量短,以免耽误时机(其它紧迫任务).?
(2) 快速的任务分派能力.在完成任务调度后,便应进行任务切换.为了提高分派程序进行任务切换时的速度, 应使系统中的每个运行功能单位适当的小,以减少任务切换的时间开销.实时调度实例
一, 最早截止时间优先算法(EDF)
EDF算法用于非抢占调度方式
优先级:根据任务的开始截止时间来确定任务的优先级.
二,最低松弛优先算法(LLF)
例如:系统中有两个周期性实时任务A和B,任务A要求每20ms执行一次,执行时间为10ms;任务B要求每50ms执行一次,执行时间为25ms.这样可知A和B每次必须完成的时间和开始截止时间如图所示
优先级:根据任务紧急程度来确定任务优先级
A和B任务每次必须完成的时间
A1 (10) A2 (30) A3(50) A4 (70) A5(90) A6 (110) A7(130) A8(150)
0 、10、 20、 30 、40、 50 、60、 70、 80 、90 、100 、110、 120、130、 140、 150
B1(25) B2(75) B3(125)
A和B任务每次必须开始的时间
时间(ms) A截止时间 B截止时间 调度对象
0 A1(10) B1(25) A1
10 A2(20) B1(15) B1
30 A2(0) B1(15) A2
40 A3(10) B1(5) B1
45 A3(5) B2(30) A3
55 A4(15) B2(20) B2
70 A4(0) B2(20) A4
松弛度
松弛度
( 20-10-0 ) ( 50-25-0 )
(40-10-10 ) ( 50-25-10 )
(40-10-30) (50-5-30)
(60-10-40) (50-5-40)
(60-10-45) (100-25-45)
(80-10-55) (100-25-55)
(80-10-70) (100-10-70 )
3.4.1 多处理器系统的类型
(1) 紧密耦合(Tightly Coupted)MPS.
这通常是通过高速总线或高速交叉开关,来实现多个处理器之间的互连的.它们共享主存储器系统和I/O设备,并要求将主存储器划分为若干个能独立访问的存储器模块,以便多个处理机能同时对主存进行访问.系统中的所有资源和进程,都由操作系统实施统一的控制和管理.
3.4 多处理机系统中的调度
从处理器之间耦合的紧密程度上划分:
松散耦合(Loosely Coupled)MPS.
在松散耦合MPS中,通常是通过通道或通信线路,来实现多台计算机之间的互连.每台计算机都有自己的存储器和I/O设备,并配置了OS来管理本地资源和在本地运行的进程.因此,每一台计算机都能独立地工作, 必要时可通过通信线路与其它计算机交换信息,以及协调它们之间的工作.
根据系统中所用处理器的相同与否划分:
(1) 对称多处理器系统SMPS. 在系统中所包含的各处理器单元,在功能和结构上都是相同的,当前的绝大多数MPS都属于SMP系统.例如,IBM公司的SR/6000 Model F50, 便是利用4片Power PC处理器构成的.?
(2) 非对称多处理器系统.在系统中有多种类型的处理单元,它们的功能和结构各不相同,其中只有一个主处理器,有多个从处理器：
1. 对称多处理器系统中的进程分配方式
在SMP系统中,所有的处理器都是相同的,因而可把所有的处理器作为一个处理器池(Processor pool),由调度程序或基于处理器的请求,将任何一个进程分配给池中的任何一个处理器去处理.在进行进程分配时,可采用以下两种方式之一.
1) 静态分配(Static Assigenment)方式
2) 动态分配(Dynamic Assgement)方式?
3.4.2 进程分配方式
静态分配(Static Assigenment)方式
一个进程从开始执行直到完成,都被固定分配到一个处理器上去执行.
2) 动态分配(Dynamic Assgement)方式
系统中设置有公共的就绪队列.分配进程时,可以将进程分配到任何一个处理器上.
动态分配方式的主要优点是消除了各处理器忙闲不均的现象
2. 非对称MPS中的进程分配方式?
对于非对称MPS,其OS大多采用主—从(Master-Slave)式OS,即OS的核心部分驻留在一台主机上(Master),而从机(Slave)上只是用户程序,进程调度只由主机执行.每当从机空闲时,便向主机发送一索求进程的信号,然后,便等待主机为它分配进程.在主机中保持有一个就绪队列,只要就绪队列不空,主机便从其队首摘下一进程分配给请求的从机.从机接收到分配的进程后便运行该进程,该进程结束后从机又向主机发出请求.
缺点:对主机要求高,出现故障导致整个系统瘫痪
1. 自调度(Self-Scheduling)方式
1) 自调度机制?
在系统中设置有一个公共的进程或线程就绪队列, 所有的处理器在空闲时,都可自己到该队列中取得一进程(或线程)来运行.在自调度方式中,可采用在单处理机环境下所用的调度算法,如先来先服务(FCFS)调度算法,最高优先权优先(FPF)调度算法和抢占式最高优先权优先调度算法等.
3.4.3 进程(线程)调度方式
2) 自调度方式的优点?
1,系统中的公共就绪队列可按照单处理机系统中所采用的各种方式加以组织;其调度算法也可沿用单处理机系统所用的算法,即很容易将单处理机环境下的调度机制移植到多处理机系统中
2,只要系统中有任务(公共就绪队列不空)就不会出现处理机空闲的情况,也不会发生处理器忙闲不均的现象,因而有利于提高处理器的利用率.
3)自调度方式的缺点
3.4.4进程调度过程
1、进程名：作为进程的标识。
指针：进程按顺序排成循环链表，用指针指出下一个进程的进程控制块首地址，最后一个进程中的指针指出第一个进程的进程控制块首地址。
2、要求运行时间：假设进程需要运行的单位时间数。
已运行时间：假设进程已经运行的单位时间数，初值为0。
状态：可假设有两种状态，就绪状态和结束状态。进程的初始状态都为就绪状态。
3、每次运行所设计的处理器调度程序调度进程之前，为每个进程任意确定它的要求运行时间。
4、此程序是模拟处理器调度，因此，被选中的进程并不实际启动运行，而是执行
已运行时间+1
来模拟进程的一次运行，表示进程已经运行过一个单位时间。
.5、在所设计的程序中应有显示或打印语句，能显示或打印每次被选中的进程名以及运行一次后进程队列的变化。
6、为进程任意确定要求运行时间，运行所设计的处理器调度程序，显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。
7、设有一个就绪队列，就绪进程按优先数（优先数范围0－100）由小到大排列（优先数越小，级别越高）。当某一进程运行完一个时间片后，其优先级应下调（如优先数加2或3）。
8、例如一组进程如下表： 进程名 A B C D E F G H J K L M 到达时间 0 1 2 3 6 8 12 12 12 18 25 25 服务时间 6 4 10 5 1 2 5 10 4 3 15 8

---

伊春区15839443211： 操作系统的时间片轮转法具体的算法 - ？
机柱硫酸： 四、算法实现 1)系统初始化时给每一个进程赋以一个needtime,并将所有进程按needtime从小到大的次序排成一个队列.2) 取队头进程,并投入运行. 3) 采用相对固定时间片(Time_piece),进程每执行一次,进程占用的CPU时间加...

伊春区15839443211： 什么是时间片轮转调度算法?希望能够详细的解释一下,最好是举个例子. - ？
机柱硫酸：[答案] 时间片轮转调度是一种最古老,最简单,最公平且使用最广的算法.每个进程被分配一个时间段,称作它的时间片,即该进程允许运行的时间.如果在时间片结束时进程还在运行,则CPU将被剥夺并分配给另一个进程.如果进程在时间片...

伊春区15839443211： 什么是时间片轮转调度算法 - ？
机柱硫酸： 时间片轮转调度是一种最古老,最简单,最公平且使用最广的算法. 每个进程被分配一个时间段,称作它的时间片,即该进程允许运行的时间.如果在时间片结束时进程还在运行,则CPU将被剥夺并分配给另一个进程.如果进程在时间片结束前阻塞或结束,则CPU当即进行切换.调度程序所要做的就是维护一张就绪进程列表,当进程用完它的时间片后,它被移到队列的末尾. 就这样说吧,CPU假如比做一个游戏机,现在A,B,C都想玩,如何去分配呢,时间片轮转调度就是来分配这游戏机的,先让A玩三分钟,再让B玩三分钟,再让C玩三分钟,再来让A玩三分钟,如此循环.

伊春区15839443211： 操作系统中基于时间片段的轮转调度算法,中时间片大小如何确定的 - ？
机柱硫酸：[答案] 让就绪进程以 FCFS 的方式按时间片轮流使用 CPU 的调度方式叫基于时间片段的轮转调度算法.根据确定实时任务优先权方法的不同,确定时间片的大小.以响应度高的优先权高的进程正序排列进程任务,轮流作业.

伊春区15839443211： 时间片轮转调度 - ？
机柱硫酸： #include ＂stdio.h＂ #include ＂stdlib.h＂ #include ＂string.h＂ typedef struct node {char name[10]; /*进程标识符*/int prio; /*进程优先数*/int round; /*进程时间轮转时间片*/int cputime; /*进程占用cpu时间*/int needtime; /*进程到完成还...

伊春区15839443211： 时间片轮转调度算法C语言实现 - ？
机柱硫酸： 用定时器,比如定时10ms,当时间到时,就把当前PC压栈,然后跳转下一个任务的地址,依次类推,生死轮回

伊春区15839443211： 操作系统进程调度算法 - ？
机柱硫酸： 你好,我复制的,希望对你有用. 调度算法是指:根据系统的资源分配策略所规定的资源分配算法. 一、先来先服务和短作业(进程)优先调度算法 1. 先来先服务调度算法.先来先服务(FCFS)调度算法是一种最简单的调度算法,该算法既...

伊春区15839443211： 常用的进程调度算法有_____、优先数、时间片轮转以及_____等算法.先来先服务;分级调度】 - ？
机柱硫酸：[答案] 先来先服务,短作业优先,最高相应比,多级反馈队列.

伊春区15839443211： 时间片轮转调度算法如何选择时间片的大小 - ？
机柱硫酸：[答案] 时间片轮转算法. 时间片不是相等的吗?! 难道您说的是时间片不相同的时间片轮转. 那就是按照事件的优先级来排序了. 看看linux源代码.O(1)算法. 你会明白很多.

伊春区15839443211： 时间片轮转调度算法的执行顺序问题 - ？
机柱硫酸： 那个时刻,顺序是:先入队,调整队,队首进程执行. 所以,新程序先入队,调整队把第一个进程放在队尾了,最后执行在队头的进程 所以你说的“第一个进程”(就是没完成的那个)在队尾 想像一下,如果队中只有一个没有完成的进程,结束之后不是放在队尾,这样不是刚进来的进程都要放在它的后面执行吗?这样是不是对刚来的家伙不公平呢?但是实际上不同的进程调度算法实现起来是不一样的,你也可以自己写一个,让新来的给前辈让路. 我参照的是汤小丹的《计算机操作系统》教材的实现方式. 希望能帮到你