운영 체제 프로 세 스 스케줄 링 알고리즘 (자바 구현)

FCFS (First Come First Server, 먼저 서비스)
이것 은 가장 간단 하고 기본 적 인 알고리즘 입 니 다. 그의 사상 은 매우 간단 합 니 다. 바로 프로 세 스 가 도착 하 는 시간 순서에 따라 CPU 자원 의 장점 을 하나씩 분배 하 는 것 입 니 다. 간단 하고 편리 한 단점: 효율 이 낮 으 며 자원 의 이 용 률 이 낮 습 니 다.

/**
  * CPU     
  * 1:   
  * 0:     
  */
 static int CPU = 1;
 /**
  *       
  */
 static final int MAXLEN = 10;

 /**
  *        
  * @param processes
  */
 public static void FCFS(List processes){
     int count = processes.size();
     int time = 0;
     int[] waitQueue = new int[MAXLEN];
     int front = 0;int tail = 0;
     int running = 0;
     System.out.println("-------------FCFS  -------------");
     if (count <= 0){
         System.out.println("     ");
         return;
     }

     while (count > 0){
         System.out.print("  " + time + "  : ");
         for (int i = 0; i < processes.size(); i++){
             if (processes.get(i).isAlive() && processes.get(i).getInTime() == time){
                 System.out.print("   " + i + "    ");
                 waitQueue[tail] = i;
                 tail = (tail+1) % MAXLEN;
             }
             if (processes.get(running).isAlive() && processes.get(running).getCount() == 0){
                 System.out.print("   " + running + "      ");
                 processes.get(running).setAlive(false);
                 processes.get(running).setEndTime(time);
                 count--;
                 CPU = 1;
             }
         }
         if (CPU == 1 && front != tail){
             running = waitQueue[front];
             front = (front+1) % MAXLEN;
             System.out.print("   " + running + "     ");
             int temp = processes.get(running).getCount();
             temp--;
             processes.get(running).setCount(temp);
             CPU = 0;
         } else if (CPU == 0){
             int temp = processes.get(running).getCount();
             temp--;
             processes.get(running).setCount(temp);
         }
         time++;
         System.out.println();
     }
     System.out.println("---------------------------------");
     ShowResult(processes);
 }

SJF (짧 은 작업 우선, 짧 은 작업 우선)
프로 세 스 가 예상 하 는 운행 시간 에 따라 어 릴 때 부터 자원 의 장점 을 분배 합 니 다. 간단 한 프로 세 스 실행 속도 가 빠 른 단점: 운행 시간 을 정확하게 예측 할 수 없고 성장 프로 세 스 의 배 고 픔 을 만 들 기 쉽 습 니 다.

/**
 *        
 *     FCFS        waitQueue             
 */

//    
...

for (int i = 0; i < processes.size(); i++){
    if (processes.get(i).isAlive() && processes.get(i).getInTime() == time){
        System.out.print("   " + i + "    ");
        waitQueue[tail] = i;
        tail = (tail+1) % MAXLEN;
        length++;
        /**
         *                    
         */
        for (int x=front, z=0; z < length; x=(x+1)%MAXLEN, z++){
            for (int y=x+1, q=0; q < length-x; y=(y+1)%MAXLEN, q++){
                if (processes.get(waitQueue[x]).getCount() > processes.get(waitQueue[y]).getCount()){
                    int t = waitQueue[x];
                    waitQueue[x] = waitQueue[y];
                    waitQueue[y] = t;
                }
            }
        }
    }

...

PSA (우선 순위 스케줄 링)
프로 세 스 의 우선 순위 에 따라 스케줄 링 순 서 를 선택 하 십시오.

/**
 *        
 *     SJF       ，         
 */

/**
 *     
 *                   
 */
for (int x=front, z=0; z < length; x=(x+1)%MAXLEN, z++){
    for (int y=x+1, q=0; q < length-x; y=(y+1)%MAXLEN, q++){
        if (processes.get(waitQueue[x]).getPriority() > processes.get(waitQueue[y]).getPriority()){
            int t = waitQueue[x];
            waitQueue[x] = waitQueue[y];
            waitQueue[y] = t;
        }
    }
}

RR (타임 시트 윤전 알고리즘)
CPU 실행 을 위 한 시간 대 크기 를 설정 합 니 다. 모든 프로 세 스 가 시간 대 를 문의 하고 시간 대가 끝 난 후에 실행 을 중단 하고 대기 열 에 가입 합 니 다.

  /**
   *        
   * @param processes
   * @param round
   */
  public static void RR(List processes, int round){
      int count = processes.size();
      int time = 0;
      int[] waitQueue = new int[MAXLEN];
      int front = 0;int tail = 0;
      int running = 0;
      System.out.println("------------- RR   -------------");
      if (count <= 0){
          System.out.println("     ");
          return;
      }

      while (count > 0){
          System.out.print("  " + time + "  : ");
          for (int i = 0; i < processes.size(); i++){
              if (processes.get(i).isAlive() && processes.get(i).getInTime() == time){
                  System.out.print("   " + i + "    ");
                  waitQueue[tail] = i;
                  tail = (tail+1) % MAXLEN;
              }
              if (processes.get(running).isAlive() && processes.get(running).getCount() == 0){
                  System.out.print("   " + running + "      ");
                  processes.get(running).setAlive(false);
                  processes.get(running).setEndTime(time);
                  count--;
                  CPU = 1;
              }
          }
          if (CPU == 1 && front != tail){
              running = waitQueue[front];
              front = (front+1) % MAXLEN;
              System.out.print("   " + running + "     ");
              int temp = processes.get(running).getCount();
              temp--;
              processes.get(running).setCount(temp);
              CPU = 0;
          } else if (CPU == 0){
              int temp = processes.get(running).getCount();
              temp--;
              processes.get(running).setCount(temp);
              if (time % round == 0){
                  System.out.print("   " + running + "     ");
                  waitQueue[tail] = running;
                  tail = (tail+1) % MAXLEN;
                  CPU = 1;
              }
          }
          time++;
          System.out.println();
      }
      System.out.println("---------------------------------");
      ShowResult(processes);
  }

알고리즘 실행 결과 표시

    /**
     *         
     * @param processes
     */
    public static void ShowResult(List processes){
        int averageTime = 0;
        for (int i = 0; i < processes.size(); i++){
            int inTime = processes.get(i).getInTime();
            int endTime = processes.get(i).getEndTime();
            averageTime += endTime-inTime;
            System.out.println("   " + i + " :     : " +
                    inTime + "     : " +
                    endTime + "     : " +
                    (endTime-inTime));
        }
        System.out.println("      : " + averageTime / processes.size());
        System.out.println("---------------END--------------");
    }