处理机调度算法（时间调度）

南昌航空大学实验报告

课程名称:  操作系统              实验名称:   处理机调度

班级:110462          姓名:XXX    学号:  11046208

一 实验目的:

编写程序以下面三种方式之一模拟处理机调度。要求掌握几种处理机调度算法的基本思想和特点，理解并发与并行的区别，学会设计处理调度算法

二 实验内容:

时间片轮转算法:

时间片轮转调度是一种最古老，最简单，最公平且使用最广的算法，又称RR调度。每个进程被分配一个时间段，称作它的时间片，即该进程允许运行的时间。

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

三 实验分析:

每个任务都只运行一个固定的时间片或者但程序运行结束的时候时间片还有剩余则主动转向另外一个程序执行;所以需要设置程序时片的大小,也需要设置以上的第二种情况发生的时候,自动转向另外一个程序;

设计思路:

1        设计一个队列,需要运行的进程作为结点,保存需要进行运行的程序,

2        设计调度一个队列的处理算法,也就是设计时间片轮转调度;

四 实验程序代码设计:

package com.rainplus.processor;

public class Processor {
	private long cpuTime = 3000l; // 设置时间片大小

	class ProcessQueue {
		private ProcessNode first;
		private ProcessNode last;
		private long size = 0;

		public void insert(ProcessNode pn) {
			if (size == 0) {
				first = pn;
			} else {
				last.setNext(pn);
			}
			last = pn;
			size++;
		}

		public void delete() {
			Process p = first.getProcess();
			first = first.getNext();
			size--;
		}
	}

	class ProcessNode {
		private Process process;
		private ProcessNode next;

		public void setProcess(Process p) {
			process = p;
		}

		public Process getProcess() {
			return process;
		}

		public void setNext(ProcessNode pn) {
			next = pn;
		}

		public ProcessNode getNext() {
			return next;
		}

	}

	class Process {
		private long runTime;
		private String name;

		public void setName(String name) {
			this.name = name;
		}

		public String getName() {
			return name;
		}

		public void setRunTime(long runTime) {
			this.runTime = runTime;
		}

		public long getRunTime() {
			return runTime;
		}
	}

	public void processing(ProcessQueue queue) {
		
		System.out.print("各个作业需要运行的时间为:");
		ProcessNode temp0 = queue.first;
		for (int i = 0; i < queue.size; i++) {
			System.out.print(temp0.getProcess().getRunTime() + "ms, ");
			temp0 = temp0.getNext();
		}System.out.println("\n--------开始执行程序!-----------");
		while (queue.size != 0) {
			ProcessNode temp = queue.first;
			if (temp.getProcess().runTime <= cpuTime) {// 如果<=时间片轮转时间,则占用一个时间片,执行后想下一个结点执行
				System.out.println(temp.getProcess().getName()
						+ "进程执行结束,转向下一个作业");
				queue.delete();
			} else {// 占用多个时间片,运行时间-时间片后移动到队列尾部
				long remainTime = temp.getProcess().getRunTime() - cpuTime;
				System.out.println(temp.getProcess().getName()
						+ "运行3000ms后中断执行,移动到执行队列后端,剩余运行时间为:" + remainTime
						+ "ms");
				temp.getProcess().setRunTime(remainTime);
				queue.insert(temp);
				queue.delete();
			}

		}
		System.out.println("已没有需要执行的作业\n--------执行程序结束!-----------!");

	}

	public void test() {
		ProcessQueue queue = new ProcessQueue();
		int processNum = 5;
		long[] runTimes = { 7000, 2000, 5000, 10000, 1600 };
		ProcessNode[] processNodes = new ProcessNode[processNum];
		for (int i = 0; i < processNum; i++) {
			processNodes[i] = new ProcessNode();
			processNodes[i].setProcess(new Process());
		}
		for (int i = 0; i < processNodes.length; i++) {
			processNodes[i].getProcess().setName("作业" + i);
			processNodes[i].getProcess().setRunTime(runTimes[i]);
			queue.insert(processNodes[i]);
		}
		processing(queue);

	}

	public static void main(String[] args) {
		new Processor().test();
	}
}

五 实验结果:

各个作业需要运行的时间为:7000ms,2000ms, 5000ms, 10000ms, 1600ms,

--------开始执行程序!-----------

作业0运行3000ms后中断执行,移动到执行队列后端,剩余运行时间为:4000ms

作业1进程执行结束,转向下一个作业

作业2运行3000ms后中断执行,移动到执行队列后端,剩余运行时间为:2000ms

作业3运行3000ms后中断执行,移动到执行队列后端,剩余运行时间为:7000ms

作业4进程执行结束,转向下一个作业

作业0运行3000ms后中断执行,移动到执行队列后端,剩余运行时间为:1000ms

作业2进程执行结束,转向下一个作业

作业3运行3000ms后中断执行,移动到执行队列后端,剩余运行时间为:4000ms

作业0进程执行结束,转向下一个作业

作业3运行3000ms后中断执行,移动到执行队列后端,剩余运行时间为:1000ms

作业3进程执行结束,转向下一个作业

已没有需要执行的作业

--------执行程序结束!-----------!

 

六 实验体会:

通过本次实验,了解了几种处理机调度算法的基本思想和特点，理解并发与并行的区别，并真实实现了时间片处理算法