時間片輪轉算法實現

一、實驗內容

編程實現時間片輪轉算法，並求出每個作業的完成時間、周轉時間、帶權周轉時間，及平均周轉時間、平均帶權周轉時間。

二、實驗要求

1. 任選一種高級語言實現；
2. 選擇1-2種調度算法；
3. 能夠輸入進程的基本信息，如進程名、提交時間、預估運行時間等；
4. 根據選擇的調度算法顯示進程調度順序；
5. 顯示完成調度后每個進程的開始時間、完成時間呢、周轉時間，帶權周轉時間；
6. 計算平均周轉時間和平均帶權周轉時間；

三、實驗過程

1、 設計思想

系統將所有的就緒進程按FCFS策略排成一個就緒隊列。系統可設置每隔一定時間(如30ms)便產生一次中斷，去激活進程調度程序進行調度，把CPU分配給隊首進程，並令其執行一個時間片。當它運行完畢后，將進程管道就緒隊列的隊尾，再把處理機分配給就緒隊列中新的隊首進程，也讓它執行一個時間片，以此類推。這樣，就可以保證就緒隊列中的所有進程在確定的時間段內，都能獲得一個時間片的處理機時間。

將進程按FCFS排成一個隊列，每次調度取隊首進程分配CPU，時間片到，將PCB掛到就緒隊尾。

在時間片輪轉調度算法中，應在何時進行進程的切換，可分為兩種情況：

① 若一個時間片尚未用完，正在運行的進程便已經完成，就立即激活調度程序，將它從就緒隊列中刪除，再調度就緒隊列中隊首的進程運行，並啟動一個新的時間片。

② 在一個時間片用完時，計時器中斷處理程序被激活。如果進程尚未運行完畢，調度程序將把它送往就緒隊列的末尾。

2.運行結果

四、實驗代碼

public class Thread {
    int id;//進程ID
    int arrivetime;//到達時間
    int runtime;//運行時間
    int rmaintime;//剩余運行時間
    int endtime;//完成時間
    int turnovertime;//周轉時間
    float qturnovertime;//帶權周轉時間

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getArrivetime() {
        return arrivetime;
    }

    public void setArrivetime(int arrivetime) {
        this.arrivetime = arrivetime;
    }

    public int getRuntime() {
        return runtime;
    }

    public void setRuntime(int runtime) {
        this.runtime = runtime;
    }

    public int getRmaintime() {
        return rmaintime;
    }

    public void setRmaintime(int rmaintime) {
        this.rmaintime = rmaintime;
    }

    public int getEndtime() {
        return endtime;
    }

    public void setEndtime(int endtime) {
        this.endtime = endtime;
    }

    public int getTurnovertime() {
        return turnovertime;
    }

    public void setTurnovertime(int turnovertime) {
        this.turnovertime = turnovertime;
    }

    public float getQturnovertime() {
        return qturnovertime;
    }

    public void setQturnovertime(float qturnovertime) {
        this.qturnovertime = qturnovertime;
    }

    public Thread() {
        id=0;
        arrivetime=0;//到達時間
         runtime=0;//運行時間
         rmaintime=0;//剩余運行時間
         endtime=0;//完成時間
         turnovertime=0;//周轉時間
         qturnovertime=0;//帶權周轉時間
    }

    public Thread(int id, int arrivetime, int runtime,int rmaintime) {
        this.id = id;
        this.arrivetime = arrivetime;
        this.runtime = runtime;
        this.rmaintime=rmaintime;
    }

    @Override
    public String toString() {
        return "Thread{" +
                "id=" + id +
                ", arrivetime=" + arrivetime +
                ", runtime=" + runtime +
                ", rmaintime=" + rmaintime +
                '}';
    }


}






package com.hu;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.Random;

public class Test {

    static final int slicetime=2;//時間片大小設為2

    public static void main(String[] args) {

        RR(InitQueue(SortThread(InitThread())));

    }

    public static void RR(LinkedList queue){

        int i=0;
        int count=0;
        for (Iterator iter = queue.iterator(); iter.hasNext();){

            System.out.println();
            Thread thread =(Thread) queue.getFirst();       
            System.out.println(thread);

                if (thread.rmaintime<=slicetime){
                    count=count+thread.rmaintime;//當前時間
                    thread.endtime=count;//結束時間
                    thread.turnovertime= thread.endtime-thread.arrivetime;//周轉時間
                    thread.qturnovertime=(float)thread.turnovertime/thread.runtime;//帶權周轉時間
                    thread.rmaintime=0;

                    System.out.println(thread.getId()+"號進程結束"+"結束時間："+thread.endtime+"周轉時間："+thread.turnovertime+"帶權周轉時間："+thread.qturnovertime);
                    queue.remove();
                }else {
                    count=count+2;//當前時間
                    thread.rmaintime=thread.rmaintime-slicetime;//執行進程
                    queue.remove();
                    queue.offer(thread);//時間片完插入隊尾
                }
                

        }
    }

    public static Thread[] InitThread(){//初始化進程到達時間與運行時間

        Thread[] thread = new Thread[5];

        for (int i=0;i<thread.length;i++){
            Random random = new Random();
            int t= random.nextInt(10)+1;
            thread[i] = new Thread(i,random.nextInt(10)+1,t,t);
        }

        return thread;
    }

    public static Thread[] SortThread(Thread[] threads) {//進程排序

        for (int i = 0; i < threads.length; i++) {
            for (int j = 0; j < threads.length - 1; j++) {

                if (threads[j].arrivetime > threads[j + 1].arrivetime) {//如果進程到達時間不相等按進程的到達時間從小到大排序
                    Thread t;
                    t = threads[j];
                    threads[j] = threads[j + 1];
                    threads[j + 1] = t;
                }
                if (threads[j].arrivetime == threads[j + 1].arrivetime) {//如果進程到達時間相等按進程的運行時間從小到大排序
                    if (threads[j].runtime > threads[j + 1].runtime) {
                        Thread t;
                        t = threads[j];
                        threads[j] = threads[j + 1];
                        threads[j + 1] = t;
                    }

                }

            }

        }
        return threads;
    }
    public static LinkedList InitQueue(Thread[] threads){//初始化隊列

        LinkedList<Thread> queue = new LinkedList<Thread>();

        for (int i=0;i< threads.length;i++){
            queue.offer(threads[i]);
        }

        return queue;
    }


}