优先级的时间片轮转算法（操作系统实验）

最新推荐文章于 2023-04-02 15:32:44 发布

小卓仗剑走天涯hhh

最新推荐文章于 2023-04-02 15:32:44 发布

阅读量2.4k

点赞数 2

实验题目：基于优先级的时间片轮转调度算法调度处理器

一、实验目的
在采用多道程序设计的系统中，同时处于就绪态的进程往往有多个，当就绪态的进程数大于处理器的个数时，就需按照某种策略进行分配处理器。本次设计模拟在单处理器情况下采用基于优先数的时间片轮转调度算法进行处理器调度，加深了解处理器调度工作过程。
二、实验内容及要求
2.1、设计一个程序实现基于优先数的时间片轮转调度算法调度处理器。
2.2、假定系统有5个进程，每个进程用一个进程控制块PCB开代表，进程控制块的结构如下图1.2所示：

  1、进程名
  2、指针
  3、到达时间
  4、要求运行时间
  5、已运行时间
  6、优先数

进程状态
其中：
进程名：作为进程的标识。
指针：进程按顺序排成循环链表，用指针指出下一个进程的进程控制块首地址，最后一个进程中的指针指出第一个进程的进程控制块首地址。
要求运行时间：假设进程需要运行的单位时间数。
已运行时间：假设进程已经运行的单位时间数，初值为0。
状态：可假设有两种状态，就绪状态和结束状态。进程的初始状态都为就绪状态。
3、每次运行所设计的处理器调度程序调度进程之前，为每个进程任意确定它的要求运行时间。
4、此程序是模拟处理器调度，因此，被选中的进程并不实际启动运行，而是执行
已运行时间+1
来模拟进程的一次运行，表示进程已经运行过一个单位时间。
.5、在所设计的程序中应有显示或打印语句，能显示或打印每次被选中的进程名以及运行一次后进程队列的变化。
6、为进程任意确定要求运行时间，运行所设计的处理器调度程序，显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。
7、设有一个就绪队列，就绪进程按优先数（优先数范围0－100）由小到大排列（优先数越小，级别越高）。当某一进程运行完一个时间片后，其优先级应下调（如优先数加2）。

三丶 主要解决办法
3.1 判断进程是否在就绪队列中

wait_run_list = new ArrayList<>();

            // 此处将所有进程中等待执行的序列的进程选出 由current_time 判断进程是否在等待序列中
            for (ProgressTest pt : list) {
                // 是否在就绪队列 是否执行完毕
                if (current_time >= pt.arrive_time
                        && pt.do_service_time != pt.service_time) {
                    wait_run_list.add(pt);
                }
            }

3.2 List list 排序

Collections.sort(wait_run_list, new Comparator<ProgressTest>() {
                public int compare(ProgressTest arg0, ProgressTest arg1) {
                    return arg0.priority < arg1.priority ? -1 : 1;
                }
            });

四丶完整代码

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

public class ProgressTest2 {
	private int arrive_time; // 到达时间
	private int service_time; // 服务时间
	private int do_service_time; // 已运行时间
	private int priority; // 优先级
	private boolean state; // 运行状态 false为完成 true为就绪
	private char name; // 名称

	public static int current_time;//当前运行的时间
	public static int total_time; // 总的运行时间

	static List<ProgressTest2> list = new ArrayList<>();  //目标队列
	static List<ProgressTest2> wait_run_list = null;      //就绪队列
	static List<ProgressTest2> wait_list = null;          //等待队列

	public static void main(String[] args) throws InterruptedException {
		ProgressTest2 A = new ProgressTest2(65, 0, 6, 7);
		ProgressTest2 B = new ProgressTest2(66, 2, 10, 8);
		ProgressTest2 C = new ProgressTest2(67, 3, 5, 4);
		ProgressTest2 D = new ProgressTest2(68, 6, 1, 1);
		ProgressTest2 E = new ProgressTest2(69, 8, 2, 1);
		ProgressTest2 F = new ProgressTest2(70, 12, 5, 8);

		list.add(A);
		list.add(B);
		list.add(C);
		list.add(D);
		list.add(E);
		list.add(F);

		total_time = getTotalTime(list);

		doRRbyPriority(list);

	}

	private static void doRRbyPriority(List<ProgressTest2> list) throws InterruptedException {

		while (current_time <= total_time) {
			wait_run_list = new ArrayList<>();
			wait_list = new ArrayList<>();

			// 此处将所有进程中等待执行的序列的进程选出 由current_time 判断进程是否在等待序列中
			for (ProgressTest2 pt : list) {
				// 是否在就绪队列 是否执行完毕
				if (current_time >= pt.arrive_time && pt.do_service_time != pt.service_time) {
					if (wait_run_list.size() < 3) {
						wait_run_list.add(pt);
					}else{
						pt.priority--;
						wait_list.add(pt);
					}
					
				}
			}

			Collections.sort(wait_run_list, new Comparator<ProgressTest2>() {
				public int compare(ProgressTest2 arg0, ProgressTest2 arg1) {
					return arg0.priority < arg1.priority ? -1 : 1;
				}
			});

			System.out.println("就绪队列wait_run_list:" + wait_run_list.toString());
			System.out.println("等待队列wait_list:" + wait_list.toString());

			System.out.println(current_time + " " + total_time + " " + current_time);
			if (wait_run_list.size() > 0) {
				ProgressTest2 pt = wait_run_list.get(0);
				if (pt.checkProgress()) {
					pt.doOnceRun();
					current_time++; // 一次执行一个时间片
					System.out.println("当前运行" + pt.toString());
				}
				System.out.println();

			} else {
				break;
			}

		}

	}

	public ProgressTest2(int name, int arrive_time, int service_time, int priority) {
		this.arrive_time = arrive_time;
		this.service_time = service_time;
		this.priority = priority;
		this.name = (char) name;
		state = true; // 默认为就绪状态
	}

	// 获得总的运行时间
	public static int getTotalTime(List<ProgressTest2> list) {
		int time = 0;
		Iterator<ProgressTest2> it = list.iterator();
		while (it.hasNext()) {
			ProgressTest2 pt = it.next();
			time += pt.service_time;
		}
		return time;
	}

	// 一次运行时间 服务时间减一 上调优先数
	public void doOnceRun() {
		if (this.do_service_time < this.service_time) {
			do_service_time++;
		}

		this.priority += 2;
	}

	public boolean checkProgress() {
		if (this.do_service_time == this.service_time) {
			state = false;
			System.out.println(this.state + ",运行完毕");
			return state;
		} else {
			return state;
		}
	}

	@Override
	public String toString() {
		return this.name + " " + "已服务" + do_service_time + " 到达" + arrive_time + " 服务" + service_time + " 优先级"
				+ priority;
	}

}

运行效果：

就绪队列wait_run_list:[A 已服务0 到达0 服务6 优先级7]
等待队列wait_list:[]
0 29 0
当前运行A 已服务1 到达0 服务6 优先级9

就绪队列wait_run_list:[A 已服务1 到达0 服务6 优先级9]
等待队列wait_list:[]
1 29 1
当前运行A 已服务2 到达0 服务6 优先级11

就绪队列wait_run_list:[B 已服务0 到达2 服务10 优先级8, A 已服务2 到达0 服务6 优先级11]
等待队列wait_list:[]
2 29 2
当前运行B 已服务1 到达2 服务10 优先级10

就绪队列wait_run_list:[C 已服务0 到达3 服务5 优先级4, B 已服务1 到达2 服务10 优先级10, A 已服务2 到达0 服务6 优先级11]
等待队列wait_list:[]
3 29 3
当前运行C 已服务1 到达3 服务5 优先级6

就绪队列wait_run_list:[C 已服务1 到达3 服务5 优先级6, B 已服务1 到达2 服务10 优先级10, A 已服务2 到达0 服务6 优先级11]
等待队列wait_list:[]
4 29 4
当前运行C 已服务2 到达3 服务5 优先级8

就绪队列wait_run_list:[C 已服务2 到达3 服务5 优先级8, B 已服务1 到达2 服务10 优先级10, A 已服务2 到达0 服务6 优先级11]
等待队列wait_list:[]
5 29 5
当前运行C 已服务3 到达3 服务5 优先级10

就绪队列wait_run_list:[B 已服务1 到达2 服务10 优先级10, C 已服务3 到达3 服务5 优先级10, A 已服务2 到达0 服务6 优先级11]
等待队列wait_list:[D 已服务0 到达6 服务1 优先级0]
6 29 6
当前运行B 已服务2 到达2 服务10 优先级12

就绪队列wait_run_list:[C 已服务3 到达3 服务5 优先级10, A 已服务2 到达0 服务6 优先级11, B 已服务2 到达2 服务10 优先级12]
等待队列wait_list:[D 已服务0 到达6 服务1 优先级-1]
7 29 7
当前运行C 已服务4 到达3 服务5 优先级12

就绪队列wait_run_list:[A 已服务2 到达0 服务6 优先级11, B 已服务2 到达2 服务10 优先级12, C 已服务4 到达3 服务5 优先级12]
等待队列wait_list:[D 已服务0 到达6 服务1 优先级-2, E 已服务0 到达8 服务2 优先级0]
8 29 8
当前运行A 已服务3 到达0 服务6 优先级13

就绪队列wait_run_list:[B 已服务2 到达2 服务10 优先级12, C 已服务4 到达3 服务5 优先级12, A 已服务3 到达0 服务6 优先级13]
等待队列wait_list:[D 已服务0 到达6 服务1 优先级-3, E 已服务0 到达8 服务2 优先级-1]
9 29 9
当前运行B 已服务3 到达2 服务10 优先级14

就绪队列wait_run_list:[C 已服务4 到达3 服务5 优先级12, A 已服务3 到达0 服务6 优先级13, B 已服务3 到达2 服务10 优先级14]
等待队列wait_list:[D 已服务0 到达6 服务1 优先级-4, E 已服务0 到达8 服务2 优先级-2]
10 29 10
当前运行C 已服务5 到达3 服务5 优先级14

就绪队列wait_run_list:[D 已服务0 到达6 服务1 优先级-4, A 已服务3 到达0 服务6 优先级13, B 已服务3 到达2 服务10 优先级14]
等待队列wait_list:[E 已服务0 到达8 服务2 优先级-3]
11 29 11
当前运行D 已服务1 到达6 服务1 优先级-2

就绪队列wait_run_list:[E 已服务0 到达8 服务2 优先级-3, A 已服务3 到达0 服务6 优先级13, B 已服务3 到达2 服务10 优先级14]
等待队列wait_list:[F 已服务0 到达12 服务5 优先级7]
12 29 12
当前运行E 已服务1 到达8 服务2 优先级-1

就绪队列wait_run_list:[E 已服务1 到达8 服务2 优先级-1, A 已服务3 到达0 服务6 优先级13, B 已服务3 到达2 服务10 优先级14]
等待队列wait_list:[F 已服务0 到达12 服务5 优先级6]
13 29 13
当前运行E 已服务2 到达8 服务2 优先级1

就绪队列wait_run_list:[F 已服务0 到达12 服务5 优先级6, A 已服务3 到达0 服务6 优先级13, B 已服务3 到达2 服务10 优先级14]
等待队列wait_list:[]
14 29 14
当前运行F 已服务1 到达12 服务5 优先级8

就绪队列wait_run_list:[F 已服务1 到达12 服务5 优先级8, A 已服务3 到达0 服务6 优先级13, B 已服务3 到达2 服务10 优先级14]
等待队列wait_list:[]
15 29 15
当前运行F 已服务2 到达12 服务5 优先级10

就绪队列wait_run_list:[F 已服务2 到达12 服务5 优先级10, A 已服务3 到达0 服务6 优先级13, B 已服务3 到达2 服务10 优先级14]
等待队列wait_list:[]
16 29 16
当前运行F 已服务3 到达12 服务5 优先级12

就绪队列wait_run_list:[F 已服务3 到达12 服务5 优先级12, A 已服务3 到达0 服务6 优先级13, B 已服务3 到达2 服务10 优先级14]
等待队列wait_list:[]
17 29 17
当前运行F 已服务4 到达12 服务5 优先级14

就绪队列wait_run_list:[A 已服务3 到达0 服务6 优先级13, B 已服务3 到达2 服务10 优先级14, F 已服务4 到达12 服务5 优先级14]
等待队列wait_list:[]
18 29 18
当前运行A 已服务4 到达0 服务6 优先级15

就绪队列wait_run_list:[B 已服务3 到达2 服务10 优先级14, F 已服务4 到达12 服务5 优先级14, A 已服务4 到达0 服务6 优先级15]
等待队列wait_list:[]
19 29 19
当前运行B 已服务4 到达2 服务10 优先级16

就绪队列wait_run_list:[F 已服务4 到达12 服务5 优先级14, A 已服务4 到达0 服务6 优先级15, B 已服务4 到达2 服务10 优先级16]
等待队列wait_list:[]
20 29 20
当前运行F 已服务5 到达12 服务5 优先级16

就绪队列wait_run_list:[A 已服务4 到达0 服务6 优先级15, B 已服务4 到达2 服务10 优先级16]
等待队列wait_list:[]
21 29 21
当前运行A 已服务5 到达0 服务6 优先级17

就绪队列wait_run_list:[B 已服务4 到达2 服务10 优先级16, A 已服务5 到达0 服务6 优先级17]
等待队列wait_list:[]
22 29 22
当前运行B 已服务5 到达2 服务10 优先级18

就绪队列wait_run_list:[A 已服务5 到达0 服务6 优先级17, B 已服务5 到达2 服务10 优先级18]
等待队列wait_list:[]
23 29 23
当前运行A 已服务6 到达0 服务6 优先级19

就绪队列wait_run_list:[B 已服务5 到达2 服务10 优先级18]
等待队列wait_list:[]
24 29 24
当前运行B 已服务6 到达2 服务10 优先级20

就绪队列wait_run_list:[B 已服务6 到达2 服务10 优先级20]
等待队列wait_list:[]
25 29 25
当前运行B 已服务7 到达2 服务10 优先级22

就绪队列wait_run_list:[B 已服务7 到达2 服务10 优先级22]
等待队列wait_list:[]
26 29 26
当前运行B 已服务8 到达2 服务10 优先级24

就绪队列wait_run_list:[B 已服务8 到达2 服务10 优先级24]
等待队列wait_list:[]
27 29 27
当前运行B 已服务9 到达2 服务10 优先级26

就绪队列wait_run_list:[B 已服务9 到达2 服务10 优先级26]
等待队列wait_list:[]
28 29 28
当前运行B 已服务10 到达2 服务10 优先级28

就绪队列wait_run_list:[]
等待队列wait_list:[]
29 29 29

小卓仗剑走天涯hhh

关注

2
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫