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 | 6ms | 0 ms |
| P2 | 8ms | 0 ms |
| P3 | 5ms | 0 ms |
Execução passo a passo:
- Tempo 0-5 (P3) : P3 funciona por 5 ms (tempo total restante: 0 ms), pois tem o menor tempo restante restante.
- Tempo 5-11 (P1) : P1 funciona por 6 ms (tempo total restante: 0 ms), pois tem o menor tempo restante restante.
- 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 | 11 | 11-0 = 11 | 11-6 = 5 | |
| P2 | 8 | 19 | 19-0 = 19 | 19-8 = 11 | |
| P3 | 5 | 5 | 5-0 = 5 | 5-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 | 6ms | 0 ms |
| P2 | 3ms | 1 ms |
| P3 | 7ms | 2ms |
Execução passo a passo:
- Tempo 0-1 (P1) : P1 funciona por 1 ms (tempo total restante: 5 ms), pois tem o menor tempo restante restante.
- Tempo 1-4 (P2) : P2 funciona por 3 ms (tempo total restante: 0 ms), pois tem o menor tempo restante entre P1 e P2.
- Tempo 4-9 (P1) : P1 funciona por 5 ms (tempo total restante: 0 ms), pois tem o menor tempo restante entre P1 e P3.
- 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 | 9 | 9-0 = 9 | 9-6 = 3 | |
| P2 | 1 | 3 | 4 | 4-1 = 3 | 3-3 = 0 |
| P3 | 2 Olá mundo com java | 7 | 16 | 16-2 = 14 | 14-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
- 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.
- Eficiente para processos curtos : Processos mais curtos são concluídos mais rapidamente, melhorando a capacidade de resposta geral do sistema.
- Ideal para sistemas com tempo crítico : Garante que processos urgentes sejam executados rapidamente.
Desvantagens do SRTF Agendamento
- Fome de processos longos : Processos mais longos podem ser atrasados indefinidamente se processos mais curtos continuarem chegando.
- 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.
- Altas despesas gerais : a troca frequente de contexto pode aumentar a sobrecarga e diminuir o desempenho do sistema.
- Não é adequado para sistemas em tempo real : tarefas em tempo real podem sofrer atrasos devido a preempções frequentes.