操作系统-磁盘调度算法:先来先服务,最短寻道时间优先,scan算法

1.先来先服务
[java]
public class FCFS {

    /**
     * 磁盘调度:先来先服务
     */
    private static int startPosition = 100 ;//磁头开始位置  
    private static int totalMoving = 0;
    private static List<Integer> visitList = new ArrayList<Integer>();//访问磁道列表  
    public static void main(String[] args) {
        System.out.println("------磁盘调度:先来先服务算法模拟---------");
        input();
        running();
        display();  www.atcpu.com
    }
    //接收用户输入列表  
    public static void input(){
        System.out.print("请输入磁道访问列表,以空格分开:");
        Scanner sc = new Scanner(System.in);
        String input = sc.nextLine();
        String[] inputList = input.split("\\s");
        try{
            for(String in : inputList){
                visitList.add(Integer.valueOf(in));
            }
        }
        catch(Exception e){
            System.out.println("输入的必须是数字,请重新开始！！！");
            System.exit(1);
        }
    }
    
    //运行  
    public static void running(){
        Iterator<Integer> it = visitList.listIterator();
        int thisPosition = 0;
        while(it.hasNext()){
            thisPosition = it.next();
            totalMoving += Math.abs(startPosition-thisPosition);
            startPosition = thisPosition;
            System.out.println("当前访问磁道号:"+thisPosition);
        }
    }
    public static void display(){
        System.out.println("平均寻道时间是:"+(double)totalMoving/visitList.size());
    }

}
public class FCFS {
/**
  * 磁盘调度:先来先服务
  */
private static int startPosition = 100 ;//磁头开始位置
private static int totalMoving = 0;
private static List<Integer> visitList = new ArrayList<Integer>();//访问磁道列表
public static void main(String[] args) {
  System.out.println("------磁盘调度:先来先服务算法模拟---------");
  input();
  running();
  display();
}
//接收用户输入列表
public static void input(){
  System.out.print("请输入磁道访问列表,以空格分开:");
  Scanner sc = new Scanner(System.in);
  String input = sc.nextLine();
  String[] inputList = input.split("\\s");
  try{
   for(String in : inputList){
    visitList.add(Integer.valueOf(in));
   }
  }
  catch(Exception e){
   System.out.println("输入的必须是数字,请重新开始！！！");
   System.exit(1);
  }
}

//运行
public static void running(){
  Iterator<Integer> it = visitList.listIterator();
  int thisPosition = 0;
  while(it.hasNext()){
   thisPosition = it.next();
   totalMoving += Math.abs(startPosition-thisPosition);
   startPosition = thisPosition;
   System.out.println("当前访问磁道号:"+thisPosition);
  }
}
public static void display(){
  System.out.println("平均寻道时间是:"+(double)totalMoving/visitList.size());
}
}


2.最短寻道时间优先
[java]
public class SSTF {

    /**
     *磁盘调度:最短寻道时间优先
     */
    private static int startPosition = 100 ;//磁头开始位置  
    private static int totalMoving = 0;
    private static List<Integer> visitList = new LinkedList<Integer>();//访问磁道列表  
    private static int size;
    public static void main(String[] args) {
        System.out.println("------磁盘调度:最短寻道时间优先算法模拟---------");
        input();
        running();
        display();

    }
    
    //接收用户输入列表  
    public static void input(){
        System.out.print("请输入磁道访问列表,以空格分开:");
        Scanner sc = new Scanner(System.in);
        String input = sc.nextLine();
        String[] inputList = input.split("\\s");
        try{
            for(String in : inputList){
                visitList.add(Integer.valueOf(in));
            }
            size = visitList.size();
        }
        catch(Exception e){
            System.out.println("输入的必须是数字,请重新开始！！！");
            System.exit(1);
        }
    }
    
    //运行  
    public static void running(){
        int visitNumber = 0;
        for(int i=0,size = visitList.size();i<size;i++){
            visitNumber = searchMinimum(startPosition);
            System.out.println("当前访问磁道:"+visitNumber);
        }
    }
    //寻找与当前磁头最近的磁道号  
    public static int searchMinimum(int startPosition){
        int min = Integer.MAX_VALUE,index = 0,i = 0,thisPosition = 0,computering=0;
        Iterator<Integer> it = visitList.iterator();
        while(it.hasNext()){
            int in = it.next();
            computering = Math.abs(startPosition-in);//判断是否小于最小值  
            if(min>computering){
                index = i;
                min = computering;
            }
            i++;
        }
        thisPosition = visitList.remove(index);//设置当前磁头，访问后移除  
        totalMoving += Math.abs(startPosition-thisPosition);
        
        SSTF.startPosition = thisPosition;
        
        return thisPosition;
    }
    public static void display(){
        System.out.println("平均寻道时间是:"+(double)totalMoving/size);
    }

}
public class SSTF {
/**
  *磁盘调度:最短寻道时间优先
  */
private static int startPosition = 100 ;//磁头开始位置
private static int totalMoving = 0;
private static List<Integer> visitList = new LinkedList<Integer>();//访问磁道列表
private static int size;
public static void main(String[] args) {
  System.out.println("------磁盘调度:最短寻道时间优先算法模拟---------");
  input();
  running();
  display();
}

//接收用户输入列表
public static void input(){
  System.out.print("请输入磁道访问列表,以空格分开:");
  Scanner sc = new Scanner(System.in);
  String input = sc.nextLine();
  String[] inputList = input.split("\\s");
  try{
   for(String in : inputList){
    visitList.add(Integer.valueOf(in));
   }
   size = visitList.size();
  }
  catch(Exception e){
   System.out.println("输入的必须是数字,请重新开始！！！");
   System.exit(1);
  }
}

//运行
public static void running(){
  int visitNumber = 0;
  for(int i=0,size = visitList.size();i<size;i++){
   visitNumber = searchMinimum(startPosition);
   System.out.println("当前访问磁道:"+visitNumber);
  }
}
//寻找与当前磁头最近的磁道号
public static int searchMinimum(int startPosition){
  int min = Integer.MAX_VALUE,index = 0,i = 0,thisPosition = 0,computering=0;
  Iterator<Integer> it = visitList.iterator();
  while(it.hasNext()){
   int in = it.next();
   computering = Math.abs(startPosition-in);//判断是否小于最小值
   if(min>computering){
    index = i;
    min = computering;
   }
   i++;
  }
  thisPosition = visitList.remove(index);//设置当前磁头，访问后移除
  totalMoving += Math.abs(startPosition-thisPosition);
  
  SSTF.startPosition = thisPosition;
  
  return thisPosition;
}
public static void display(){
  System.out.println("平均寻道时间是:"+(double)totalMoving/size);
}
}


3.SCAN算法
[java]
public class SCAN {

    /**
     * 磁盘调度can算法
     */
    private static int startPosition = 100 ;//磁头开始位置  
    private static int totalMoving = 0;
    private static List<Integer> visitList = new ArrayList<Integer>();//访问磁道列表  
    private static int moveDirection = 0;//0:向外移动,1:向里移动  
    private static int size;
    public static void main(String[] args) {
        System.out.println("------磁盘调度can算法模拟---------");
        input();
        running();
        display();
    }
    
    //接收用户输入列表  
    public static void input(){
        System.out.print("请输入磁道访问列表,以空格分开:");
        Scanner sc = new Scanner(System.in);
        String input = sc.nextLine();
        String[] inputList = input.split("\\s");
        try{
            for(String in : inputList){
                visitList.add(Integer.valueOf(in));
            }
            size = visitList.size();
        }
        catch(Exception e){
            System.out.println("输入的必须是数字,请重新开始！！！");
            System.exit(1);
        }
    }
    
    //运行  
    public static void running(){
        int visitNumber = 0;
        for(int i=0,size = visitList.size();i<size;i++){
            visitNumber = searchMinimum(startPosition);
            System.out.println("当前访问磁道:"+visitNumber);
        }
    }
    //寻找与当前磁头最近并且和磁头的移动方向一致的磁道号  
    public static int searchMinimum(int startPosition){
        int min = Integer.MAX_VALUE,index = -1,i = 0,thisPosition = 0,computing=0;
        Iterator<Integer> it = visitList.iterator();
        while(it.hasNext()){
            int in = it.next();
            computing = Math.abs(startPosition-in);
            if((min>computing);;(moveDirection==0);;(in>startPosition)){//向外移动  
                index = i;
                min = computing;
            }
            else if((min>computing);;(moveDirection==1);;(in<startPosition)){//向里移动  
                index = i;
                min = computing;
            }
            if((index == -1);;(moveDirection == 0)){//若移动到尽头,则返回扫描  
                moveDirection = 1;
            }
            else if((index == -1);;(moveDirection == 1)){
                moveDirection = 0;
            }
            i++;
        }
        thisPosition = visitList.remove(index);//设置当前磁头，访问后移除  
        totalMoving += Math.abs(startPosition-thisPosition);
        
        SCAN.startPosition = thisPosition;
        
        return thisPosition;
    }
    public static void display(){
        System.out.println("平均寻道时间是:"+(double)totalMoving/size);
    }

}
public class SCAN {
/**
  * 磁盘调度can算法
  */
private static int startPosition = 100 ;//磁头开始位置
private static int totalMoving = 0;
private static List<Integer> visitList = new ArrayList<Integer>();//访问磁道列表
private static int moveDirection = 0;//0:向外移动,1:向里移动
private static int size;
public static void main(String[] args) {
  System.out.println("------磁盘调度can算法模拟---------");
  input();
  running();
  display();
}

//接收用户输入列表
public static void input(){
  System.out.print("请输入磁道访问列表,以空格分开:");
  Scanner sc = new Scanner(System.in);
  String input = sc.nextLine();
  String[] inputList = input.split("\\s");
  try{
   for(String in : inputList){
    visitList.add(Integer.valueOf(in));
   }
   size = visitList.size();
  }
  catch(Exception e){
   System.out.println("输入的必须是数字,请重新开始！！！");
   System.exit(1);
  }
}

//运行
public static void running(){
  int visitNumber = 0;
  for(int i=0,size = visitList.size();i<size;i++){
   visitNumber = searchMinimum(startPosition);
   System.out.println("当前访问磁道:"+visitNumber);
  }
}
//寻找与当前磁头最近并且和磁头的移动方向一致的磁道号
public static int searchMinimum(int startPosition){
  int min = Integer.MAX_VALUE,index = -1,i = 0,thisPosition = 0,computing=0;
  Iterator<Integer> it = visitList.iterator();
  while(it.hasNext()){
   int in = it.next();
   computing = Math.abs(startPosition-in);
   if((min>computing);;(moveDirection==0);;(in>startPosition)){//向外移动
    index = i;
    min = computing;
   }
   else if((min>computing);;(moveDirection==1);;(in<startPosition)){//向里移动
    index = i;
    min = computing;
   }
   if((index == -1);;(moveDirection == 0)){//若移动到尽头,则返回扫描
    moveDirection = 1;
   }
   else if((index == -1);;(moveDirection == 1)){
    moveDirection = 0;
   }
   i++;
  }
  thisPosition = visitList.remove(index);//设置当前磁头，访问后移除
  totalMoving += Math.abs(startPosition-thisPosition);
  
  SCAN.startPosition = thisPosition;
  
  return thisPosition;
}
public static void display(){
  System.out.println("平均寻道时间是:"+(double)totalMoving/size);
}
}

作者：mzlqh