Short Job First

Contoh source code proses computer :

import java.util.Random;

public class ShortestJobFirst {               
    static class Process {
        public int arrivalTime;
        public int startTime;
        public int burstTime;
        public Process(int t) { burstTime=t; }
    }
    static class Queue {
        class QueueNode {
            Process  key;
            QueueNode next = null;
            QueueNode(Process p, QueueNode n) { key=p; next=n; }
            QueueNode(Process p) { key=p; }
        }
        QueueNode tail;
        public  Queue() {
            tail = null;
        }
        public  boolean  isEmpty() {
            return tail==null;
        }
        public  void  enqueue(Process x, float burstTime) {
            if ( tail==null ) {
                tail = new QueueNode(x); tail.next=tail;
            }
            else tail = (tail.next = new QueueNode(x,tail.next));
        }
        public Process dequeue() {
            if ( tail==null ) return null;
            else {  QueueNode p = tail.next;
            if ( p!=tail ) tail.next = p.next;
            else tail = null;
            return  p.key;
            }
        }
    }

    public static void main(String[]  args) {
        int  T = 0;                     
        int  N = 0;                     
        int  NumProcesses =  100;        
        int  QueuedProcesses = 0;        
        int  totalProcessDuration = 0;
        int totalTurnaroundTime = 0;     
        Process  activeProcess = null;
        int  lastProcessArrival = 0;   
        Random rand0 = new Random();    
        Random rand1 = new Random();    
        Random rand2 = new Random();    
        Queue q = new Queue();
       

        while ( N < NumProcesses ) {
            int newProcessArrival = rand0.nextInt(1801); 
            do {
                u = 1.-rand1.nextDouble();
                v = 1.-rand2.nextDouble();
                x = Math.sqrt (-2.*Math.log(u))*Math.cos(2.*Math.PI*v) + 2.0;  /
            } while ( x<0 );
            int newProcessDuration = (int) Math.round (x*1000); 
            // Create the process p
            Process p = new Process(newProcessDuration);
            lastProcessArrival += newProcessArrival;
            if ( lastProcessArrival < T ) lastProcessArrival = T;
            p.arrivalTime = lastProcessArrival;
           
            // If the active process has finished, start the next one
            if ( activeProcess == null ) {
                activeProcess = p;
                T = p.startTime = p.arrivalTime;
            }
            // Otherwise, put the process in the queue
            else {  q.enqueue(p, p.burstTime);   QueuedProcesses++; }
            do { // this terminates processes
                if ( T + activeProcess.burstTime > lastProcessArrival ) break;
                totalProcessDuration += activeProcess.burstTime;
                T += activeProcess.burstTime;
                int  turnaroundTime = T - activeProcess.arrivalTime;
                totalTurnaroundTime  +=  turnaroundTime;
                System.out.printf ("Process %d terminated. Turnaround time: %.2f milliseconds.\n",
                        ++N, (double) turnaroundTime/1000);
                System.out.printf (" \t(arrival %.2f,  begin %.2f,  end %.2f,  duration %.2f)\n",
                        (double) activeProcess.arrivalTime/1000, (double) activeProcess.startTime/1000,
                        (double) (activeProcess.startTime+activeProcess.burstTime)/1000,
                        (double) activeProcess.burstTime/1000);
                // If terminated processes >= to max processes, break;
                if ( N >= NumProcesses ) break;
                if ( q.isEmpty( ) ) {  activeProcess = null;   break; }
                // Otherwise, dequeue the active process and start the next one
                else {
                    activeProcess = q.dequeue( );  QueuedProcesses--;
                    if ( activeProcess.arrivalTime <= T ) activeProcess.startTime = T;
                    else activeProcess.startTime = T = activeProcess.arrivalTime;
                }
            } while(true);
        }   //  end while loop

        // Print the results
        System.out.printf ("\nSimulation time: %.2f milliseconds\n", (double) T/1000);
        System.out.printf ("Average turnaround time: %.2f milliseconds\n",
                (double) totalTurnaroundTime/NumProcesses/1000);
        System.out.printf ("Average process duration: %.2f milliseconds\n",
                (double) totalProcessDuration/NumProcesses/1000);
        System.out.printf ("Throughput: %.2f processes per second\n", (double) NumProcesses/T * 1000000);
        System.out.println ("Processes in the queue at the end of the simulation: "  + QueuedProcesses);
    }   //  end main
}





Gambar hasil output proses :