logo

Algoritmo de agendamento do menor tempo restante primeiro (SJF preemptivo)

A versão preventiva do agendamento Shortest Job First (SJF) é chamada Shortest Remaining Time First (SRTF). No SRTF o processo com menor tempo restante para terminar é selecionado para execução. O processo em execução continua até terminar ou chegar um novo processo com um tempo restante mais curto, garantindo que o processo de finalização mais rápido sempre tenha prioridade.

Exemplo de algoritmo SJF:

Cenário 1: Processos com Mesmo Horário de Chegada

Exemplo: Considere a seguinte tabela de tempo de chegada e tempo de burst para três processos P1 P2 e P3 .

Processo Tempo de explosão Hora de chegada
 P1   6ms0 ms
 P2 8ms0 ms
 P3 5ms0 ms

Execução passo a passo:



  1. Tempo 0-5 (P3) : P3 funciona por 5 ms (tempo total restante: 0 ms), pois tem o menor tempo restante restante.
  2. Tempo 5-11 (P1) : P1 funciona por 6 ms (tempo total restante: 0 ms), pois tem o menor tempo restante restante.
  3. Tempo 11-19 (P2) : P2 funciona por 8 ms (tempo total restante: 0 ms), pois tem o menor tempo restante restante.

Gráfico de Gantt:


instrução if-else java

Agora vamos calcular a média tempo de espera e virar tempo:

Como sabemos

  • Hora de virar = Hora de conclusão - hora de chegada
  • Tempo de espera = Tempo de retorno - tempo de explosão
Processo  

Hora de chegada

baixar vídeos do youtube com vlc

(NO)

Tempo de explosão

(BT)

Tempo de conclusão (CT)Tempo de entrega (TAT)Tempo de espera (WT)
 P1  

6

chamando a função js de html
1111-0 = 1111-6 = 5
 P2

8

1919-0 = 1919-8 = 11
 P3

5

55-0 = 55-5 = 0

Agora 

  • Tempo médio de retorno = (11 + 19 + 5)/3 = 11,6ms
  • Tempo médio de espera = (5 + 0 + 11)/3 = 16/3 = 5,33ms

Cenário 2: Processos com Tempos de Chegada Diferentes

Considere a seguinte tabela de tempo de chegada e tempo de rajada para três processos P1, P2 e P3.

árvore b e árvore b
Processo Tempo de explosão Hora de chegada
 P1   6ms0 ms
 P2 3ms1 ms
 P3 7ms2ms

Execução passo a passo:

  1. Tempo 0-1 (P1) : P1 funciona por 1 ms (tempo total restante: 5 ms), pois tem o menor tempo restante restante.
  2. Tempo 1-4 (P2) : P2 funciona por 3 ms (tempo total restante: 0 ms), pois tem o menor tempo restante entre P1 e P2.
  3. Tempo 4-9 (P1) : P1 funciona por 5 ms (tempo total restante: 0 ms), pois tem o menor tempo restante entre P1 e P3.
  4. Tempo 9-16 (P3) : P3 funciona por 7 ms (tempo total restante: 0 ms), pois tem o menor tempo restante restante.

Gráfico de Gantt:

Agora vamos calcular a média tempo de espera e virar tempo:

Processo  

Hora de chegada (AT)

Tempo de explosão (BT)

Tempo de conclusão (CT)Tempo de entrega (TAT)Tempo de espera (WT)
 P1  

6

99-0 = 99-6 = 3
 P2

1

3

44-1 = 33-3 = 0
 P3

2

Olá mundo com java

7

1616-2 = 1414-7 = 7
  • Tempo médio de retorno = (9 + 14 + 3)/3 = 8,6ms
  • Tempo médio de espera = (3 + 0 + 7)/3 = 10/3 = 3,33ms

Implementação do Algoritmo SRTF

Etapa 1: Insira o número de processos com hora de chegada e tempo de burst.
Etapa 2: Inicialize os tempos restantes (tempos de burst), tempo atual = 0 e contadores.
Etapa 3: A cada unidade de tempo adicione processos que chegaram à fila de prontos.
Etapa 4: Selecione o processo com o menor tempo restante (preempção se chegar um mais curto).
Etapa 5: Execute o processo selecionado por 1 unidade, reduza o tempo restante e aumente o tempo atual.
Etapa 6: Se um processo for concluído:

  • Tempo de resposta = Tempo de conclusão - Hora de chegada
  • Tempo de espera = Tempo de resposta - Tempo de estouro

Etapa 7: Repita as etapas 3 a 6 até que todos os processos sejam concluídos.
Etapa 8: Calcule o tempo médio de espera e o tempo de resposta.
Etapa 9: Exiba os tempos de espera e de resposta para cada processo, juntamente com as médias.

Implementação de código

O programa para implementar o menor tempo restante primeiro é o seguinte:

C++
#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; } 
Java
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);  } } 
Python
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) 

Saída
Enter number of processes: Avg WT: -nan Avg TAT: -nan 

Vantagens do SRTF Agendamento

  1. Minimiza o tempo médio de espera : O SRTF reduz o tempo médio de espera priorizando processos com o menor tempo de execução restante.
  2. Eficiente para processos curtos : Processos mais curtos são concluídos mais rapidamente, melhorando a capacidade de resposta geral do sistema.
  3. Ideal para sistemas com tempo crítico : Garante que processos urgentes sejam executados rapidamente.

Desvantagens do SRTF Agendamento

  1. Fome de processos longos : Processos mais longos podem ser atrasados ​​indefinidamente se processos mais curtos continuarem chegando.
  2. Difícil prever tempos de explosão : a previsão precisa dos tempos de intermitência do processo é desafiadora e afeta as decisões de agendamento.
  3. Altas despesas gerais : a troca frequente de contexto pode aumentar a sobrecarga e diminuir o desempenho do sistema.
  4. Não é adequado para sistemas em tempo real : tarefas em tempo real podem sofrer atrasos devido a preempções frequentes.
Criar questionário