De preventieve versie van de Shortest Job First (SJF)-planning wordt Shortest Remaining Time First (SRTF) genoemd. In SRTF wordt het proces met de minste resterende tijd om te voltooien geselecteerd om te worden uitgevoerd. Het lopende proces gaat door totdat het klaar is of er een nieuw proces met een kortere resterende tijd arriveert, zodat het snelste afwerkingsproces altijd prioriteit krijgt.

Voorbeeld van SJF-algoritme:

Scenario 1: Processen met dezelfde aankomsttijd

Voorbeeld: Beschouw de volgende tabel met aankomsttijden en burst-tijden voor drie processen P1, P2 en P3 .

Stapsgewijze uitvoering:

1. Tijd 0-5 (P3) : P3 duurt 5 ms (totale resterende tijd: 0 ms) omdat er nog de kortste resterende tijd over is.
2. Tijd 5-11 (P1) : P1 duurt 6 ms (totale resterende tijd: 0 ms) omdat er nog de kortste resterende tijd over is.
3. Tijd 11-19 (P2) : P2 duurt 8 ms (totale resterende tijd: 0 ms) omdat er nog de kortste resterende tijd over is.

Gantt-diagram:

hoe verborgen apps op te halen

Laten we nu het gemiddelde berekenen wachttijd en draai je om tijd:

Zoals wij weten

• Draai rond tijd = Voltooiingstijd - aankomsttijd
• Wachttijd = Draaitijd - burst-tijd

Nu 

palindroom nummer

• Gemiddelde doorlooptijd = (11 + 19 + 5)/3 = 11,6 ms
• Gemiddelde wachttijd = (5 + 0 + 11)/3 = 16/3 = 5,33 ms

Scenario 2: Processen met verschillende aankomsttijden

Beschouw de volgende tabel met aankomsttijden en burst-tijden voor drie processen P1, P2 en P3.

Stapsgewijze uitvoering:

1. Tijd 0-1 (P1) : P1 duurt 1 ms (totale resterende tijd: 5 ms) omdat er nog de kortste resterende tijd over is.
2. Tijd 1-4 (P2) : P2 duurt 3 ms (totale resterende tijd: 0 ms) omdat er de kortste resterende tijd overblijft tussen P1 en P2.
3. Tijd 4-9 (P1) : P1 duurt 5 ms (totale resterende tijd: 0 ms) omdat er de kortste resterende tijd overblijft tussen P1 en P3.
4. Tijd 9-16 (P3) : P3 duurt 7 ms (totale resterende tijd: 0 ms) omdat er nog de kortste resterende tijd over is.

Gantt-diagram:

Laten we nu het gemiddelde berekenen wachttijd en draai je om tijd:

• Gemiddelde doorlooptijd = (9 + 14 + 3)/3 = 8,6 ms
• Gemiddelde wachttijd = (3 + 0 + 7)/3 = 10/3 = 3,33 ms

Implementatie van SRTF-algoritme

Stap 1: Voer het aantal processen in met aankomsttijd en burst-tijd.
Stap 2: Initialiseer resterende tijden (bursttijden) huidige tijd = 0 en tellers.
Stap 3: Voeg bij elke tijdseenheid processen toe die in de gereedstaande wachtrij zijn aangekomen.
Stap 4: Selecteer het proces met de kortste resterende tijd (voorrang als er een kortere arriveert).
Stap 5: Voer het geselecteerde proces uit voor 1 eenheid, verminder de resterende tijd en verhoog de huidige tijd.
Stap 6: Als een proces is voltooid:

• Doorlooptijd = Voltooiingstijd − Aankomsttijd
• Wachttijd = Doorlooptijd − Bursttijd

Stap 7: Herhaal stap 3 t/m 6 totdat alle processen zijn voltooid.
Stap 8: Bereken de gemiddelde wachttijd en doorlooptijd.
Stap 9: Geef de wacht- en doorlooptijden voor voltooiing weer voor elk proces, samen met gemiddelden.

Code-implementatie

Het programma om Shortest Remaining Time First te implementeren is als volgt:

#include    #include  #include    using namespace std; struct Process {  int id arrivalTime burstTime remainingTime waitingTime turnaroundTime completionTime; }; int main() {  int n currentTime = 0 completed = 0;  cout << 'Enter number of processes: ';  cin >> n;  vector<Process> p(n);    for (int i = 0; i < n; i++) {  p[i].id = i + 1;  cin >> p[i].arrivalTime >> p[i].burstTime;  p[i].remainingTime = p[i].burstTime;  }  while (completed < n) {  int idx = -1;  for (int i = 0; i < n; i++) {  if (p[i].arrivalTime <= currentTime && p[i].remainingTime > 0 && (idx == -1 || p[i].remainingTime < p[idx].remainingTime)) {  idx = i;  }  }  if (idx != -1) {  p[idx].remainingTime--;  currentTime++;  if (p[idx].remainingTime == 0) {  p[idx].completionTime = currentTime;  p[idx].turnaroundTime = currentTime - p[idx].arrivalTime;  p[idx].waitingTime = p[idx].turnaroundTime - p[idx].burstTime;  completed++;  }  } else {  currentTime++;  }  }  double totalWT = 0 totalTAT = 0;  for (auto &proc : p) {  totalWT += proc.waitingTime;  totalTAT += proc.turnaroundTime;  cout << 'P' << proc.id << ' CT: ' << proc.completionTime << ' WT: ' << proc.waitingTime << ' TAT: ' << proc.turnaroundTime << endl;  }  cout << 'Avg WT: ' << totalWT / n << ' Avg TAT: ' << totalTAT / n << endl; } 

import java.util.*; class Process {  int id arrivalTime burstTime remainingTime waitingTime turnaroundTime completionTime;  public Process(int id int arrivalTime int burstTime) {  this.id = id;  this.arrivalTime = arrivalTime;  this.burstTime = burstTime;  this.remainingTime = burstTime;  } } public class SRTF {  public static void main(String[] args) {  Scanner sc = new Scanner(System.in);  int n = sc.nextInt();  Process[] processes = new Process[n];    for (int i = 0; i < n; i++) {  int arrivalTime = sc.nextInt() burstTime = sc.nextInt();  processes[i] = new Process(i + 1 arrivalTime burstTime);  }  Arrays.sort(processes Comparator.comparingInt(p -> p.arrivalTime));  int currentTime = 0 completed = 0;  while (completed < n) {  int idx = -1;  for (int i = 0; i < n; i++) {  if (processes[i].arrivalTime <= currentTime && processes[i].remainingTime > 0 && (idx == -1 || processes[i].remainingTime < processes[idx].remainingTime)) {  idx = i;  }  }  if (idx != -1) {  processes[idx].remainingTime--;  currentTime++;  if (processes[idx].remainingTime == 0) {  processes[idx].completionTime = currentTime;  processes[idx].turnaroundTime = currentTime - processes[idx].arrivalTime;  processes[idx].waitingTime = processes[idx].turnaroundTime - processes[idx].burstTime;  completed++;  }  } else {  currentTime++;  }  }  double totalWT = 0 totalTAT = 0;  for (Process p : processes) {  totalWT += p.waitingTime;  totalTAT += p.turnaroundTime;  System.out.println('P' + p.id + ' CT: ' + p.completionTime + ' WT: ' + p.waitingTime + ' TAT: ' + p.turnaroundTime);  }  System.out.println('Avg WT: ' + totalWT / n + ' Avg TAT: ' + totalTAT / n);  } } 

class Process: def __init__(self id arrival_time burst_time): self.id = id self.arrival_time = arrival_time self.burst_time = burst_time self.remaining_time = burst_time def srtf(processes): current_time completed = 0 0 while completed < len(processes): idx = -1 for i p in enumerate(processes): if p.arrival_time <= current_time and p.remaining_time > 0 and (idx == -1 or p.remaining_time < processes[idx].remaining_time): idx = i if idx != -1: processes[idx].remaining_time -= 1 current_time += 1 if processes[idx].remaining_time == 0: processes[idx].completion_time = current_time processes[idx].turnaround_time = current_time - processes[idx].arrival_time processes[idx].waiting_time = processes[idx].turnaround_time - processes[idx].burst_time completed += 1 else: current_time += 1 def print_results(processes): total_wt total_tat = 0 0 for p in processes: total_wt += p.waiting_time total_tat += p.turnaround_time print(f'P{p.id} CT: {p.completion_time} WT: {p.waiting_time} TAT: {p.turnaround_time}') print(f'Avg WT: {total_wt / len(processes)} Avg TAT: {total_tat / len(processes)}') n = int(input('Enter number of processes: ')) processes = [Process(i + 1 *map(int input(f'Enter arrival and burst time for P{i + 1}: ').split())) for i in range(n)] srtf(processes) print_results(processes) 

Enter number of processes: Avg WT: -nan Avg TAT: -nan 

Voordelen van SRTF Planning

1. Minimaliseert de gemiddelde wachttijd : SRTF vermindert de gemiddelde wachttijd door prioriteit te geven aan processen met de kortst resterende uitvoeringstijd.
2. Efficiënt voor korte processen : Kortere processen worden sneller voltooid, waardoor de algehele reactiesnelheid van het systeem verbetert.
3. Ideaal voor tijdkritische systemen : Het zorgt ervoor dat tijdgevoelige processen snel worden uitgevoerd.

Nadelen van SRTF Planning

1. Uithongering van lange processen : Langere processen kunnen voor onbepaalde tijd worden uitgesteld als er steeds kortere processen binnenkomen.
2. Moeilijk om burst-tijden te voorspellen : Nauwkeurige voorspelling van procesbursttijden is een uitdaging en beïnvloedt planningsbeslissingen.
3. Hoge overheadkosten : Regelmatig wisselen van context kan de overhead vergroten en de systeemprestaties vertragen.
4. Niet geschikt voor realtime systemen : Real-time taken kunnen vertraging oplopen als gevolg van frequente preemptions.