有一个具有两道作业的批处理系统，作业调度采用短作业优先调度算法，进程调度采用以优先数为基础的抢占式
有一个具有两道作业的批处理系统，作业调度采用短作业优先调度算法，进程调度采用以优先数为基础的抢占式调度算法
本题中的系统是两道作业系统，因此每次只能有两个作业进入系统，作业调度采
用短作业优先算法，只有调度进入系统的进程方能参与进程调度；进程调度采用
基于优先数的抢占式调度算法，高优先级的进程可以抢占系统处理机。
本题的作业和进程的推进过程如下：
10：00 A作业到达，被作业调度程序调度进入系统，被进程调度程序调度开始运行
10：20 A作业运行20分钟，剩余20分钟，由于优先级低，被进程调度程序调度处于就绪状态
B作业到达，被作业调度程序调度进入系统，由于优先级高，被进程调度程序调度处于开始运行状态
10：30 A作业等待10分钟，剩余20分钟，继续等待
B作业运行10分钟，剩余20分钟，继续运行
C作业到达，等待被作业调度程序调度
10：50 A作业等待30分钟，剩余20分钟，由于优先级高，被进程调度程序调度处于开始运行状态
B作业运行30分钟，作业完成，结束运行
C作业等待20分钟，由于估计运行时间较长，仍未被调入系统中运行
D作业到达，被进程调度程序调度处于就绪状态
11：10 A作业运行40分钟，作业完成，结束运行
C作业等待30分钟，被作业调度程序调度进入系统，由于优先级高，被进程调度程序调度处于开始运行状态
D作业等待10分钟，由于优先级低，被进程调度程序调度处于就绪状态
12：00 C作业运行50分钟，作业完成，结束运行
D作业等待70分钟，被进程调度程序调度处于开始运行状态
12：20 D作业运行20分钟，作业完成，结束运行
各作业周转时间为：
作业A 70，作业B 30，作业C 90，作业D 90。
平均作业周转时间为70分钟。
参考1.网页链接
2.网页链接
略改动。
温馨提示：答案为网友推荐，仅供参考
第1个回答 2018-04-10
今天让我们来一起了解一下linux cpu的进程调度，对于linux服务器，通常会碰到2个问题
1、实时性，有什么办法能确保某一个进程能优先运行、并且不受时间片的限制，只有等待它运行完了，其它进程才能运行？
2、多核cpu，有什么办法能够自定义，绑定某些进程在某些cpu上？
那么在探讨这俩问题之前，先来了解一下linux进程调度基础知识。
多任务系统分为2类。
非抢占式多任务：除非进程自己主动停止运行，否则它会一直执行；
抢占式多任务：有调度程序来决定什么时候停止某一进程的运行，以便其它进程能够得到执行机会。linux采用的是此种方式。
进程对于处理的使用上，也分为2类：
I/O消耗型：有大量的磁盘、网络io操作，这种进程，其大部分时间都堵塞在io请求及其响应上；
处理器消耗型：这种程序大部分是算法很复杂，一个极端的例子就是while(1)，死循环。
高优先级的进程，先运行，并且其享用的时间片较长。低优先级进程则反之。
时间片：
过大、等待时间长，过小、进程切换频繁。默认时间片20ms。
调度的公平性
在支持多进程的系统中，理想情况下，各个进程应该是根据其优先级公平地占有CPU。而不会出现谁运气好谁占得多这样的不可控的情况。
linux实现公平调度基本上是两种思路：1、给处于可执行状态的进程分配时间片（按照优先级），用完时间片的进程被放到过期队列中。等可执行状态的进程都过期了，再重新分配时间片；2、动态调整进程的优先级。随着进程在CPU上运行，其优先级被不断调低，以便其他优先级较低的进程得到运行机会；后一种方式有更小的调度粒度，并且将公平性与动态调整优先级两件事情合二为一，大大简化了内核调度程序的代码。因此，这种方式也成为内核调度程序的新宠。强调一下，以上两点都是仅针对普通进程的。而对于实时进程，内核既不能自作多情地去动态调整优先级，也没有什么公平性可言。
一个有趣的例子：
一个系统，2个进程，一个文字编辑、一个视频编码。前者是I/O消耗型，后者处理器消耗型。那么处理器在对待这两种进程是如何分配优先级和时间片的呢。
首先，文字编辑，其大部分时间都在I/O等待上，需要对用户的请求及时响应，所以其优先级高，并且时间片长。当有用户请求时，会中断视频编码的运行。当需要等待I/O响应时，会及时交出时间片，给视频编码用。
相反，视频编码，优先级低，时间片短。
===========================================================================
好，基本知识介绍完了，下面来回答开篇提的2个问题。
linux两种实时调度策略：
SCHED_NORMAL：普通调度策略，平时我们所使用，基于时间片的抢占式调度策略。
SCHED_FIFO：先入先出调度，不使用时间片，一旦一个SCHED_FIFO级进程处于可执行状态，就会一直执行下去，直到它自己受阻塞或显式地释放cpu为止。FIFO比NORMAL优先级高，只有较高优先级的SCHED_FIFO或SCHED_RR任务才能抢占SCHED_FIFO任务。
SCHED_RR：和SCHED_FIFO类似，但是使用时间片，其优先级比SCHED_NORMAL高。当SCHED_RR时间片耗尽，相同优先级的其它实时进程会被轮流调度，注意是相同优先级的实时进程。换句话说，当其时间片耗尽，只有相同优先级的SCHED_FIFO和SCHED_RR可以被cpu调度，而低优先级的SCHED_NORMAL是不会被轮流到的。当然高优先级的实时进程，可以抢占。
实时优先级范围0~99，99是最高优先级。可以通过函数sched_get_priority_max获取。
总结：实时调度，可以使用SCHED_FIFO和SCHED_RR，区别是前者没有时间片，知道其运行完毕或受阻塞，后者有时间片，时间片耗尽，cpu可以交给同优先级的实时任务使用。
说了一大堆，到底如何设置实时调度策略，函数有哪些呢？
nice() //设置进程的nice值sched_setscheduler()//设置进程的调度策略sched_getscheduler()//获取进程的调度策略sched_setparam()//设置进程的实时优先级sched_getparam()//获取进程的实时优先级sched_get_priority_max()//获取实时优先级最大值sched_get_priority_min()//获取实时优先级最小值sched_rr_get_interval()//获取进程时间片sched_setaffinity()//设置进程处理器的亲和力sched_getaffinity()//获取进程处理器的亲和力sched_yield()//暂时让出处理器
设置实时调度策略SCHED_FIFO例子：
intrtsched_set_my_realtime_priority (int32_t prio) { struct sched_param schp; if (sched_getparam(0, &schp) < 0) { return(-1); } schp.sched_priority = prio; if (sched_setscheduler(0, SCHED_FIFO, &schp) < 0) { return(-1); } return(1);}绑定指定cpu的例子：
intrtsched_setaffinity_by_name(int32_t cpuid){ cpu_set_t mask; CPU_ZERO(&mask); CPU_SET(cpuid, &mask); sched_setaffinity(0, sizeof(cpu_set_t), &mask); return 1;}这是一个绑定cpu的例子，系统默认进程可以在任何一个cpu上运行，但为了保证某些进程的实时性，把它绑定在某个空闲cpu上运行也是很有必要的。
放弃cpu
好了，绑定cpu，设定优先级，都保证了某个进程的实时性，那么如果我们想暂时放弃其实时性，让其让出cpu，让别的进程运行一会，有什么办法呢？
可以调用函数sched_yield()，其将进程从活动队列移到过期队列中，交出其占用的cpu，需要注意的是，对于实时进程，不是将其放倒过期队列中，而是放到优先级队列的最后面。而不会放到过期队列中去。
1、实时性，有什么办法能确保某一个进程能优先运行、并且不受时间片的限制，只有等待它运行完了，其它进程才能运行？
2、多核cpu，有什么办法能够自定义，绑定某些进程在某些cpu上？
那么在探讨这俩问题之前，先来了解一下linux进程调度基础知识。
多任务系统分为2类。
非抢占式多任务：除非进程自己主动停止运行，否则它会一直执行；
抢占式多任务：有调度程序来决定什么时候停止某一进程的运行，以便其它进程能够得到执行机会。linux采用的是此种方式。
进程对于处理的使用上，也分为2类：
I/O消耗型：有大量的磁盘、网络io操作，这种进程，其大部分时间都堵塞在io请求及其响应上；
处理器消耗型：这种程序大部分是算法很复杂，一个极端的例子就是while(1)，死循环。
高优先级的进程，先运行，并且其享用的时间片较长。低优先级进程则反之。
时间片：
过大、等待时间长，过小、进程切换频繁。默认时间片20ms。
调度的公平性
在支持多进程的系统中，理想情况下，各个进程应该是根据其优先级公平地占有CPU。而不会出现谁运气好谁占得多这样的不可控的情况。
linux实现公平调度基本上是两种思路：1、给处于可执行状态的进程分配时间片（按照优先级），用完时间片的进程被放到过期队列中。等可执行状态的进程都过期了，再重新分配时间片；2、动态调整进程的优先级。随着进程在CPU上运行，其优先级被不断调低，以便其他优先级较低的进程得到运行机会；后一种方式有更小的调度粒度，并且将公平性与动态调整优先级两件事情合二为一，大大简化了内核调度程序的代码。因此，这种方式也成为内核调度程序的新宠。强调一下，以上两点都是仅针对普通进程的。而对于实时进程，内核既不能自作多情地去动态调整优先级，也没有什么公平性可言。
一个有趣的例子：
一个系统，2个进程，一个文字编辑、一个视频编码。前者是I/O消耗型，后者处理器消耗型。那么处理器在对待这两种进程是如何分配优先级和时间片的呢。
首先，文字编辑，其大部分时间都在I/O等待上，需要对用户的请求及时响应，所以其优先级高，并且时间片长。当有用户请求时，会中断视频编码的运行。当需要等待I/O响应时，会及时交出时间片，给视频编码用。
相反，视频编码，优先级低，时间片短。
===========================================================================
好，基本知识介绍完了，下面来回答开篇提的2个问题。
linux两种实时调度策略：
SCHED_NORMAL：普通调度策略，平时我们所使用，基于时间片的抢占式调度策略。
SCHED_FIFO：先入先出调度，不使用时间片，一旦一个SCHED_FIFO级进程处于可执行状态，就会一直执行下去，直到它自己受阻塞或显式地释放cpu为止。FIFO比NORMAL优先级高，只有较高优先级的SCHED_FIFO或SCHED_RR任务才能抢占SCHED_FIFO任务。
SCHED_RR：和SCHED_FIFO类似，但是使用时间片，其优先级比SCHED_NORMAL高。当SCHED_RR时间片耗尽，相同优先级的其它实时进程会被轮流调度，注意是相同优先级的实时进程。换句话说，当其时间片耗尽，只有相同优先级的SCHED_FIFO和SCHED_RR可以被cpu调度，而低优先级的SCHED_NORMAL是不会被轮流到的。当然高优先级的实时进程，可以抢占。
实时优先级范围0~99，99是最高优先级。可以通过函数sched_get_priority_max获取。
总结：实时调度，可以使用SCHED_FIFO和SCHED_RR，区别是前者没有时间片，知道其运行完毕或受阻塞，后者有时间片，时间片耗尽，cpu可以交给同优先级的实时任务使用。
说了一大堆，到底如何设置实时调度策略，函数有哪些呢？
nice() //设置进程的nice值sched_setscheduler()//设置进程的调度策略sched_getscheduler()//获取进程的调度策略sched_setparam()//设置进程的实时优先级sched_getparam()//获取进程的实时优先级sched_get_priority_max()//获取实时优先级最大值sched_get_priority_min()//获取实时优先级最小值sched_rr_get_interval()//获取进程时间片sched_setaffinity()//设置进程处理器的亲和力sched_getaffinity()//获取进程处理器的亲和力sched_yield()//暂时让出处理器
设置实时调度策略SCHED_FIFO例子：
intrtsched_set_my_realtime_priority (int32_t prio) { struct sched_param schp; if (sched_getparam(0, &schp) < 0) { return(-1); } schp.sched_priority = prio; if (sched_setscheduler(0, SCHED_FIFO, &schp) < 0) { return(-1); } return(1);}绑定指定cpu的例子：
intrtsched_setaffinity_by_name(int32_t cpuid){ cpu_set_t mask; CPU_ZERO(&mask); CPU_SET(cpuid, &mask); sched_setaffinity(0, sizeof(cpu_set_t), &mask); return 1;}这是一个绑定cpu的例子，系统默认进程可以在任何一个cpu上运行，但为了保证某些进程的实时性，把它绑定在某个空闲cpu上运行也是很有必要的。
放弃cpu
好了，绑定cpu，设定优先级，都保证了某个进程的实时性，那么如果我们想暂时放弃其实时性，让其让出cpu，让别的进程运行一会，有什么办法呢？
可以调用函数sched_yield()，其将进程从活动队列移到过期队列中，交出其占用的cpu，需要注意的是，对于实时进程，不是将其放倒过期队列中，而是放到优先级队列的最后面。而不会放到过期队列中去。
第2个回答 推荐于2018-04-10
a先到达先运行，运行20分钟后B到达，且优先级高于a，b即抢占cpu，运行过程中c，d到达，但是他们的优先级低于b，所以b一直运行完，此时所有的作业都在等待，现在是短作业优先，即是a先运行，然后是d，最后是c
a 进入时间 10：:50 结束：11:10
b 进入时间 10：:20 结束：10:50
c 进入时间 11：:30 结束：12:20
d 进入时间 11：10 结束：11:30
周转时间对应的算一下就行了本回答被提问者和网友采纳
a 进入时间 10：:50 结束：11:10
b 进入时间 10：:20 结束：10:50
c 进入时间 11：:30 结束：12:20
d 进入时间 11：10 结束：11:30
周转时间对应的算一下就行了本回答被提问者和网友采纳
第3个回答 2020-06-20
没进入内存时，作业调度采用的是短作业优先算法；进入内存中等待执行时，采用的是进程优先抢占算法。所以周转时间是：A：10：00-11：10；B：10：20-10：50；C：10：30-12：00；D：10：50-12：20
平均周转时间为：（70+30+90+90）/4=70分钟
平均周转时间为：（70+30+90+90）/4=70分钟
第4个回答 2018-10-21
A 10.00~11.10
B 10.20~10.50
C 11.10~12.00
D 10.50~12.20
B 10.20~10.50
C 11.10~12.00
D 10.50~12.20
相似回答