（上）实现进程调度算法|操作系统

（1）要求
<1>.有录入界面,动态录入进程个数,进程标识符,进入时间,服务时间,优先级,系统时间片长短等信息.
<2>.有算法选择界面,能够选择不同的调度算法.
<3>.有输出界面,输出不同调度算法下诸进程的进程标识符,进入时间,服务时间,开始时间,完成时间,周转时间,带权周转时间,及一组进程的平均周转时间及平均带权周转时间.
<4>.实现4大算法:先来先服务进程优先,短进程进程优先,高优先级优先,时间片轮转.

（2）我的思想（初始化）

我在看到这个题的时候,因为我学的是java,就想这建一个静态的内部进程类,里面放着进程信息,像各进程的名字,进入时间,服务时间等.
然后在进程集这个类里面创建一个进程数组就OK了。用的时候直接初始化就行了。
然后就是写各种调度算法就是写4个方法就ok了。

package ProcessScheduling;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class process {
    static class proces {
       public String name;   //进程标识符
       public int insertTime;   //进入时间
         public int serviceTime;  //服务时间
      public   int startTime;  //开始时间
        public  int overTime;  //完成时间
        public int turnoverTime; //周转时间
        public double turnAroundTime; //带权周转时间

    }
    proces[] processes;
    public  void  init(){
        Scanner scanner = new Scanner(System.in);
        System.out.println("你要输入的进程数");
        int amount = scanner.nextInt();
        processes = new proces[amount];
        for(int i = 0; i < amount; i++){
            System.out.println("第" + (i+1) + "进程是:");
            System.out.println("你的进程名是:");
            processes[i] = new proces();
            processes[i].name = scanner.next();
            System.out.println("你的进入时间是:");
            processes[i].insertTime = scanner.nextInt();
            System.out.println("你的估计运行时间是");
            processes[i].serviceTime = scanner.nextInt();
        }
    }

（3） 先来先服务算法
这个算法我的想法也很简单,就是按进入时间排序,4个算法每次肯定先执行进程时间第一个.所以我可以定义一个temover变量去记每次变量结束时间.
然后后面的进程就只有2中情况:
（1）进入时间小于这个temover就直接用temover作这个进程的开始时间
（2）进入时间大于这个temover,那么久还没进来,所以开始时间还是自已的进入时间

先排序我直接用的直接选择排序,简单方便,直接去进行引用的交换.

 public void FCFS(){   //先来先服务进程调度算法
        sort();
        int temover = 0; //记住每次进程的结束时间.作为下次的开始时间.
        for(int i = 0; i < processes.length; i++){
            if(i == 0){
                processes[i].startTime = processes[i].insertTime;
                processes[i].overTime = processes[i].startTime + processes[i].serviceTime;
                temover = processes[i].overTime; //记住他的结束时间.
            }else{
                //如果上一个结束时间比这个进程进入时间大,则这个进程已经进入,
                // 需要等待到temover时间才能开始,直接使用temover作为这个进程的开始时间
                if(temover >= processes[i].insertTime){
                processes[i].startTime = temover;
                processes[i].overTime = processes[i].startTime + processes[i].serviceTime;
                temover = processes[i].overTime;
            }else{
                    //否则这个进程还没有进入,需要等到这个进程的进入时间才能开始
                processes[i].startTime = processes[i].insertTime;
                processes[i].overTime = processes[i].startTime + processes[i].serviceTime;
                temover = processes[i].overTime; //记住他的结束时间.
            }
        }
        computationTime();  //计算周转时间和带权周转时间
      }
    }
    public void computationTime(){  //计算周转时间和带权周转时间
        for(int i = 0; i < processes.length; i++){
            processes[i].turnoverTime = processes[i].overTime - processes[i].insertTime;
            processes[i].turnAroundTime = (double)processes[i].turnoverTime / processes[i].serviceTime;
        }
    }
     public void sort(){  //根据进入时间直接选择排序
        for(int i = 0; i < processes.length; i++){
            for(int j = i + 1; j < processes.length; j++){
                if(processes[i].insertTime > processes[j].insertTime){
                    proces tem = processes[i];
                    processes[i] = processes[j];
                    processes[j] = tem;
                }
            }
        }
    }

（2）短进程优先算法

这个算法，其实和先来先服务差不了多少,就还是进入时间先排序,肯定先执行先进来的,然后才是短进程优先,然后就来去看在第一个进程结束前有几个进程进来,进来就按短进程优先去排序,去执行最短的.

 public void SJF() { //短进程优先算法
        sort();
        int temover = processes[0].insertTime;
        for (int i = 0; i < processes.length; i++) {
                int effect = effective(temover,i);  //查看进来了几个进程
                sort1(i,effect); //对进来的进程对短进程排序
                if (temover >= processes[i].insertTime) {
                    processes[i].startTime = temover;
                    processes[i].overTime = processes[i].startTime + processes[i].serviceTime;
                    temover = processes[i].overTime;
                } else {
                    processes[i].startTime = processes[i].insertTime;
                    processes[i].overTime = processes[i].startTime + processes[i].serviceTime;
                    temover = processes[i].overTime; //记住他的结束时间.
                }
            }
            computationTime();  //计算周转时间和带权周转时间
    }
public void sort(){  //根据进入时间直接选择排序
        for(int i = 0; i < processes.length; i++){
            for(int j = i + 1; j < processes.length; j++){
                if(processes[i].insertTime > processes[j].insertTime){
                    proces tem = processes[i];
                    processes[i] = processes[j];
                    processes[j] = tem;
                }
            }
        }
    }
    public int effective(int temover, int start){ //查看短进程有效值
        int end;  //去返回有效值的下标
        for(end = start; end < processes.length; end++){
            if(processes[end].insertTime > temover){
                break;
            }
        }
        return end;
    }
    public void sort1(int start, int end){ //根据服务时间排序
        for(int i = start; i < end; i++){
            for(int j = i + 1; j < end; j++){
                if(processes[i].serviceTime > processes[j].serviceTime){
                    proces tem = processes[i];
                    processes[i] = processes[j];
                    processes[j] = tem;
                }
            }
        }
    }

思想出来了题就好写了.