夜をむかえる

操作系统课设（优先数调度算法&&最先适应算法）

一．设计目的：

1．模拟实现计算机的处理机调度。帮助学生理解计算机的处理机调度的工作原理和实现过程。

2．模拟实现计算机的主存储器空间的分配与回收．帮助学生理解计算机主存储器空间的分配与回收

的工作原理和实现过程。

二．设计内容：

1．设计一个按优先数调度算法实现处理机调度的程序。

2．设计一个在可变分区管理方式下采用最先适应算法实现主存的分配与回收的程序。

三．设计要求：

a) 完成程序调试和运行。

b) 完成课程设计报告书

c) 课程设计报告书含数据结构、符号说明、流程图、源程序并附注解

四．设计思路：

（一）按优先数调度算法实现处理机调度

说明：系统假设 5 个进程，进程控制块 PCB 的格式为：（用结构体描述）

进程名-----作为进程的标识，5 个进程的进程名分别为 P1，P2，P3，P4，P5。

指针 -----按优先数大小把 5 个进程连成队列，用指针针出下一个进程的进程控制块 PCB 的首地址，

最后一个进程的指针为”0”.

要求运行时间-----进程需要运行的单位时间数。

优先数------进程的优先数，调度时按优先数大的进程先执行。

状态---------假设有两种状态，”就绪”状态和”结束”状态。5 个进程的初始状态为”就绪”状态，用“R”

表示，”结束”状态用“E”表示。

1）功能说明

①在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”和“要求运行时间”。

②为了调度方便，把五个进程按给定的优先数从大到小连成队列。用一单元指出队首进程，用指针指出队列的连接情况。例如：用next代替指针指向下一个节点。

③处理器调度总是选队首进程运行。采用动态改变优先数的办法，进程每运行一次优先数就减“1”。由于本实习是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：

优先数-1

要求运行时间-1

来模拟进程的一次运行。

④ 进程运行一次后，若要求运行时间!=0，则再将它加入队列（按优先数大小插入，且置队首标志）；若要求运行时间=0，则把它的状态修改成“结束”（E），且退出队列。

⑤若“就绪”状态的进程队列不为空，则重复上面（4）和（5）的步骤，直到所有进程都成为“结束”状态。

⑥ 在所设计的程序中应有显示或打印语句，能显示或打印每次被选中进程的进程名以及运行一次后进程队列的变化。

⑦为五个进程任意确定一组“优先数”和“要求运行时间”，启动所设计的处理器调度程序，显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。

即实现：按优先数调度算法实现处理机调度

2）相关类的定义（结构）

进程控制块PCB

public class PCB {

public String pcbName;//进程名

public PCB next;//指针

public int time;//运行时间

public int priority;//优先数

public char statue = 'R';//进程的状态，初始化为就绪态

//构造方法

public PCB(String pcbName, int time, int priority) {

this.pcbName = pcbName;

this.time = time;

this.priority = priority;

}}

3）流程图

4）源程序代码

package hh;
// 定义进程控制块PCB
public class PCB {
    public String pcbName;//进程名
    public PCB next;//指针
    public int time;//运行时间
    public int priority;//优先数
    public char statue = 'R';//进程的状态，初始化为就绪态

    //构造方法
    public PCB(String pcbName, int time, int priority) {
        this.pcbName = pcbName;
        this.time = time;
        this.priority = priority;
    }

    //重写toString方法
    public String toString() {
        return "进程名='" + pcbName + '\'' +
                ", 要求运行时间=" + time +
                ", 优先级数=" + priority +
                ", 状态=" + statue;
    }
}

/*按优先数调度算法模拟实现处理器调度
 */
class ProcessScheduling {
    private PCB head;

    /**
     * PCB对象插入操作，根据每一个进程的优先级数进行插入
     * 如果优先级数相等，则按先来先服务原则进行插入
     */
    public void addPCB(PCB node) {
        //若要求运行时间=0，则把它的状态修改成“结束”（E），且退出队列
        if(node.time == 0) {
            node.statue = 'E';
            System.out.println(node.pcbName + "退出进程队列");
            System.out.println(node + "\n");
            return;
        }
        //若头结点为空
        if(this.head == null) {
            this.head = node;
            return;
        }
        //边插入边按优先级进行排序

        //如果node的优先级比头结点大
        if(node.priority > this.head.priority) {
            node.next = this.head;
            this.head = node;
            return;
        }
        //如果node的优先级与头结点相等，按先来先服务原则
        if(node.priority == this.head.priority) {
            node.next = this.head.next;
            this.head.next = node;
            return;
        }
        //如果node的优先级不比头结点大，也不与头结点相等
        PCB cur = this.head;
        while(cur.next != null) {
            if(cur.next.priority < node.priority) {
                PCB curNext = cur.next;
                node.next = curNext;
                cur.next = node;
                return;
            }
            //如果node的优先级与头结点相等，按先来先服务原则
            if(cur.next.priority == node.priority) {
                PCB curNext = cur.next;
                node.next = curNext.next;
                curNext.next = node;
                return;
            }
            cur = cur.next;
        }
        //此时如果还未结束，则node应该直接插入到队尾
        cur.next = node;
        node.next = null;
    }

    /**
     * 优先数调度算法模拟实现处理器调度的运行
     * 每一次运行优先级数最高的一个进程，运行结束后再将其插入到队列中
     */
    public void runPCB() {
        while(this.head != null) {
            //运行优先级最高的第一个进程
            PCB cur = this.head;
            this.head = this.head.next;
            System.out.println();
            System.out.println("开始执行" + cur.pcbName + "进程");
            System.out.println(cur);
            //cur的运行优先级数-1
            cur.priority -= 1;
            //cur的运行时间-1
            cur.time -= 1;
            System.out.println(cur.pcbName + "进程执行完毕");
            System.out.println();
            //再将cur插入进程队列
            addPCB(cur);
            //打印每次被选中进程的进程运行一次后进程队列的变化。
            if(this.head == null) {
                System.out.println("所有的线程执行完毕");
                return;
            }
            System.out.println("=====================");
            System.out.println("此时进程队列的所有进程信息");
            display();
            System.out.println("=====================");
        }
    }

    //打印进程队列
    public void display() {
        for(PCB pcb = this.head; pcb != null; pcb = pcb.next) {
            System.out.println(pcb);
        }
    }
}


package hh;
public class TestPCB {
    public static void main(String[] args) {
        PCB[] pcbs = new PCB[5];
        pcbs[0] = new PCB("P1",2,1);
        pcbs[1] = new PCB("P2",3,5);
        pcbs[2] = new PCB("P3",1,3);
        pcbs[3] = new PCB("P4",2,4);
        pcbs[4] = new PCB("P5",4,2);
        ProcessScheduling p = new ProcessScheduling();
        for(PCB pcb : pcbs) {
            p.addPCB(pcb);
        }
        p.runPCB();
    }
}

5）实验结果

（二）可变分区管理方式下采用最先适应算法实现主存的分配与回收

可变分区方式是按作业需要的主存空间大小来分割分区的。当要装人一个作业时；根据作业需要的主存量查看是否有足够的空闲空间，若有，则按需要量分割一个分区分配给该作业；若无，则作业不能装入。随着作业的装入、撤离、主存空间被分成许多个分区。有的分区被作业占用，而有的分区是空闲的。

如图（A）所示．为了说明哪些区是空闲的，可以用来装入新作业，必须要有一张空闲区说明表，格式如图（B）所示：

起址：指出一个空闲区的主存起始地址。

长度：指出从起始地址开始的一个连续空闲区的长度。

状态：有两种状态。一种是“未分配”状态，指出对应的由起始地址接线员出的某个长度的区域是空闲区；另一种是“空表目”状态，表示表中对应的登记项目是空白（无效），可用来登记新的空闲区（例如，作业撤消后，它所占用的区域就成了空闲区位。应找一个“空表目”栏登记归还区的起址和长度且修改状态）。由于分区的个数不定，所以空闲区说明表中应有适量的状态为“空表目”的登记栏目，否则造成表格溢出无法登记。