求一进程调度算法，高手请进

Question

一、一个具有两道作业的批处理系统，作业调度采用短作业优先的调度算法，进程调度采用以优先数为基础的抢占式调度算法，如下表的作业序列（表中所有作业优先数即为进程优先数，数值越小优先级越高）。
（1）列出所有作业进入内存时间及结束时间
（2）计算平均周转时间
作业名          到达时间            估计运算时间        优先数
A               10：00                  40分                  5
B               10：20                  30分                  3
C               10：30                  50分                  4
D               10：50                  20分                  6
二、要求实现各种作业和进程调度算法，使用户任意选择组合使用。

Answer 1

问一下，楼主学的<<计算机操作系统>>是哪个出版社出的

Answer 2

寒一个！！！！！！
MD 刚辛辛苦苦的回帖 电脑居然莫名其妙重启了干脆就到简体给你回复！！
FT

Answer 3

楼主是作题目吧 思路一下
1. 监听新的作业
2. 将新的作业的优先级与正在运行的作业的优先级比较,< 则不管, ＝ 要看你的业务规则， > 则抢过来，挂起原来的这里可以使用树做为保存作业，根节点为永远为当前运行的作业(即优先级最高，叶子的优先级都<=其)你可以这么进行模拟:
主线程负责调度 监听线程负责监听 作业的运行就以获得某个资源的使用权来模拟，本质是一样的，都是获得某个东西，主线程随机产生一系列的作业<子线程>，然后对资源进行申请，监听线程进行处理，或者专门写一个工作线程来处理树的重新生成楼主还可以增加一些 为了避免线程<任务>饿死，可以采用时间片的方法，即如果有比正在运行的作业的优先级相同的作业进来，则判断时间片是否用完，用完了则交给后面相等的。。否则继续，。。也可以不采用树，采用其他的比如队列 但是如果用队列可能需要多个队列呵呵 楼主好好干 做好了 给大家共享一下。。

Answer 4

努力中，我原先用了推算的方法，中间就写不下去了，我把原代码贴出来大家帮忙看看。另外我也试试楼上的方法。下面的过程只能处理没有强占时的情况，如果有多个进程同时进入就不行了。
procedure TSlove.resolve;
var i,rd: Integer;
begin
  with MainForm do
  begin
    if Reslove.unsloved<=Reslove.pt then //如果进程数已经小于系统允许同时运行的进程数
    begin
      for i:=1 to Reslove.pt do
      begin     //推算剩下进程各自需要执行的时间
        proc[Reslove.sloving[i]].RunnedTime := proc[Reslove.sloving[i]].RunnedTime
            +proc[Reslove.sloving[i]].RunTime-proc[Reslove.sloving[i]].RealRunnedTime;
        output(Reslove.sloving[i]);
      end
    end else      //如果进程数量大于系统允许同时运行的数量
    begin
      i := 1;
      rd := i;
      while (i<=Reslove.pt) and (Reslove.unsloved>Reslove.pt)do //正在运行的进程
      begin
        if proc[Reslove.sloving[i]].StartTime+proc[Reslove.sloving[i]].RunTime<=
            proc[Reslove.lastproc+1].StartTime then           //如果该进程在下一进程到达前能运行完毕
        begin
          proc[Reslove.sloving[i]].unsloved := false;   //标记该进程为已完成
          proc[Reslove.sloving[i]].RunnedTime := proc[Reslove.sloving[i]].RunTime;
          Reslove.output(Reslove.sloving[i]);           //输出该进程的执行结果
          Reslove.lastproc := Reslove.lastproc+1;       //调入一个新的进程
          Reslove.sloving[i] := Reslove.lastproc;
          Reslove.unsloved := Reslove.unsloved-1;
          i := 0;
          rd := 1;
        end else rd := rd+1;
        i := i+1;
      end;
      if rd=Reslove.pt then //当前正在运行的进程的结束时间均在下一进程到达之后
      begin
        if maxseed<>Reslove.lastproc then  //待进入的进程的优先级最小,保持现有的状态
        begin
          i := 1;
          rd := proc[Reslove.sloving[minruntime]].RunTime-proc[Reslove.sloving[minruntime]].RealRunnedTime;
          while (i<=pnum) do
          begin
            if (proc[i].unsloved) and (proc[i].StartTime<proc[Reslove.sloving[minruntime]].StartTime
                  +proc[Reslove.sloving[minruntime]].RunnedTime+rd)
            then
            begin
              proc[i].RunnedTime := proc[i].RunnedTime+rd;
              proc[Reslove.sloving[minruntime]].RunnedTime := proc[Reslove.sloving[minruntime]].RunnedTime+rd;
              proc[Reslove.sloving[minruntime]].unsloved := false;
              output(Reslove.sloving[minruntime]);
              Reslove.lastproc := Reslove.lastproc+1;       //调入一个新的进程
              Reslove.sloving[i] := Reslove.lastproc;
              Reslove.unsloved := Reslove.unsloved-1;
            end;
            i := i+1;
          end;
        end;
      end;
      Reslove.resolve;
    end;
  end;
end;

Answer 5

先把你的思路理清楚...然後分成比較小的處理模塊<函數>...這麼長的代碼 一般很少人看喔...呵呵..