广州大学操作系统课程设计：优先级调度
源文件下载：//download.csdn.net/download/qq_40752913/12047066
一、 实验目的
通过模拟Linux优先级调度算法，加深对进程调度算法的理解
二、实验内容
优先级调度算法实现处理机调度的程序设计提示如下：
（1） 假设系统有n个进程，每个进程用一个进程控制块（PCB）来代表。进程控制块的格式如下表所示，且参数意义也相同。进程的优先数、到达时间和估计运行时间由用户程序任意设定，且优先数越低，优先级越高。调度时，总是选择优先级最高的进程运行。
| 进程名 |
| 链接指针 |
| 进程的到达时间 |
| 进程的优先级 |
| 估计运行时间 |
| 进程状态 |
（2） 为了调度方便，设计一个指针指向就绪队列的第一个到达进程。另外再设一个当前运行进程指针，指向当前正运行的进程。
（3） 处理机调度时，总是选择已经到达队列的优先级最高的进程运行。为了采用动态优先级调度，进程每运行一次，其优先级就减1。
（4） 由于本题目是模拟实验，所以对被选中的进程并不实际启动运行，而只是执行如下操作：
- 优先数加1；
- 估计运行时间减1；
- 输出当前运行进程的名字。
用这三个操作来模拟进程的一次运行。 - 进程运行一次后，应判断该进程的剩余运行时间是否为0，若不为0，且其优先级低于就绪队列的其他进程的优先级，则选择一个高优先级进程抢占CPU运行，若该进程的剩余运行时间为0，则将该进程的状态置为完成状态“C”，并撤出就绪队列。
- 若就绪队列不为空，则重复上述的步骤（4）和（5）直到所有进程都运行完为止。
- 在所设计的调度程序中，应包含显示或打印语句，以便显示或打印每次选中进程的名称及运行一次后进程的变化以及就绪队列中各进程排队情况。
三、实验原理
此实验模拟的是进程调度的优先级法。优先级法有抢占式和非抢占式两种，这里模拟的是“抢占式优先级法”。
抢占式优先级法的原理是：当前进程在运行过程中，一旦有另一个优先级更高的进程出现在就绪队列中，进程调度程序就停止当前进程的运行，强行将CPU分给那个进程。
那这里的优先级是怎么确定呢？优先级是“一定终身”还是“随机应变呢”？
这里是选择跟Linux一样的，这里采用“随机应变”的优先级，优先级有两部分组成，一部分是一开始用户指定的优先级，另一部分是根据进程等待CPU的时间，随着等待CPU越长，优先级不断提升。
四、实验设备
Linux环境下，语言使用Java，编译器用IDEA
五、实验要求
书写课程设计报告，报告中应该包含如下内容：
（1） 课程设计题目及内容
（2） 程序中使用的数据结构及主要符号说明
（3） 程序流程图和带有详细注释的源程序
（4） 执行程序名，并打印程序运行时的初值和运算结果
（5） 实验结果分析，实验收获和体会
（6） 实验的改进意见和建议。
六、实验程序
实验的类结构图为：
Main类
package com.zhengzeliang;
/**
* @author Zzl
*/
public class Main {
public static void main(String[] args) {
SchedulingThread processSchedule = new SchedulingThread();
new Thread(processSchedule).start();
}
}
SchedulingThread类
package com.zhengzeliang;
/**
* @author Zzl
*/
public class SchedulingThread implements Runnable{
/**
* @author Zzl
* @date 2019/12/16 13:13
* @description 调度管理类的实体，用于实现优先级的调度
*/
private ScheduleManagement scheduleManagement = new ScheduleManagement();
/**
* @author Zzl
* @date 2019/12/16 13:13
* @description 对将要到达的进程的管理
*/
private ReachingProcessManagement reachingProcessManagement = new ReachingProcessManagement(scheduleManagement);
@Override
public void run() {
reachingProcessManagement.initReadyToArriveProcessTable();
while (true){
System.out.print("当前时间为：" + reachingProcessManagement.getTimeCounter());
reachingProcessManagement.enterReadySequenceOrNot();
scheduleManagement.priorityScheduling();
reachingProcessManagement.addTimeCounter();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
ProcessObj类
package com.zhengzeliang;
/**
* @author Zzl
*/
public class ProcessObj {
ProcessObj(String processName, ProcessObj nextProcess, int arriveTime, int priority, int runTime, String status) {
this.processName = processName;
this.nextProcess = nextProcess;
this.arriveTime = arriveTime;
this.priority = priority;
this.runTime = runTime;
this.status = status;
}
public ProcessObj() {
}
ProcessObj(ProcessObj process) {
this.processName = process.getProcessName();
this.nextProcess = process.getNextProcess();
this.arriveTime = process.getArriveTime();
this.priority = process.getPriority();
this.runTime = process.getRunTime();
this.status = process.getStatus();
}
/**
* @author Zzl
* @date 2019/12/15 16:53
* @description 进程名
*/
private String processName;
/**
* @author Zzl
* @date 2019/12/15 16:53
* @description 链接指针
*/
private ProcessObj nextProcess;
/**
* @author Zzl
* @date 2019/12/15 16:53
* @description 进程到达的时间
*/
private int arriveTime;
/**
* @author Zzl
* @date 2019/12/15 16:53
* @description 进程的优先级
*/
private int priority;
/**
* @author Zzl
* @date 2019/12/15 16:53
* @description 进程的运行时间
*/
private int runTime;
/**
* @author Zzl
* @date 2019/12/15 16:54
* @description 进程的状态
*/
private String status;
String getProcessName() {
return processName;
}
int getArriveTime() {
return arriveTime;
}
int getPriority() {
return priority;
}
int getRunTime() {
return runTime;
}
String getStatus() {
return status;
}
ProcessObj getNextProcess() {
return nextProcess;
}
void setPriority(int priority) {
this.priority = priority;
}
void setRunTime(int runTime) {
this.runTime = runTime;
}
void setStatus(String status) {
this.status = status;
}
}
ReachingProcessManagement类
package com.zhengzeliang;
import java.util.Enumeration;
import java.util.Hashtable;
/**
* @author Zzl
*/
public class ReachingProcessManagement {
private ScheduleManagement scheduleManagement;
/**
* @author Zzl
* @date 2019/12/15 21:28
* @description 等时间一到就提交作业的进程
*/
private Hashtable<ProcessObj, Integer> reachingProcessTable = new Hashtable<>();
/**
* @author Zzl
* @date 2019/12/15 21:58
* @description reachingProcessTable中离现在最近的时间
*/
private int nextEnterReadySequenceTime = 10000;
/**
* @author Zzl
* @date 2019/12/15 22:06
* @description 下次进入就绪队列的进程，和上面的nextEnterReadySequenceTime相对应
*/
private String nextEnterReadySequenceProcessName = null;
/**
* @author Zzl
* @date 2019/12/15 21:29
* @description 时钟计数器，每秒加一
*/
private int timeCounter = 0;
ReachingProcessManagement(ScheduleManagement scheduleManagement) {
this.scheduleManagement = scheduleManagement;
}
/**
* @author Zzl
* @date 2019/12/15 20:05
* @description 初始化一开始的进程序列
*/
void initReadyToArriveProcessTable() {
//初始化四个进程
ProcessObj a = new ProcessObj("a", null, 0, 10, 40, "R");
//等到arriveTime一到，就能加入就绪队列了
reachingProcessTable.put(a, a.getArriveTime());
ProcessObj b = new ProcessObj("b", null, 20, 5, 30, "R");
reachingProcessTable.put(b, b.getArriveTime());
ProcessObj c = new ProcessObj("c", null, 30, 8, 50, "R");
reachingProcessTable.put(c, c.getArriveTime());
ProcessObj d = new ProcessObj("d", null, 50, 12, 20, "R");
reachingProcessTable.put(d, d.getArriveTime());
//输出输出readyToArriveProcessTable表的内容
outputReachingProcessTable();
//设置 readyToArriveProcessTable中离现在最近的时间和设置下次进入就绪序列的进程名
this.setNextEnterReadySequenceTimeAndProcess();
}
/**
* @author Zzl
* @date 2019/12/15 22:02
* @description 【同步】遍历整个“未到达的进程”表reachingProcessTable，从中选出快要到的进程，
* 设置nextEnterReadySequenceProcessName和nextEnterReadySequenceTime
*/
private synchronized void setNextEnterReadySequenceTimeAndProcess() {
//键的枚举
Enumeration listWaitingProcess = reachingProcessTable.keys();
while (listWaitingProcess.hasMoreElements()) {
ProcessObj listProcess = (ProcessObj) listWaitingProcess.nextElement();
//判断是不是最早到达的进程 (离现在的最近的进程)
if (reachingProcessTable.get(listProcess) < nextEnterReadySequenceTime) {
//设置nextEnterReadySequenceProcessName和nextEnterReadySequenceTime
nextEnterReadySequenceTime = reachingProcessTable.get(listProcess);
nextEnterReadySequenceProcessName = listProcess.getProcessName();
}
}
}
/**
* @author Zzl
* @date 2019/12/15 21:41
* @description 时间计数器+1
*/
void addTimeCounter() {
this.timeCounter++;
}
/**
* @author Zzl
* @date 2019/12/15 21:47
* @description 检查进程是否到达, 如果有进程到达，进行相应处理并输出相应的信息，如果没有，则返回null
*/
void enterReadySequenceOrNot() {
ProcessObj pReadySequence;
//如果timeCounter == nextEnterReadySequenceTime，说明有进程可以进入就绪队列链表
if (timeCounter == nextEnterReadySequenceTime) {
Enumeration listWaitingProcesses = reachingProcessTable.keys();
//找出名字相等的进程
while (listWaitingProcesses.hasMoreElements()) {
ProcessObj listWaitingProcess = (ProcessObj) listWaitingProcesses.nextElement();
if (listWaitingProcess.getProcessName().equals(nextEnterReadySequenceProcessName)) {
//获取已到达进程的对象
pReadySequence = new ProcessObj(listWaitingProcess);
//删除readyToArriveProcessTable中已到达的进程
reachingProcessTable.remove(listWaitingProcess);
//重新设置nextEnterReadySequenceTime的初始值
this.nextEnterReadySequenceTime = 10000;
//重新设置nextEnterReadySequenceTime和nextEnterReadySequenceProcessName
setNextEnterReadySequenceTimeAndProcess();
//将到达的进程加入就绪队列
scheduleManagement.addReadySequence(pReadySequence);
//输出就绪队列的信息
System.out.print("\n有一个进程进入就绪队列：" + pReadySequence.getProcessName() + " ");
scheduleManagement.outputReadySequence();
//输出未到达进程的信息
outputReachingProcessTable();
System.out.println(" ");
break;
}
}
}
}
/**
* @author Zzl
* @date 2019/12/16 13:23
* @description 输出未到达的进程的信息
*/
private void outputReachingProcessTable() {
//输出readyToArriveProcessTable表的内容
System.out.println(" -------还未到达的进程-------");
Enumeration listWaitingProcess = reachingProcessTable.keys();
while (listWaitingProcess.hasMoreElements()) {
ProcessObj listProcess = (ProcessObj) listWaitingProcess.nextElement();
System.out.println(" -----name:" + listProcess.getProcessName() + "-----time:" + reachingProcessTable.get(listProcess) + "-----");
}
}
public Hashtable<ProcessObj, Integer> getReachingProcessTable() {
return reachingProcessTable;
}
public void setReachingProcessTable(Hashtable<ProcessObj, Integer> reachingProcessTable) {
this.reachingProcessTable = reachingProcessTable;
}
public int getTimeCounter() {
return timeCounter;
}
}
ScheduleManagement类
package com.zhengzeliang;
import java.util.ArrayList;
/**
* @author Zzl
*/
class ScheduleManagement {
/**
* @author Zzl
* @date 2019/12/15 21:27
* @description 就绪序列
*/
private ArrayList<ProcessObj> readySequence = new ArrayList<>();
/**
* @author Zzl
* @date 2019/12/16 9:40
* @description 向就绪链表添加进程
*/
void addReadySequence(ProcessObj pReadySequence) {
readySequence.add(pReadySequence);
}
/**
* @author Zzl
* @date 2019/12/15 21:37
* @description 输出就绪链表
*/
void outputReadySequence() {
System.out.print("长度为 " + this.readySequence.size() + " 的就绪链表：");
for (ProcessObj process : this.readySequence) {
System.out.print(process.getProcessName() + "-->");
}
System.out.println("NULL");
}
/**
* @author Zzl
* @date 2019/12/16 10:43
* @description 优先级调度
*/
void priorityScheduling() {
int minPriorityNum = 10000;
ProcessObj minPriorityProcess = null;
//找到优先数最低，即优先级最高的进程
for (ProcessObj process : readySequence) {
if (minPriorityNum > process.getPriority()) {
minPriorityNum = process.getPriority();
minPriorityProcess = process;
}
}
//修改优先级最高进程信息
modifyMinPriorityProcess(minPriorityProcess);
//输出优先级最高进程的信息
outputMaxPriorityProcess(minPriorityProcess);
//判断运行时间是否为0, 如果为0，设置状态位为“C”，并从就绪队列中移除
judgeRuntimeIsZeroOrNot(minPriorityProcess);
}
/**
* @author Zzl
* @date 2019/12/16 11:15
* @description 修改优先级最高进程信息
*/
private void modifyMinPriorityProcess(ProcessObj minPriorityProcess) {
if (minPriorityProcess != null) {
//优先数+1，即优先级减1
minPriorityProcess.setPriority(minPriorityProcess.getPriority() + 1);
//剩余运行时间减1
minPriorityProcess.setRunTime(minPriorityProcess.getRunTime() - 1);
}
}
/**
* @author Zzl
* @date 2019/12/16 10:51
* @description 输出优先级最高进程的信息
*/
private void outputMaxPriorityProcess(ProcessObj minPriorityProcess) {
if (minPriorityProcess != null) {
System.out.println("----name:" + minPriorityProcess.getProcessName() +
"----priority:" + minPriorityProcess.getPriority() +
"----remain runTime" + minPriorityProcess.getRunTime() +
"----");
}else {
System.out.println(" ");
}
}
/**
* @author Zzl
* @date 2019/12/16 11:31
* @description 判断运行时间是否为0, 如果为0，设置状态位为“C”，并从就绪队列中移除
*/
private void judgeRuntimeIsZeroOrNot(ProcessObj minPriorityProcess) {
if (minPriorityProcess != null) {
if (minPriorityProcess.getRunTime() == 0) {
//状态位设置为“C”
minPriorityProcess.setStatus("C");
System.out.print("\n（*＾-＾*） " + minPriorityProcess.getProcessName() + "进程运行完毕!");
//从就绪队列中移除
readySequence.remove(minPriorityProcess);
//输出就绪队列的信息
outputReadySequence();
System.out.println(" ");
}
}
}
ScheduleManagement() {
}
}
七、总结心得
a) 程序中使用的数据结构及主要符号说明：
| 数据结构及主要符号 | 作用 |
|---|---|
| ProcessObj类 | 进程的PCB，有进程名、状态、运行时间、优先级等信息 |
| ScheduleManagement类 | 优先级调度管理类，主要功能是从就绪队列中挑选出优先级最高的进程 |
| ArrayList readySequence | 链表，readySquence，就绪序列 |
| ReachingProcessManagement类 | 未到达进程管理类，主要功能是管理未到达的进程，当进程到达时，就将进程加入就绪队列 |
| Hashtable |
哈希表，存放的键值对是进程和进程到达的时间，等进程的时间的时间一到，就向就绪序列提交 |
b) 程序的流程图
调度线程
reachingProcessManagement.getTimeCounter()输出当前的时间
reachingProcessManagement.enterReadySequenceOrNot() 判断现在有没有新的线程加入就绪队列
schedleManagement.priorityScheduling() 优先级调度
addTimeCounter() 时间加1
c) 运行结果
-------还未到达的进程-------
-----name:c-----time:30-----
-----name:b-----time:20-----
-----name:a-----time:0-----
-----name:d-----time:50-----
当前时间为：0
有一个进程进入就绪队列：a 长度为 1 的就绪链表：a-->NULL
-------还未到达的进程-------
-----name:c-----time:30-----
-----name:b-----time:20-----
-----name:d-----time:50-----
----name:a----priority:11----remain runTime39----
当前时间为：1----name:a----priority:12----remain runTime38----
当前时间为：2----name:a----priority:13----remain runTime37----
当前时间为：3----name:a----priority:14----remain runTime36----
当前时间为：4----name:a----priority:15----remain runTime35----
当前时间为：5----name:a----priority:16----remain runTime34----
当前时间为：6----name:a----priority:17----remain runTime33----
当前时间为：7----name:a----priority:18----remain runTime32----
当前时间为：8----name:a----priority:19----remain runTime31----
当前时间为：9----name:a----priority:20----remain runTime30----
当前时间为：10----name:a----priority:21----remain runTime29----
当前时间为：11----name:a----priority:22----remain runTime28----
当前时间为：12----name:a----priority:23----remain runTime27----
当前时间为：13----name:a----priority:24----remain runTime26----
当前时间为：14----name:a----priority:25----remain runTime25----
当前时间为：15----name:a----priority:26----remain runTime24----
当前时间为：16----name:a----priority:27----remain runTime23----
当前时间为：17----name:a----priority:28----remain runTime22----
当前时间为：18----name:a----priority:29----remain runTime21----
当前时间为：19----name:a----priority:30----remain runTime20----
当前时间为：20
有一个进程进入就绪队列：b 长度为 2 的就绪链表：a-->b-->NULL
-------还未到达的进程-------
-----name:c-----time:30-----
-----name:d-----time:50-----
----name:b----priority:6----remain runTime29----
当前时间为：21----name:b----priority:7----remain runTime28----
当前时间为：22----name:b----priority:8----remain runTime27----
当前时间为：23----name:b----priority:9----remain runTime26----
当前时间为：24----name:b----priority:10----remain runTime25----
当前时间为：25----name:b----priority:11----remain runTime24----
当前时间为：26----name:b----priority:12----remain runTime23----
当前时间为：27----name:b----priority:13----remain runTime22----
当前时间为：28----name:b----priority:14----remain runTime21----
当前时间为：29----name:b----priority:15----remain runTime20----
当前时间为：30
有一个进程进入就绪队列：c 长度为 3 的就绪链表：a-->b-->c-->NULL
-------还未到达的进程-------
-----name:d-----time:50-----
----name:c----priority:9----remain runTime49----
当前时间为：31----name:c----priority:10----remain runTime48----
当前时间为：32----name:c----priority:11----remain runTime47----
当前时间为：33----name:c----priority:12----remain runTime46----
当前时间为：34----name:c----priority:13----remain runTime45----
当前时间为：35----name:c----priority:14----remain runTime44----
当前时间为：36----name:c----priority:15----remain runTime43----
当前时间为：37----name:b----priority:16----remain runTime19----
当前时间为：38----name:c----priority:16----remain runTime42----
当前时间为：39----name:b----priority:17----remain runTime18----
当前时间为：40----name:c----priority:17----remain runTime41----
当前时间为：41----name:b----priority:18----remain runTime17----
当前时间为：42----name:c----priority:18----remain runTime40----
当前时间为：43----name:b----priority:19----remain runTime16----
当前时间为：44----name:c----priority:19----remain runTime39----
当前时间为：45----name:b----priority:20----remain runTime15----
当前时间为：46----name:c----priority:20----remain runTime38----
当前时间为：47----name:b----priority:21----remain runTime14----
当前时间为：48----name:c----priority:21----remain runTime37----
当前时间为：49----name:b----priority:22----remain runTime13----
当前时间为：50
有一个进程进入就绪队列：d 长度为 4 的就绪链表：a-->b-->c-->d-->NULL
-------还未到达的进程-------
----name:d----priority:13----remain runTime19----
当前时间为：51----name:d----priority:14----remain runTime18----
当前时间为：52----name:d----priority:15----remain runTime17----
当前时间为：53----name:d----priority:16----remain runTime16----
当前时间为：54----name:d----priority:17----remain runTime15----
当前时间为：55----name:d----priority:18----remain runTime14----
当前时间为：56----name:d----priority:19----remain runTime13----
当前时间为：57----name:d----priority:20----remain runTime12----
当前时间为：58----name:d----priority:21----remain runTime11----
当前时间为：59----name:c----priority:22----remain runTime36----
当前时间为：60----name:d----priority:22----remain runTime10----
当前时间为：61----name:b----priority:23----remain runTime12----
当前时间为：62----name:c----priority:23----remain runTime35----
当前时间为：63----name:d----priority:23----remain runTime9----
当前时间为：64----name:b----priority:24----remain runTime11----
当前时间为：65----name:c----priority:24----remain runTime34----
当前时间为：66----name:d----priority:24----remain runTime8----
当前时间为：67----name:b----priority:25----remain runTime10----
当前时间为：68----name:c----priority:25----remain runTime33----
当前时间为：69----name:d----priority:25----remain runTime7----
当前时间为：70----name:b----priority:26----remain runTime9----
当前时间为：71----name:c----priority:26----remain runTime32----
当前时间为：72----name:d----priority:26----remain runTime6----
当前时间为：73----name:b----priority:27----remain runTime8----
当前时间为：74----name:c----priority:27----remain runTime31----
当前时间为：75----name:d----priority:27----remain runTime5----
当前时间为：76----name:b----priority:28----remain runTime7----
当前时间为：77----name:c----priority:28----remain runTime30----
当前时间为：78----name:d----priority:28----remain runTime4----
当前时间为：79----name:b----priority:29----remain runTime6----
当前时间为：80----name:c----priority:29----remain runTime29----
当前时间为：81----name:d----priority:29----remain runTime3----
当前时间为：82----name:b----priority:30----remain runTime5----
当前时间为：83----name:c----priority:30----remain runTime28----
当前时间为：84----name:d----priority:30----remain runTime2----
当前时间为：85----name:a----priority:31----remain runTime19----
当前时间为：86----name:b----priority:31----remain runTime4----
当前时间为：87----name:c----priority:31----remain runTime27----
当前时间为：88----name:d----priority:31----remain runTime1----
当前时间为：89----name:a----priority:32----remain runTime18----
当前时间为：90----name:b----priority:32----remain runTime3----
当前时间为：91----name:c----priority:32----remain runTime26----
当前时间为：92----name:d----priority:32----remain runTime0----
（*＾-＾*） d进程运行完毕!长度为 3 的就绪链表：a-->b-->c-->NULL
当前时间为：93----name:a----priority:33----remain runTime17----
当前时间为：94----name:b----priority:33----remain runTime2----
当前时间为：95----name:c----priority:33----remain runTime25----
当前时间为：96----name:a----priority:34----remain runTime16----
当前时间为：97----name:b----priority:34----remain runTime1----
当前时间为：98----name:c----priority:34----remain runTime24----
当前时间为：99----name:a----priority:35----remain runTime15----
当前时间为：100----name:b----priority:35----remain runTime0----
（*＾-＾*） b进程运行完毕!长度为 2 的就绪链表：a-->c-->NULL
当前时间为：101----name:c----priority:35----remain runTime23----
当前时间为：102----name:a----priority:36----remain runTime14----
当前时间为：103----name:c----priority:36----remain runTime22----
当前时间为：104----name:a----priority:37----remain runTime13----
当前时间为：105----name:c----priority:37----remain runTime21----
当前时间为：106----name:a----priority:38----remain runTime12----
当前时间为：107----name:c----priority:38----remain runTime20----
当前时间为：108----name:a----priority:39----remain runTime11----
当前时间为：109----name:c----priority:39----remain runTime19----
当前时间为：110----name:a----priority:40----remain runTime10----
当前时间为：111----name:c----priority:40----remain runTime18----
当前时间为：112----name:a----priority:41----remain runTime9----
当前时间为：113----name:c----priority:41----remain runTime17----
当前时间为：114----name:a----priority:42----remain runTime8----
当前时间为：115----name:c----priority:42----remain runTime16----
当前时间为：116----name:a----priority:43----remain runTime7----
当前时间为：117----name:c----priority:43----remain runTime15----
当前时间为：118----name:a----priority:44----remain runTime6----
当前时间为：119----name:c----priority:44----remain runTime14----
当前时间为：120----name:a----priority:45----remain runTime5----
当前时间为：121----name:c----priority:45----remain runTime13----
当前时间为：122----name:a----priority:46----remain runTime4----
当前时间为：123----name:c----priority:46----remain runTime12----
当前时间为：124----name:a----priority:47----remain runTime3----
当前时间为：125----name:c----priority:47----remain runTime11----
当前时间为：126----name:a----priority:48----remain runTime2----
当前时间为：127----name:c----priority:48----remain runTime10----
当前时间为：128----name:a----priority:49----remain runTime1----
当前时间为：129----name:c----priority:49----remain runTime9----
当前时间为：130----name:a----priority:50----remain runTime0----
（*＾-＾*） a进程运行完毕!长度为 1 的就绪链表：c-->NULL
当前时间为：131----name:c----priority:50----remain runTime8----
当前时间为：132----name:c----priority:51----remain runTime7----
当前时间为：133----name:c----priority:52----remain runTime6----
当前时间为：134----name:c----priority:53----remain runTime5----
当前时间为：135----name:c----priority:54----remain runTime4----
当前时间为：136----name:c----priority:55----remain runTime3----
当前时间为：137----name:c----priority:56----remain runTime2----
当前时间为：138----name:c----priority:57----remain runTime1----
当前时间为：139----name:c----priority:58----remain runTime0----
（*＾-＾*） c进程运行完毕!长度为 0 的就绪链表：NULL
当前时间为：140
当前时间为：141
当前时间为：142
当前时间为：143
Process finished with exit code -1
d) 分析实验结果，实验收获和体会
实验结果：
从实验结果的结果来看，可以在进程到达时加入就绪序列，并被优先级调度算法根据就绪序列的优先级，选择一个合适的队列进程输出执行。在进程运行完毕后，能够将进程的状态改为“C”，并将进程从就绪队列删除。
实验收获：
在做实验前，由于对操作系统的一些概念还不是很熟悉，因此先看了课本，先熟悉了一下，并做成博客（基本整本课本都做了）：点击跳转,
并且通过实验，加深了优先级调度算法的理解，同时，用的环境是Linux，编程语言是Java，进一步也加深了我对Linux和Java的理解