Logo Passei Direto
Buscar
Material
páginas com resultados encontrados.
páginas com resultados encontrados.

Prévia do material em texto

Aluna: Ellen Cristina Torres Cardosos / Matrícula: 04164893 
Curso: Análise e Desenvolvimento de Sistemas 
Turma: 3° Semestre / Noite 
 
Segue uma breve explicação de como funciona a variação dos código a seguir: Na primeira 
variação, chamada Round-Robin com Controle de CPU (Lock), cada processo é executado 
como uma thread concorrente, mas o acesso à CPU é controlado por um Lock (mutex), 
garantindo que apenas um processo rode por vez. Cada processo possui um quantum fixo 
de 2 segundos antes de liberar a CPU para outro, simulando um sistema multitarefa com 
alternância obrigatória. 
Na segunda variação, Round-Robin com Threads Concorrentes, os processos continuam 
sendo threads, mas sem bloqueio explícito. Cada processo inicia sua execução de forma 
independente, e o escalonamento ocorre automaticamente. Isso permite uma execução 
mais dinâmica, sem um controle rígido da CPU, simulando um ambiente multitarefa mais 
realista. 
Já na terceira variação, Escalonamento por Prioridade, os processos são ordenados por 
níveis de prioridade, onde os mais importantes recebem mais tempo de CPU. Cada 
processo recebe uma prioridade aleatória, ajustando o tempo de execução de acordo com 
essa hierarquia. Essa abordagem simula um sistema operacional mais sofisticado, 
garantindo que tarefas críticas sejam executadas primeiro, sem impedir a execução de 
processos menos prioritários. 
Segue abaixo os códigos e suas variações: 
 
 
 
 
 
 
 
Codigo 1 
 
Uma abordagem simples é o Round-Robin, onde cada processo recebe um quantum fixo de 
tempo antes de ceder a CPU para o próximo. Isso impede que um único processo 
monopolize a execução, garantindo uma distribuição mais justa do tempo de 
processamento. Outra variação dessa estratégia utiliza threads concorrentes junto a um 
mecanismo de sincronização (Lock), garantindo que apenas um processo utilize a CPU por 
vez, imitando um ambiente multitarefa real. 
Além disso, podemos implementar um escalonador por prioridade, onde processos com 
maior prioridade recebem mais tempo de CPU antes dos menos prioritários. Isso simula um 
cenário mais realista, onde tarefas críticas do sistema são executadas antes de processos 
menos urgentes. 
Com essas abordagens, conseguimos representar de forma simplificada como os sistemas 
operacionais lidam com múltiplos processos, garantindo eficiência e organização na 
execução dos programas. 
 
 
 
 
 
 
 
 
 
 
 
Código 2 
 
Nesta variação da simulação de multiprogramação, utilizamos threads para executar os 
processos simultaneamente, com um gerente de CPU controlando o escalonamento. Dessa 
forma, o processador alterna entre os processos, garantindo que apenas um possa executar 
por vez, graças a um mecanismo de sincronização (Lock). 
Cada processo é representado por uma Thread, permitindo a execução concorrente. No 
entanto, para evitar que múltiplos processos usem a CPU ao mesmo tempo, um bloqueio 
(mutex) é utilizado, garantindo que apenas um processo tenha acesso ao processador por 
vez, imitando o funcionamento de um sistema real. A execução é baseada em um quantum 
fixo de 2 segundos, após os quais o processo libera a CPU para outro. O loop dentro de 
run() verifica constantemente se o processo ainda tem tempo restante, e, caso tenha, ele 
volta a competir pelo processador. 
Essa abordagem traz algumas melhorias em relação à versão anterior. Agora, os processos 
realmente competem entre si de forma concorrente, e o gerente de CPU (Lock) decide 
quem pode rodar, garantindo que nenhum processo fique "preso" monopolizando a CPU. 
Dessa forma, conseguimos simular de maneira mais fiel um sistema operacional multitarefa, 
onde os processos compartilham os recursos do processador de maneira organizada e 
eficiente. 
 
 
 
 
Código 3 
 
 
Nesta variação da simulação de multiprogramação, implementamos um escalonador 
baseado em prioridades, onde os processos possuem diferentes níveis de prioridade, 
determinando a quantidade de tempo de CPU que cada um recebe. Os processos com 
maior prioridade têm preferência na execução e ganham mais tempo de CPU antes dos 
demais. 
O sistema ordena os processos com base em sua prioridade antes de iniciar a execução. 
Cada processo recebe um quantum proporcional à sua prioridade, garantindo que tarefas 
mais importantes sejam concluídas mais rapidamente. Isso simula um cenário mais realista, 
onde tarefas críticas do sistema operacional recebem mais recursos do que processos 
menos urgentes. 
Essa abordagem melhora a eficiência do uso da CPU, permitindo que processos mais 
prioritários sejam atendidos primeiro, ao mesmo tempo em que processos de menor 
prioridade ainda conseguem ser executados, mas com menos tempo de CPU por ciclo. 
Assim, conseguimos representar um sistema operacional que gerencia múltiplos processos 
de maneira organizada, garantindo um balanceamento entre eficiência e equidade na 
distribuição dos recursos.

Mais conteúdos dessa disciplina