1+ /**
2+ * <h2>Shortest job first.</h2>
3+ * <p>Shortest job first (SJF) or shortest job next, is a scheduling policy
4+ * that selects the waiting process with the smallest execution time to execute next
5+ * Shortest Job first has the advantage of having minimum average waiting time among all scheduling algorithms.
6+ * It is a Greedy Algorithm.
7+ * It may cause starvation if shorter processes keep coming.
8+ * This problem has been solved using the concept of aging.</p>
9+ * @author shivg7706
10+ * @since 2018/10/27
11+ */
12+
13+ import java .util .Scanner ;
14+ import java .util .ArrayList ;
15+ import java .util .Comparator ;
16+ import java .util .*;
17+
18+ class Process {
19+
20+ public int pid ;
21+ public int arrivalTime ;
22+ public int burstTime ;
23+ public int priority ;
24+ public int turnAroundTime ;
25+ public int waitTime ;
26+ public int remainingTime ;
27+ }
28+
29+ class Schedule {
30+
31+ private int noOfProcess ;
32+ private int timer = 0 ;
33+ private ArrayList <Process > processes ;
34+ private ArrayList <Process > remainingProcess ;
35+ private ArrayList <Integer > gantChart ;
36+ private float burstAll ;
37+ private Map <Integer , ArrayList <Process >> arrivals ;
38+
39+ Schedule () {
40+ Scanner in = new Scanner (System .in );
41+
42+ processes = new ArrayList <Process >();
43+ remainingProcess = new ArrayList <Process >();
44+
45+ gantChart = new ArrayList <>();
46+ arrivals = new HashMap <>();
47+
48+ System .out .print ("Enter the no. of processes: " );
49+ noOfProcess = in .nextInt ();
50+ System .out .println ("Enter the arrival, burst and priority of processes" );
51+ for (int i = 0 ; i < noOfProcess ; i ++) {
52+ Process p = new Process ();
53+ p .pid = i ;
54+ p .arrivalTime = in .nextInt ();
55+ p .burstTime = in .nextInt ();
56+ p .priority = in .nextInt ();
57+ p .turnAroundTime = 0 ;
58+ p .waitTime = 0 ;
59+ p .remainingTime = p .burstTime ;
60+
61+ if (arrivals .get (p .arrivalTime ) == null ) {
62+ arrivals .put (p .arrivalTime , new ArrayList <Process >());
63+ }
64+ arrivals .get (p .arrivalTime ).add (p );
65+ processes .add (p );
66+ burstAll += p .burstTime ;
67+ }
68+
69+ }
70+
71+
72+ void startScheduling () {
73+
74+
75+ processes .sort (new Comparator <Process >() {
76+ @ Override
77+ public int compare (Process a , Process b ) {
78+ return a .arrivalTime - b .arrivalTime ;
79+ }
80+ });
81+
82+ while (!(arrivals .size () == 0 && remainingProcess .size () == 0 )) {
83+ removeFinishedProcess ();
84+ if (arrivals .get (timer ) != null ) {
85+ remainingProcess .addAll (arrivals .get (timer ));
86+ arrivals .remove (timer );
87+ }
88+
89+ remainingProcess .sort (new Comparator <Process >() {
90+ private int alpha = 6 ;
91+ private int beta = 1 ;
92+
93+ @ Override
94+ public int compare (Process a , Process b ) {
95+ int aRem = a .remainingTime ;
96+ int bRem = b .remainingTime ;
97+ int aprior = a .priority ;
98+ int bprior = b .priority ;
99+ return (alpha *aRem + beta *aprior ) - (alpha *bRem + beta *bprior );
100+ }
101+ });
102+
103+ int k = timeElapsed (timer );
104+ ageing (k );
105+ timer ++;
106+ }
107+
108+ System .out .println ("Total time required: " + (timer -1 ));
109+ }
110+
111+ void removeFinishedProcess () {
112+ ArrayList <Integer > completed = new ArrayList <Integer >();
113+ for (int i = 0 ; i < remainingProcess .size (); i ++) {
114+ if (remainingProcess .get (i ).remainingTime == 0 ) {
115+ completed .add (i );
116+ }
117+ }
118+
119+ for (int i = 0 ; i < completed .size (); i ++) {
120+ int pid = remainingProcess .get (completed .get (i )).pid ;
121+ processes .get (pid ).waitTime = remainingProcess .get (completed .get (i )).waitTime ;
122+ remainingProcess .remove (remainingProcess .get (completed .get (i )));
123+ }
124+
125+
126+ }
127+
128+ public int timeElapsed (int i ) {
129+ if (!remainingProcess .isEmpty ()) {
130+ gantChart .add (i , remainingProcess .get (0 ).pid );
131+ remainingProcess .get (0 ).remainingTime --;
132+ return 1 ;
133+ }
134+ return 0 ;
135+ }
136+
137+ public void ageing (int k ) {
138+ for (int i = k ; i < remainingProcess .size (); i ++) {
139+ remainingProcess .get (i ).waitTime ++;
140+ if (remainingProcess .get (i ).waitTime % 7 == 0 ) {
141+ remainingProcess .get (i ).priority --;
142+ }
143+ }
144+ }
145+
146+
147+ public void solve () {
148+ System .out .println ("Gant chart " );
149+ for (int i = 0 ; i < gantChart .size (); i ++) {
150+ System .out .print (gantChart .get (i ) + " " );
151+ }
152+ System .out .println ();
153+
154+ float waitTimeTot = 0 ;
155+ float tatTime = 0 ;
156+
157+ for (int i = 0 ; i < noOfProcess ; i ++) {
158+ processes .get (i ).turnAroundTime = processes .get (i ).waitTime + processes .get (i ).burstTime ;
159+
160+ waitTimeTot += processes .get (i ).waitTime ;
161+ tatTime += processes .get (i ).turnAroundTime ;
162+
163+ System .out .println ("Process no.: " + i + " Wait time: " + processes .get (i ).waitTime + " Turn Around Time: " + processes .get (i ).turnAroundTime );
164+ }
165+
166+ System .out .println ("Average Waiting Time: " + waitTimeTot /noOfProcess );
167+ System .out .println ("Average TAT Time: " + tatTime /noOfProcess );
168+ System .out .println ("Throughput: " + (float )noOfProcess /(timer - 1 ));
169+ }
170+
171+ }
172+
173+ public class SJF {
174+ public static void main (String [] args ) {
175+ Schedule s = new Schedule ();
176+ s .startScheduling ();
177+ s .solve ();
178+ }
179+ }
0 commit comments