前言
其实代码半年前就已经写完了，现在才想起来可以分享给大伙交作业，整个代码是两天时间赶出来的，所以前端页面做的很烂，后端很多设计也不合理，但是整体功能都没啥问题，因为要快速搭建环境所以使用了springBoot来构建后端，前端也用的Vue2来实现，不懂vue也基本能看懂，本项目着重讲解使用java来完成四种进程调度算法
- 先来先服务： 这个算法是最简单实现的，就是进程根据到达的时间，先来的就先进行，按照到达时间排序
- 优先级排序： 这个算法也是十分简单的，按照进程的优先级来进行降序排序
- 时间片轮转： 进程根据到底时间来排序，并按照所给的时间片进行轮询，即前面的进程没有进行完但轮到下一个进程进行调度
- 响应比优先： 响应比Rp = (等待时间+要求服务时间)/要求服务时间 前后端完整代码已经发布到gitee上了，下面仅展示部分代码。
gitee地址:gitee.com/deng-changt…
如果帮助到了你，请给个免费的star吧!
页面展示
优先级调度结果
时间片轮转
测试下来四种调度没有问题
代码实现
进程类的属性
public class MyProcess implements Comparable<MyProcess>{
private int id;
private String name;
// 抵达时间
private String arriveTime;
// 剩余运行时间
private String needRunTime;
// 已运行时间，单位是s
private int haveRunTime;
// 优先级
private int priority;
// 是否已完成
private Boolean isFinished;
// 线程状态，分为已完成和未完成
private String state;
// 响应比
private float R;
public MyProcess run() throws IOException {
setHaveRunTime(getHaveRunTime()+1);
int needTime = new TimeHelper().transform(needRunTime);
needTime--;
if(needTime>=0){
setNeedRunTime(new TimeHelper().transform(needTime));
}
if(needTime == 0){
this.isFinished = true;
setNeedRunTime("0");
setState("已完成");
}
return this;
}
public MyProcess runByStep(int step) throws Exception {
setHaveRunTime(getHaveRunTime()+step);
int needTime = new TimeHelper().transform(needRunTime);
if(needTime>=0){
needTime-=step;
System.out.println("进程"+name+"分配运行"+step+"秒");
if(needTime<=0){
this.isFinished = true;
System.out.println("进程"+name+"运行结束");
}
setNeedRunTime( new TimeHelper().transform(needTime));
}
return this;
}
@Override
public int compareTo(MyProcess p2) {
if(!this.arriveTime.equals(p2.getArriveTime())){
return this.arriveTime.compareTo(p2.getArriveTime());
}
else{
return this.id - p2.id;
}
}
}
系统含有两个队列，一个是就绪队列，一个是等待队列，系统记录系统时间，每次系统时间改变的时候就去等待队列里面检查，查看是否有进程抵达，如果有则加入就绪队列
@Data
@Component
@AllArgsConstructor
@NoArgsConstructor
public class ProcessList {
private ArrayList<MyProcess> readyList;
private ArrayList<MyProcess> waitList;
{
readyList = new ArrayList<>();
waitList = new ArrayList<>();
}
}
判断进程是否加入就绪队列
public boolean goReadyList() throws Exception {
//使用flag记录是否添加了进程
boolean flag = false;
ArrayList<MyProcess> readyList = ProcessList.getReadyList();
ArrayList<MyProcess> waitList = ProcessList.getWaitList();
if(waitList.size()!=0){
for (int i = 0; i < waitList.size(); i++) {
int arriveTime = timeHelper.transform(waitList.get(i).getArriveTime());
// 如果当前运行时间到达进程到达时间，则将该进程从等待队列中加入到就绪队列
if(arriveTime <= systemTime){
MyProcess myProcess = waitList.get(i);
System.out.println("添加进程"+myProcess.getName());
flag = true;
readyList.add(myProcess);
waitList.remove(i);
// 正规写法请用迭代器
i--;
}
}
}
if(flag){
String wait = JSONObject.toJSONString(waitList);
String ready = JSONObject.toJSONString(readyList);
myWebSocket.sendAwitList(wait);
myWebSocket.sendReadyList(ready);
}
System.out.println("当前等待队列有"+waitList.size()+"个元素");
return flag;
}
接下来就是四种排序方法，这里写的比较烂，但能用,推荐使用迭代器
// 先来先运行
if(type == 1){
System.out.println("开始运行");
while (waitList.size()!=0||readyList.size()!=0){
if(readyList.size()!=0){
for (int i = 0; i < readyList.size(); i++) {
MyProcess myProcess = readyList.get(i);
while(!myProcess.getIsFinished()){
String obj = JSONObject.toJSONString(myProcess.run());
myWebSocket.sendMessage(obj);
Thread.sleep(1000);
systemTime++;
// 每次在系统时间更改的时候需要判断等待队列是否有就绪的进程
this.goReadyList();
}
readyList.remove(i);
String ready = JSONObject.toJSONString(readyList);
// websocket发送消息
myWebSocket.sendReadyList(ready);
i--;
}
}
else{
systemTime++;
this.goReadyList();
}
}
}
```
// 按照优先度运行
if(type == 2){
this.sortByPriority();
while (waitList.size()!=0||readyList.size()!=0) {
if (readyList.size() != 0) {
for (int i = 0; i < readyList.size(); i++) {
MyProcess myProcess = readyList.get(i);
while (!myProcess.getIsFinished()) {
String obj = JSONObject.toJSONString(myProcess.run());
myWebSocket.sendMessage(obj);
Thread.sleep(1000);
systemTime++;
this.goReadyList();
}
// 因为可能添加了新的进程进入就绪队列所以需要重新排序
readyList.remove(i);
this.sortByPriority();
String ready = JSONObject.toJSONString(readyList);
myWebSocket.sendReadyList(ready);
i--;
}
}
else {
systemTime++;
this.goReadyList();
}
}
}
// 时间片调度
public void runByTime(int step) throws Exception {
ArrayList<MyProcess> readyList = ProcessList.getReadyList();
ArrayList<MyProcess> waitList = ProcessList.getWaitList();
while (waitList.size()!=0||readyList.size()!=0) {
if (readyList.size() != 0) {
for (int i = 0; i < readyList.size(); i++) {
MyProcess myProcess = readyList.get(i);
String obj = JSONObject.toJSONString(myProcess.runByStep(step));
myWebSocket.sendMessage(obj);
Thread.sleep(step* 1000L);
systemTime += step;
this.goReadyList();
// 如果有线程运行完了
if(myProcess.getIsFinished()){
readyList.remove(i);
String ready = JSONObject.toJSONString(readyList);
myWebSocket.sendReadyList(ready);
i--;
}
}
}
else {
systemTime+=step;
this.goReadyList();
}
}
// 高响应比优先
public void HRRN() throws Exception {
ArrayList<MyProcess> readyList = ProcessList.getReadyList();
ArrayList<MyProcess> waitList = ProcessList.getWaitList();
this.SortByHRRN();
while (waitList.size()!=0||readyList.size()!=0) {
if (readyList.size() != 0) {
for (int i = 0; i < readyList.size(); i++) {
MyProcess myProcess = readyList.get(i);
while (!myProcess.getIsFinished()) {
String obj = JSONObject.toJSONString(myProcess.run());
myWebSocket.sendMessage(obj);
Thread.sleep(1000);
systemTime += 1;
this.goReadyList();
}
readyList.remove(i);
String ready = JSONObject.toJSONString(readyList);
myWebSocket.sendReadyList(ready);
i--;
this.SortByHRRN();
}
}
else{
systemTime += 1;
this.goReadyList();
this.SortByHRRN();
}
}
}
// 高响应比排序
public void SortByHRRN(){
ArrayList<MyProcess> readyList = ProcessList.getReadyList();
for (int i = 0; i < readyList.size(); i++) {
MyProcess process =readyList.get(i);
// 生成响应比- 使用系统当前时间减去进程到达时间再除以进程需要的时间
float w = systemTime-timeHelper.transform(process.getArriveTime());
float r = timeHelper.transform(process.getNeedRunTime());
float R = w/r;
process.setR(R);
}
Collections.sort(readyList, new Comparator<MyProcess>() {
@Override
public int compare(MyProcess o1, MyProcess o2) {
return (int) (o2.getR() - o1.getR());
}
});
}
