Versiunea preventivă a programării Shortest Job First (SJF) se numește Shortest Remaining Time First (SRTF). În SRTF, procesul cu cel mai mic timp rămas până la finalizare este selectat pentru a rula. Procesul de rulare continuă până când se termină sau sosește un nou proces cu un timp rămas mai scurt, asigurând că cel mai rapid proces de finisare are întotdeauna prioritate.

Exemplu de algoritm SJF:

Scenariul 1: procese cu aceeași oră de sosire

Exemplu: Luați în considerare următorul tabel cu timpul de sosire și timpul de explozie pentru trei procese P1 P2 și P3 .

Execuție pas cu pas:

1. Timp 0-5 (P3) : P3 rulează timp de 5 ms (timp total rămas: 0 ms), deoarece mai are cel mai scurt timp rămas.
2. Timp 5-11 (P1) : P1 rulează timp de 6 ms (timp total rămas: 0 ms), deoarece mai are cel mai scurt timp rămas.
3. Ora 11-19 (P2) : P2 rulează timp de 8 ms (timp total rămas: 0 ms), deoarece mai are cel mai scurt timp rămas.

Diagrama Gantt:

care este diferența dintre un megaoctet și un gigaoctet

Acum să calculăm media timp de așteptare și întoarce-te timp:

După cum știm

• Întoarceți-vă timpul = Timp de finalizare - ora de sosire
• Timp de așteptare = Timpul de întoarcere - timpul de explozie

Acum 

• Timp mediu de întoarcere = (11 + 19 + 5)/3 = 11,6 ms
• Timp mediu de așteptare = (5 + 0 + 11 )/3 = 16/3 = 5,33 ms

Scenariul 2: procese cu ore de sosire diferite

Luați în considerare următorul tabel al timpului de sosire și al timpului de explozie pentru trei procese P1 P2 și P3.

Execuție pas cu pas:

1. Timp 0-1 (P1) : P1 rulează timp de 1 ms (timp total rămas: 5 ms), deoarece mai are cel mai scurt timp rămas.
2. Timp 1-4 (P2) : P2 rulează timp de 3 ms (timp total rămas: 0 ms), deoarece are cel mai scurt timp rămas dintre P1 și P2.
3. Timp 4-9 (P1) : P1 rulează timp de 5 ms (timp total rămas: 0 ms), deoarece are cel mai scurt timp rămas dintre P1 și P3.
4. Ora 9-16 (P3) : P3 rulează timp de 7 ms (timp total rămas: 0 ms), deoarece mai are cel mai scurt timp rămas.

Diagrama Gantt:

matrice de latex

Acum să calculăm media timp de așteptare și întoarce-te timp:

• Timp mediu de întoarcere = (9 + 14 + 3)/3 = 8,6 ms
• Timp mediu de așteptare = (3 + 0 + 7 )/3 = 10/3 = 3,33 ms

Implementarea algoritmului SRTF

Pasul 1: Introduceți numărul de procese cu ora de sosire și timpul de explozie.
Pasul 2: Inițializați timpii rămasi (timpi de explozie) timpul curent = 0 și contoarele.
Pasul 3: La fiecare moment, unitatea adaugă procese care au ajuns în coada gata.
Pasul 4: Selectați procesul cu cel mai scurt timp rămas (preempționați dacă sosește unul mai scurt).
Pasul 5: Executați procesul selectat pentru 1 unitate, reduceți timpul rămas și creșteți timpul curent.
Pasul 6: Dacă un proces se încheie:

• Timp de finalizare = Timp de finalizare − Ora de sosire
• Timp de așteptare = Timp de răspuns − Timp de explozie

Pasul 7: Repetați pașii 3-6 până la finalizarea tuturor proceselor.
Pasul 8: Calculați timpul mediu de așteptare și timpul de răspuns.
Pasul 9: Afișați timpii de așteptare și de finalizare pentru fiecare proces împreună cu mediile.

Implementarea codului

Programul de implementare a celui mai scurt timp rămas mai întâi este următorul:

#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 

Avantajele SRTF Programare

1. Minimizează timpul mediu de așteptare : SRTF reduce timpul mediu de așteptare prin prioritizarea proceselor cu cel mai scurt timp de execuție rămas.
2. Eficient pentru procese scurte : Procesele mai scurte sunt finalizate mai rapid, îmbunătățind capacitatea generală de răspuns a sistemului.
3. Ideal pentru sisteme critice de timp : Se asigură că procesele sensibile la timp sunt executate rapid.

Dezavantajele SRTF Programare

1. Înfometarea proceselor lungi : Procesele mai lungi pot fi amânate pe termen nelimitat dacă procesele mai scurte continuă să sosească.
2. Este dificil de prezis orele de explozie : Predicția precisă a timpilor de explozie a procesului este o provocare și afectează deciziile de programare.
3. Înalt deasupra capului : Comutarea frecventă a contextului poate crește supraîncărcarea și poate încetini performanța sistemului.
4. Nu este potrivit pentru sistemele în timp real : Sarcinile în timp real pot suferi întârzieri din cauza preempțiilor frecvente.