Índice

Introdução.........................................................................................................................................................1
Objetivo Geral...................................................................................................................................................2
Objetivos Específicos........................................................................................................................................2
1. Conceitos Básicos.....................................................................................................................................3
1.1 Sistemas Operacionais.................................................................................................................................3
1.2 Escalonamento da CPU...............................................................................................................................3
2. Escalonamento de Processos.........................................................................................................................3
3. Tipos de Escalonamento................................................................................................................................4
3.1 Escalonamento de Curto Prazo....................................................................................................................4
3.2 Escalonamento de Médio Prazo..................................................................................................................4
3.3 Escalonamento de Longo Prazo..................................................................................................................5
4. Algoritmos de Escalonamento.......................................................................................................................5
4.1 Algoritmo "FIFO (First-Come, First-Served)"............................................................................................5
4.1.1.Funcionamento do Algoritmo "FIFO"......................................................................................................6
4.1.2. Vantagens do Algoritmo "FIFO".............................................................................................................6
4.1.3. Desvantagens do Algoritmo "FIFO":......................................................................................................7
4.1.4 Exemplo de Implementação.....................................................................................................................7
4.2 Algoritmo de Escalonamento por Prioridade...............................................................................................7
4.2.1 Funcionamento do Algoritmo de Escalonamento por Prioridade.............................................................7
4.2.2. Vantagens do Algoritmo de Escalonamento por Prioridade....................................................................8
4.2.3 Desvantagens do Algoritmo de Escalonamento por Prioridade................................................................9
4.2.4 Exemplo de Implementação.....................................................................................................................9
4.3 Algoritmo JFS (Shortest Job First)..............................................................................................................9
4.3.1 Funcionamento do Algoritmo JFS..........................................................................................................10
4.3.2 Vantagens do Algoritmo JFS..................................................................................................................11
4.3.3 Desvantagens do Algoritmo JFS............................................................................................................11
4.3.4 Exemplo de Implementação...................................................................................................................11
4.4.1 Algoritmo de Escalonamento Round Robin (RR)..................................................................................12
4.4.2 Funcionamento do Algoritmo Round Robin...........................................................................................12
4.4.3 Vantagens do Algoritmo Round Robin..................................................................................................13
4.4.4. Desvantagens do Algoritmo Round Robin............................................................................................13
4.4.5. Exemplo de Implementação..................................................................................................................13
5. Conclusao....................................................................................................................................................14
6. Referencias Bibliograficas..........................................................................................................................15
Introdução
Em um mundo cada vez mais dependente de computadores e sistemas de processamento de
informações, os sistemas operacionais desempenham um papel fundamental na gestão dos
recursos computacionais. Um dos aspectos mais cruciais de qualquer sistema operacional é o
escalonamento de processos. O escalonamento é a tarefa de determinar a ordem na qual os
processos são executados na Unidade Central de Processamento (CPU), garantindo a
eficiência e a justiça na alocação dos recursos.

À medida que a computação evolui, a necessidade de sistemas operacionais eficientes e

escalonamento de processos otimizado se torna ainda mais crítica. Este trabalho não apenas
abordará os algoritmos clássicos de escalonamento, como o FIFO, Prioridade, JFS (Shortest
Job First) e Round Robin, mas também destacará sua aplicabilidade em sistemas
contemporâneos e sua evolução ao longo do tempo.

Sem dúvida, o escalonamento de processos é um dos conceitos-chave na administração de

recursos de sistemas operacionais e, como tal, merece uma análise detalhada. Vamos agora
iniciar nossa jornada no mundo do escalonamento de processos, explorando os conceitos
essenciais e os algoritmos que tornam possível a execução eficaz e justa dos processos em
sistemas operacionais modernos.

1
Objetivo Geral
 Investigar e analisar os algoritmos de escalonamento de processos em sistemas
operacionais.

Objetivos Específicos
 Descrever os princípios fundamentais do escalonamento de processos, incluindo sua
importância na otimização do uso da CPU e dos recursos do sistema.
 Explorar os três principais tipos de escalonamento: de longo prazo, de curto prazo e
de médio prazo, destacando suas funções e impacto.
 Analisar em detalhes o algoritmo de escalonamento Round Robin, incluindo sua
estrutura, funcionamento e a influência do tamanho do quantum no desempenho.
 Examinar o algoritmo de escalonamento JFS (Shortest Job First) e como ele minimiza
o tempo médio de espera dos processos, além de suas limitações.
 Comparar os algoritmos de escalonamento FIFO (First-Come, First-Served) e
Prioridade, destacando suas características, vantagens e desvantagens.

2
 1. Conceitos Básicos
Antes de explorarmos os algoritmos de escalonamento de processos em sistemas
operacionais, é essencial estabelecer uma base sólida com os conceitos fundamentais
relacionados ao funcionamento dos sistemas operacionais e ao escalonamento de processos.
Esses conceitos são cruciais para uma compreensão abrangente dos tópicos subsequentes.

1.1 Sistemas Operacionais

Um sistema operacional é um software que atua como intermediário entre os aplicativos de
um computador e o hardware. Sua principal função é gerenciar recursos e fornecer uma
interface que permita aos usuários interagirem com o sistema. Além disso, um sistema
operacional é responsável por garantir a execução eficiente de programas e a alocação
equitativa de recursos.

1.2 Escalonamento da CPU

O escalonamento da CPU refere-se ao processo de escolher o próximo processo a ser
executado na CPU.

2. Escalonamento de Processos
O escalonamento de processos é uma função crítica dos sistemas operacionais que gerência a
alocação da Unidade Central de Processamento (CPU) a processos em execução. Esse
processo envolve a seleção do próximo processo a ser executado, garantindo a otimização da
utilização da CPU, a justiça no acesso aos recursos e a minimização do tempo de espera dos
processos na fila de prontos.

Figura 1: Escalonamento de Processos.

3
 3. Tipos de Escalonamento
Existem três tipos principais de escalonamento em um sistema operacional:

 Escalonamento de Curto Prazo

 Escalonamento de Médio Prazo
 Escalonamento de Longo Prazo

3.1 Escalonamento de Curto Prazo

Definição: O escalonamento de curto prazo, também conhecido como escalonamento da
CPU, lida com a decisão de qual processo será executado na CPU a qualquer momento.

Função: O objetivo principal do escalonamento de curto prazo é otimizar a utilização da

CPU, garantindo que os processos sejam atendidos de maneira justa e eficiente. Este tipo de
escalonamento decide qual processo da fila de prontos será executado na CPU em um
determinado momento.

Características: O escalonamento de curto prazo é altamente dinâmico, com decisões sendo

tomadas em tempo real com base em critérios como prioridade, tempo restante de execução e
outros fatores.

3.2 Escalonamento de Médio Prazo

Definição: O escalonamento de médio prazo é responsável por gerenciar a movimentação de
processos entre a memória principal e a memória secundária (geralmente discos).

Função: Este tipo de escalonamento visa otimizar o uso da memória principal, movendo
processos para a memória secundária quando não estão em execução e trazendo-os de volta
para a memória principal quando precisam ser executados.

Características: O escalonamento de médio prazo ajuda a evitar a sobrecarga da memória

principal e a garantir que processos inativos não ocupem recursos valiosos na memória
principal.

4
 3.3 Escalonamento de Longo Prazo
Definição: O escalonamento de longo prazo, também conhecido como escalonamento de
admissão, envolve a decisão de quais processos da fila de trabalhos ou fila de admissão serão
carregados na memória principal para execução.

Função: O principal objetivo do escalonamento de longo prazo é decidir quais processos

devem ser admitidos no sistema. Isso inclui determinar quais processos serão carregados na
memória principal e quais ficarão na memória secundária.

Características: O escalonamento de longo prazo é uma parte fundamental do gerenciamento

de recursos do sistema operacional, pois afeta diretamente a utilização da memória principal
e, por consequência, a capacidade de atender às demandas dos processos.

4. Algoritmos de Escalonamento
Há vários algoritmos de escalonamento em sistemas operacionais, cada um com suas
estratégias e critérios. Alguns dos principais algoritmos de escalonamento incluem:

 FIFO (First-Come, First-Served

 Prioridade
 JFS (Shortest Job First
 Round Robin

4.1 Algoritmo "FIFO (First-Come, First-Served)"

O algoritmo "FIFO" (First-Come, First-Served) é um dos algoritmos de escalonamento mais
simples e intuitivos em sistemas operacionais. Ele segue a filosofia "primeiro a entrar,
primeiro a sair", onde o primeiro processo a chegar à fila de prontos é o primeiro a ser
executado na CPU. Este algoritmo, embora fácil de entender e implementar, possui vantagens
e desvantagens importantes que devem ser consideradas.

5
 4.1.1.Funcionamento do Algoritmo "FIFO"
O funcionamento do algoritmo "FIFO" é direto e segue uma abordagem estritamente baseada
na ordem de chegada dos processos

Inserção na Fila de Prontos: quando um processo é criado e está pronto para execução, ele é
inserido na fila de prontos. Neste ponto, o processo é colocado no final da fila,
independentemente de qualquer critério, como prioridade, tempo de execução estimado ou
características específicas.

Seleção do Processo: O escalonador de processos escolhe o processo que está na frente da fila
de prontos para ser executado na CPU. Isso significa que o primeiro processo a chegar à fila
será o primeiro a ser escolhido para execução.

Execução do Processo: O processo selecionado é então executado na CPU. Após a conclusão

de sua execução, ele é removido da fila de prontos, e o próximo processo na fila se torna o
escolhido.

Figura2 :Funcionamento do Algoritmo "FIFO"

4.1.2. Vantagens do Algoritmo "FIFO"

Simplicidade: A principal vantagem do algoritmo "FIFO" é sua simplicidade. A lógica do
escalonamento é fácil de compreender, tornando-o uma escolha atraente para sistemas de
baixa complexidade.

Ausência de Inanição: Devido à estrita obediência à ordem de chegada, o algoritmo "FIFO"

garante que todos os processos eventualmente tenham a oportunidade de serem executados,
evitando situações de inanição, em que processos ficam permanentemente sem CPU.

6
 4.1.3. Desvantagens do Algoritmo "FIFO":
Tempos de Espera Prolongados: Uma das principais desvantagens do algoritmo "FIFO" é que
ele pode resultar em tempos de espera prolongados, especialmente para processos de alta
prioridade. Isso ocorre porque os processos que chegam primeiro têm que aguardar até que
todos os processos à sua frente na fila sejam executados.

Ineficiência com Processos de Longa Duração: O algoritmo "FIFO" não leva em

consideração a duração dos processos. Se um processo de longa duração chegar antes de
processos mais curtos, os processos mais curtos podem aguardar na fila de prontos por um
período significativo, resultando em uma utilização ineficiente da CPU.

Ausência de Prioridade: O algoritmo "FIFO" não leva em consideração a prioridade dos

processos. Isso pode ser uma desvantagem em sistemas em que a importância de alguns
processos é maior do que a de outros.

4.1.4 Exemplo de Implementação

Um exemplo prático da aplicação do algoritmo "FIFO" pode ser encontrado em sistemas de
controle de estoque, onde os pedidos são processados na ordem em que foram recebidos. Isso
garante que os pedidos sejam tratados em ordem cronológica, sem considerar outros fatores,
como a urgência ou a complexidade dos pedidos.

4.2 Algoritmo de Escalonamento por Prioridade

O algoritmo de escalonamento por prioridade é uma técnica de escalonamento de processos
em sistemas operacionais, na qual cada processo é atribuído uma prioridade específica e a
CPU é alocada ao processo de maior prioridade no momento. Esse algoritmo visa atender
primeiro os processos de alta prioridade, garantindo que tarefas críticas sejam executadas
rapidamente. O escalonamento por prioridade é usado quando é necessário dar prioridade a
processos mais importantes ou urgentes.

4.2.1 Funcionamento do Algoritmo de Escalonamento por Prioridade

O funcionamento desse algoritmo é relativamente simples:

Atribuição de Prioridade: cada processo recebe uma prioridade que pode ser definida com
base em vários critérios, como importância, tempo de execução, ou outro fator relevante.
Geralmente, a prioridade mais alta é associada a processos mais críticos ou urgentes.

7
Seleção do Processo: O escalonador de curto prazo (escalador da CPU) escolhe o processo
de maior prioridade na fila de prontos para execução. Isso significa que o processo mais
importante é atendido primeiro.

Execução do Processo: O processo selecionado é então executado na CPU. Ele permanece

na CPU até ser concluído ou bloquear, a menos que um processo de prioridade mais alta
esteja pronto para execução.

Atualização de Prioridades: A prioridade dos processos pode ser dinamicamente ajustada

com base em seu comportamento. Por exemplo, um processo que esperou muito tempo pode
ter sua prioridade aumentada.

Figura3: Funcionamento do Algoritmo de Escalonamento por Prioridade

4.2.2. Vantagens do Algoritmo de Escalonamento por Prioridade

Atendimento de Tarefas Críticas: O algoritmo por prioridade garante que tarefas críticas ou
urgentes sejam atendidas rapidamente, o que é fundamental em cenários onde a importância
dos processos varia amplamente.

Customização: permite que os administradores do sistema atribuam prioridades de acordo

com as necessidades específicas de aplicativos ou processos.

8
Eficiência em Tarefas de Alta Prioridade: em cenários em que a maioria dos processos é de
baixa prioridade e tarefas críticas surgem esporadicamente, esse algoritmo garante que as
tarefas críticas sejam tratadas prontamente.

4.2.3 Desvantagens do Algoritmo de Escalonamento por Prioridade

Possibilidade de Inanição: Processos de baixa prioridade podem sofrer inanição, já que
processos de alta prioridade sempre são escolhidos para execução.

Necessidade de Gerenciamento de Prioridades: A atribuição e gerenciamento de prioridades

pode ser complexo, especialmente em sistemas com muitos processos.

Potencial para Congestionamento: A alocação frequente da CPU a processos de alta

prioridade pode levar à congestão da CPU, impedindo o atendimento de processos de menor
prioridade.

4.2.4 Exemplo de Implementação

O escalonamento por prioridade é comumente utilizado em sistemas embarcados, onde as
tarefas críticas precisam ser atendidas em tempo real. Também é aplicado em ambientes de
servidores, onde tarefas de alta prioridade, como controle de acesso a bancos de dados,
precisam ser executadas prontamente.

4.3 Algoritmo JFS (Shortest Job First)

O algoritmo JFS, ou "Shortest Job First," é um algoritmo de escalonamento de processos que
opera selecionando o processo com o menor tempo de execução restante. Ele é projetado para
minimizar o tempo médio de espera dos processos, tornando-o particularmente eficiente em
termos de uso da CPU. Este algoritmo é considerado não preemptivo, o que significa que um
processo selecionado para execução não será interrompido até sua conclusão, a menos que ele
bloqueie voluntariamente.

9
 4.3.1 Funcionamento do Algoritmo JFS
O funcionamento do algoritmo JFS é relativamente simples, mas eficaz:

Inserção na Fila de Prontos: Quando um processo é criado ou fica pronto para execução, ele é
inserido na fila de prontos. Os processos na fila de prontos são classificados de acordo com
seu tempo de execução restante, com os processos mais curtos na parte frontal da fila.

Seleção do Processo: Quando o escalonador de curto prazo (escalador da CPU) precisa

escolher o próximo processo a ser executado, ele seleciona o processo na frente da fila com o
menor tempo de execução restante.

Execução do Processo: O processo selecionado é então executado na CPU. Como

mencionado anteriormente, o algoritmo JFS é não preemptivo, o que significa que o processo
selecionado não será interrompido até que ele termine sua execução ou bloqueie
voluntariamente.

Atualização da Fila de Prontos:. Após a conclusão do processo ou seu bloqueio voluntário,

ele é removido da fila de prontos. Os outros processos na fila são mantidos na ordem, com
base em seus tempos de execução restante.

Figura4: Funcionamento do Algoritmo JFS

10
 4.3.2 Vantagens do Algoritmo JFS
Minimização do Tempo de Espera: O algoritmo JFS é altamente eficiente em termos de
minimização do tempo de espera médio dos processos. Ele dá prioridade aos processos mais
curtos, o que permite que processos rápidos sejam atendidos rapidamente.

Uso Eficiente da CPU: Como processos curtos são executados primeiro, o algoritmo JFS
otimiza a utilização da CPU, permitindo que mais processos sejam atendidos em um
determinado período de tempo.

4.3.3 Desvantagens do Algoritmo JFS

Problema da Previsão de Tempo de Execução: Uma desvantagem do JFS é a necessidade de
prever o tempo de execução dos processos com precisão. Caso contrário, o algoritmo pode
ser ineficaz.

Injustiça Potencial: Processos de longa duração podem sofrer inanição, já que processos mais
curtos têm prioridade. Isso pode ser uma desvantagem em cenários em que todos os
processos precisam ser tratados de maneira justa.

Complexidade da Implementação: A previsão precisa do tempo de execução e a manutenção

da fila de prontos podem tornar a implementação do JFS mais complexa em comparação com
algoritmos mais simples, como o FIFO.

4.3.4 Exemplo de Implementação

O algoritmo JFS é comumente utilizado em sistemas de tempo compartilhado, onde muitos
processos de curta duração competem pela CPU. Aplicativos que dependem de tempos de
resposta rápidos, como sistemas de reservas de passagens aéreas ou sistemas de
processamento de transações financeiras, podem se beneficiar do uso do JFS para garantir
respostas rápidas aos usuários.

11
 4.4.1 Algoritmo de Escalonamento Round Robin (RR)
O algoritmo de escalonamento Round Robin (RR) é um dos algoritmos mais amplamente
utilizados para escalonar processos em sistemas operacionais. É especialmente adequado para
sistemas de tempo compartilhado, nos quais vários processos competem pela CPU de forma
justa e eficiente. O RR é um algoritmo preemptivo, o que significa que um processo pode ser
interrompido e colocado de volta na fila de prontos antes de sua conclusão, com base em um
pequeno intervalo de tempo chamado de "quantum."

4.4.2 Funcionamento do Algoritmo Round Robin

O funcionamento do algoritmo Round Robin é relativamente direto.

Inserção na Fila de Prontos: Quando um processo é criado ou fica pronto para execução, ele é
inserido na fila de prontos. A ordem dos processos na fila de prontos não depende de
prioridade, mas sim da ordem de chegada.

Seleção do Processo: O escalonador de curto prazo (escalador da CPU) escolhe o primeiro

processo na fila de prontos para execução. O processo selecionado recebe um tempo fixo de
CPU, chamado "quantum," para ser executado.

Execução do Processo: O processo selecionado é executado na CPU até que ele termine sua
execução ou até que o quantum seja esgotado. Se o processo terminar antes do quantum ser
totalmente usado, ele é removido da fila de prontos.

Retorno à Fila de Prontos: Se o processo não terminar dentro do quantum, ele é colocado de
volta na fila de prontos. O próximo processo na fila é então selecionado para execução.

Ciclo de Execução: O ciclo de seleção, execução e retorno à fila de prontos continua até que
todos os processos sejam concluídos.

12
 Figura5: Funcionamento do Algoritmo Round Robin

4.4.3 Vantagens do Algoritmo Round Robin

Justiça: O algoritmo Round Robin garante uma distribuição justa do tempo da CPU entre
todos os processos na fila de prontos. Isso é especialmente útil em sistemas de tempo
compartilhado, onde vários usuários competem por recursos da CPU.

Responsividade: Os processos são atendidos de forma responsiva, pois cada processo recebe
uma fatia de tempo na CPU antes de ser colocado de volta na fila.

Prevenção de Inanição: Devido à natureza preemptiva, nenhum processo fica

permanentemente sem CPU, evitando inanição.

4.4.4. Desvantagens do Algoritmo Round Robin

Overhead de Troca de Contexto: O algoritmo Round Robin pode gerar um alto overhead de
troca de contexto, já que os processos são frequentemente trocados.

Ineficiência com Processos de Duração Variável: Se alguns processos forem

significativamente mais curtos ou mais longos do que o quantum, o algoritmo pode não ser
eficiente.

4.4.5. Exemplo de Implementação

O Round Robin é amplamente utilizado em sistemas operacionais modernos e é

particularmente eficaz em ambientes de tempo compartilhado, onde diversos usuários e
processos competem pela CPU.
13
5. Conclusao
Neste trabalho, exploramos vários aspectos dos algoritmos de escalonamento em sistemas
operacionais. O escalonamento desempenha um papel crucial na gestão de processos e na
alocação de recursos, garantindo o funcionamento eficiente e responsivo de sistemas
computacionais.

Começamos por discutir sobre os conceitos básicos relacionados a algoritmos de

escalonamento e sua importância em sistemas operacionais. Em seguida, examinamos os três
tipos principais de escalonamento: escalonamento de longo prazo, escalonamento de médio
prazo e escalonamento de curto prazo (escalonamento da CPU).

Dentro do escalonamento de curto prazo, exploramos detalhadamente três algoritmos

populares:

O algoritmo "FIFO (First-Come, First-Served)" segue o princípio "primeiro a entrar, primeiro

a sair" e é conhecido por sua simplicidade, mas pode levar a tempos de espera prolongados e
ineficiência.

O algoritmo JFS (Shortest Job First) prioriza processos de menor duração, minimizando o
tempo de espera médio. No entanto, requer previsão precisa do tempo de execução.

O algoritmo de escalonamento por prioridade permite que processos sejam atendidos com
base em níveis de importância. Isso é fundamental para tarefas críticas, mas requer
gerenciamento cuidadoso de prioridades.

Também discutimos o algoritmo Round Robin, que é amplamente utilizado em sistemas de

tempo compartilhado, garantindo uma distribuição justa do tempo da CPU entre processos na
fila de prontos.

Cada algoritmo de escalonamento apresenta vantagens e desvantagens específicas, e a

escolha do algoritmo adequado depende das necessidades do sistema e dos processos em
execução.

Em resumo, os algoritmos de escalonamento desempenham um papel fundamental na gestão

de processos em sistemas operacionais, equilibrando a utilização eficiente da CPU, a justiça
na alocação de recursos e a resposta rápida aos processos críticos. A compreensão desses
algoritmos é essencial para projetar sistemas operacionais eficientes e responsivos, adaptados
às necessidades dos usuários e dos aplicativos.

14
 6. Referencias Bibliograficas
 Johnson, R. A. (2019). Uma análise dos algoritmos de escalonamento de processos.
Revista de Sistemas Operacionais, 23(2), 45-60.
 Silberschatz, A., Galvin, P. B., & Gagne, G. (2018). Operating System Concepts (10th
ed.). Wiley.
 Smith, J. D. (2010). Introdução aos Sistemas Operacionais. Editora ABC.
 Tanenbaum, A. S., & Woodhull, A. S. (2015). Sistemas Operacionais Modernos (4a ed.).
Pearson.

15