La versión preventiva de la programación del trabajo más corto primero (SJF) se llama tiempo restante más corto primero (SRTF). En SRTF se selecciona para ejecutar el proceso al que le queda menos tiempo para finalizar. El proceso en ejecución continúa hasta que finaliza o llega un nuevo proceso con un tiempo restante más corto, lo que garantiza que el proceso de finalización más rápido siempre tenga prioridad.

Ejemplo de algoritmo SJF:

Escenario 1: Procesos con Misma Hora de Llegada

Ejemplo: Considere la siguiente tabla de tiempo de llegada y tiempo de ráfaga para tres procesos. P1 P2 y P3 .

Ejecución paso a paso:

1. Tiempo 0-5 (P3) : P3 se ejecuta durante 5 ms (tiempo total restante: 0 ms) ya que le queda el menor tiempo restante.
2. Hora 5-11 (P1) : P1 funciona durante 6 ms (tiempo total restante: 0 ms) ya que le queda el menor tiempo restante.
3. Hora 11-19 (P2) : P2 se ejecuta durante 8 ms (tiempo total restante: 0 ms), ya que le queda el menor tiempo restante.

Diagrama de Gantt:

cuantas peliculas de mision imposible hay

Ahora calculemos el promedio tiempo de espera y vuelta tiempo:

Como sabemos

• Tiempo de vuelta = Hora de finalización - hora de llegada
• Tiempo de espera = Tiempo de vuelta - tiempo de ráfaga

Ahora 

• Tiempo promedio de respuesta = (11 + 19 + 5)/3 = 11,6ms
• tiempo promedio de espera = (5 + 0 + 11 )/3 = 16/3 = 5,33 ms

Escenario 2: Procesos con diferentes tiempos de llegada

Considere la siguiente tabla de tiempo de llegada y tiempo de ráfaga para tres procesos P1, P2 y P3.

trimestre en el negocio

Ejecución paso a paso:

1. Tiempo 0-1 (P1) : P1 se ejecuta durante 1 ms (tiempo total restante: 5 ms) ya que le queda el menor tiempo restante.
2. Tiempo 1-4 (P2) : P2 funciona durante 3 ms (tiempo total restante: 0 ms) ya que le queda el menor tiempo restante entre P1 y P2.
3. Tiempo 4-9 (P1) : P1 funciona durante 5 ms (tiempo total restante: 0 ms), ya que le queda el tiempo restante más corto entre P1 y P3.
4. Hora 9-16 (P3) : P3 se ejecuta durante 7 ms (tiempo total restante: 0 ms) ya que le queda el menor tiempo restante.

Diagrama de Gantt:

Ahora calculemos el promedio tiempo de espera y vuelta tiempo:

• Tiempo promedio de respuesta = (9 + 14 + 3)/3 = 8,6 ms
• tiempo promedio de espera = (3 + 0 + 7 )/3 = 10/3 = 3,33 ms

Implementación del algoritmo SRTF

Paso 1: Ingrese el número de procesos con tiempo de llegada y tiempo de ráfaga.
Paso 2: Inicialice los tiempos restantes (tiempos de ráfaga), tiempo actual = 0 y contadores.
Paso 3: En cada momento, la unidad agrega procesos que han llegado a la cola lista.
Paso 4: Seleccione el proceso con el tiempo restante más corto (prevenga si llega uno más corto).
Paso 5: Ejecute el proceso seleccionado para 1 unidad, reduzca el tiempo restante e incremente el tiempo actual.
Paso 6: Si un proceso se completa:

• Tiempo de respuesta = Tiempo de finalización − Hora de llegada
• Tiempo de espera = Tiempo de respuesta − Tiempo de ráfaga

Paso 7: Repita los pasos 3 a 6 hasta que se completen todos los procesos.
Paso 8: Calcule el tiempo promedio de espera y el tiempo de respuesta.
Paso 9: Muestre los tiempos de espera y respuesta de finalización de cada proceso junto con los promedios.

Implementación de código

El programa para implementar el tiempo restante más corto primero es el siguiente:

#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 

Ventajas de SRTF Programación

1. Minimiza el tiempo promedio de espera : SRTF reduce el tiempo de espera promedio al priorizar los procesos con el tiempo de ejecución restante más corto.
2. Eficiente para procesos cortos : Los procesos más cortos se completan más rápido, mejorando la capacidad de respuesta general del sistema.
3. Ideal para sistemas en los que el tiempo es crítico : Garantiza que los procesos urgentes se ejecuten rápidamente.

Desventajas del SRTF Programación

1. Inanición de procesos largos : Los procesos más largos pueden retrasarse indefinidamente si siguen llegando procesos más cortos.
2. Difícil predecir los tiempos de ráfaga : La predicción precisa de los tiempos de ráfaga del proceso es un desafío y afecta las decisiones de programación.
3. Altos gastos generales : El cambio de contexto frecuente puede aumentar la sobrecarga y ralentizar el rendimiento del sistema.
4. No apto para sistemas en tiempo real : Las tareas en tiempo real pueden sufrir retrasos debido a apropiaciones frecuentes.