Sistemas Operacionais - Apostila

Prévia do material em texto

Universidade Estácio - Fagner Lima 
fagnerlima.com.br 
 
SISTEMAS OPERACIONAIS 
APRESENTAÇÃO 
Bem vindos a disciplina Sistemas Operacionais. Nesta disciplina iremos estudar como funciona um 
sistema operacional identificando seus componentes, problemas e características nos sistemas 
modernos. 
Essa disciplina aborda os fundamentos de sistemas operacionais relacionando-os a tarefas e 
problemas conhecidos nas implementações mais usuais. Essa abordagem possibilita a solução de 
problemas com fundamentação teórica e um bom uso das características de cada sistema. Fornece 
ainda um grau de conhecimento que diferencia profissionais com uma formação adequada dos 
demais. 
Fique atento(a) e bom estudo! 
 
SUMÁRIO 
1. INTRODUÇÃO A SISTEMAS OPERACIONAIS ....................................................................3 
Objetivos .............................................................................................................3 
Conceitos Fundamentais de Sistemas Operacionais ...........................................................3 
Classificação de Sistemas Operacionais .........................................................................4 
Estruturas dos Sistemas Operacionais Modernos...............................................................6 
Interrupções .........................................................................................................8 
Conceitos de Concorrência ...................................................................................... 10 
Síntese do Capítulo ............................................................................................... 11 
Exercícios de Revisão ............................................................................................. 11 
2. PROCESSOS ...................................................................................................... 12 
Objetivos ........................................................................................................... 12 
Conceito ............................................................................................................ 12 
Componentes ...................................................................................................... 12 
Ciclo de Vida de um Processo ................................................................................... 13 
Estados .............................................................................................................. 14 
Tipos ................................................................................................................. 15 
Síntese do Capítulo ............................................................................................... 15 
Exercícios de Revisão ............................................................................................. 15 
3. THREADS ......................................................................................................... 16 
Objetivos ........................................................................................................... 16 
Conceito ............................................................................................................ 16 
Estrutura ............................................................................................................ 16 
Tipos ................................................................................................................. 18 
Síntese do Capítulo ............................................................................................... 20 
Exercícios de Revisão ............................................................................................. 20 
4. COMUNICAÇÃO ENTRE PROCESSOS .......................................................................... 21 
Objetivos ........................................................................................................... 21 
Motivação ........................................................................................................... 21 
Entendendo uma Condição de Corrida ........................................................................ 22 
Como Evitar a Ocorrência de uma Condição de Corrida ................................................... 24 
Síntese do Capítulo ............................................................................................... 26 
Exercícios de Revisão ............................................................................................. 26 
5. SINCRONIZAÇÃO ENTRE PROCESSOS ......................................................................... 28 
Objetivos ........................................................................................................... 28 
Mecanismos de Exclusão Mútua ................................................................................. 28 
Mecanismos Baseados em Algoritmos .......................................................................... 28 
Mecanismos Baseados em Características de Hardware .................................................... 29 
Mecanismos Baseados em Primitivas do Sistemas Operacional ........................................... 30 
Detalhando os Semáforos ........................................................................................ 31 
Sincronização Condicional Utilizando Semáforos ............................................................ 31 
Síntese do Capítulo ............................................................................................... 34 
Exercícios de Revisão ............................................................................................. 34 
6. GERÊNCIA DE TEMPO DE CPU ................................................................................. 36 
Objetivos ........................................................................................................... 36 
Escalonamento .................................................................................................... 36 
Estratégias de Escalonamento .................................................................................. 36 
Tipos de Estratégia ............................................................................................... 37 
Critérios de Escalonamento ..................................................................................... 37 
Critérios de Escalonamento ..................................................................................... 38 
Síntese da Aula .................................................................................................... 40 
Exercícios de Fixação............................................................................................. 40 
7. GERÊNCIA DE ALOCAÇÃO DE MEMÓRIA ...................................................................... 42 
Objetivos ........................................................................................................... 42 
Conceito ............................................................................................................ 42 
Estratégias de Organização Lógica do Espaço de Memória ................................................ 42 
Síntese do Capítulo ............................................................................................... 46 
Exercícios de Fixação............................................................................................. 46 
8. MEMÓRIA VIRTUAL .............................................................................................. 48 
Objetivos ........................................................................................................... 48 
O que é Memória Virtual? ........................................................................................ 48 
Endereçamento ....................................................................................................48 
Características, Vantagens e Desvantagens .................................................................. 48 
Características de Implementação ............................................................................. 49 
Paginação em Memória Virtual ................................................................................. 49 
Síntese do Capítulo ............................................................................................... 51 
Exercícios de Revisão ............................................................................................. 52 
9. DISPOSITIVOS DE ENTRADA E SAÍDA ......................................................................... 53 
Objetivos ........................................................................................................... 53 
Subsistemas de Entrada e Saída ................................................................................ 53 
Detalhando os Componentes .................................................................................... 54 
Classificação dos Dispositivos ................................................................................... 55 
Síntese do Capítulo ............................................................................................... 55 
Exercícios de Fixação............................................................................................. 55 
10. SISTEMA DE ARQUIVOS ..................................................................................... 57 
Objetivos ........................................................................................................... 57 
Conceitos de Arquivos e Diretórios ............................................................................ 57 
Métodos de Alocação ............................................................................................. 58 
Gerência de Espaço Livre ........................................................................................ 59 
Proteção de Acesso ............................................................................................... 60 
Síntese do Capítulo ............................................................................................... 60 
Exercícios de Fixação............................................................................................. 60 
 
 
 3 INTRODUÇÃO A SISTEMAS OPERACIONAIS 
1. INTRODUÇÃO A SISTEMAS OPERACIONAIS 
Objetivos 
 Identificar as funções e os componentes de um sistema operacional; 
 Diferenciar os tipos de sistemas operacionais existentes; 
 Identificar os modelos de estruturas existentes de sistemas operacionais; 
 Compreender os modos de acesso e o funcionamento de uma chamada ao sistemas (system 
call); 
 Compreender a importância e o funcionamento dos mecanismos de interrupção. 
 Compreender os fundamentos de sistemas concorrentes. 
Conceitos Fundamentais de Sistemas Operacionais 
O que é um sistema operacional? 
Sistema Operacional é um conjunto de programas (software) responsável por: 
 Fazer a interface com os usuários; 
 Gerenciar recursos; 
 Fazer a interface com o hardware. 
 
 
 
Cada parte (módulo ou função) de um sistema operacional é responsável pelo gerenciamento de um 
recurso específico. 
Que recursos são esses? 
 Tempo de CPU; 
 Espaço em memória; 
 Espaço em disco; 
 Acesso aos dispositivos de comunicação; 
 Bibliotecas de software. 
Funções adicionais: contabilização de uso, segurança de acesso, auditoria. 
O sistema operacional é o intermédio entre o usuário e o hardware. 
 4 INTRODUÇÃO A SISTEMAS OPERACIONAIS 
Gerenciar recursos é garantir a utilização compartilhada do recurso sem que ocorram erros que 
possam gerar instabilidade ou falha no sistema. 
Na visão do usuário, o sistema operacional fornece: 
 Acesso ao sistema; 
 Possibilidade de criar e gerir arquivos e diretórios; 
 Ambiente para execução de programas; 
 Acesso aos dispositivos de E/S; 
 Acesso ao conteúdo de arquivos; 
 Detecção de erros. 
Classificação de Sistemas Operacionais 
A classificação é utilizada como uma forma sintética de apresentar, em poucas palavras, as 
características de um sistema operacional. 
 
Conhecer os conceitos envolvidos em uma classificação evita o uso incorreto da nomenclatura 
técnica e sintetiza de forma unívoca as características de um sistema. 
Sistemas Monotarefa x Sistemas Multitarefa 
Definem a capacidade de gerenciar mais de uma tarefa ao mesmo tempo. 
 
 Sistemas Monotarefa: Admite e gerencia apenas uma tarefa em execução. 
Exemplo: DOS. 
 Sistemas Multitarefa: Admite e gerencia várias tarefas em processamento concorrente. 
Exemplos: Windows 7, Windows XP, Lixux, MacOS. 
 
Sistemas Monotarefa x Sistemas Multitarefa 
Sistemas Monousuário x Sistemas Multiusuário 
Sistemas Monoprocessados x Sistemas Multiprocessados 
Atenção 
Estamos falando de gerenciamento, e não de execução. 
 5 INTRODUÇÃO A SISTEMAS OPERACIONAIS 
Sistemas Monousuário x Sistemas Multiusuário 
Definem a capacidade de gerenciar mais de um usuário ao mesmo tempo, compartilhando recursos 
de software e hardware. 
 Sistemas Monousuário: Admite e gerencia apenas um usuário - não permite que mais de um 
usuário esteja “logado” simultaneamente. 
Exemplos: Windows XP, Windows NT (exceto versão com Terminal Server). 
 Sistemas Multiusuário: Admite e gerencia vários usuários - permite que mais de um usuário 
esteja “logado” simultaneamente. 
Exemplos: Linux, VMS. 
 
Sistemas Monoprocessados x Sistemas Multiprocessados 
Possuem capacidade de reconhecer e gerenciar computadores com mais de um processador. 
 Sistemas Monoprocessados: Somente reconhecem e utilizam um processador. 
Exemplo: Windows 98. 
 Sistemas Multiprocessados: Reconhecem e utilizam mais de um processador. 
Exemplos: Windows XP, Windows Vista, Windows 7, Linux. 
 
Outros Sistemas com Finalidades Específicas 
 Sistemas de Tempo Real: Sistemas que possuem um forte vínculo com o tempo. O resultado 
só é considerado correto se a execução acontecer no tempo previsto. 
O sistema deve garantir que uma tarefa possua todos os recursos necessários para sua 
execução em um intervalo de tempo pré-definido. 
 
 Sistemas Embarcados: Sistemas inseridos em produtos com funções específicas como, por 
exemplo, telefones celulares. 
 
Atenção 
Todo sistema operacional multiusuário é obrigatoriamente multitarefa, pois cada 
usuário representa, no mínimo, uma tarefa para ser executada. 
Nota 
Sistemas com suporte a multiprocessamento podem executar mais de uma 
tarefa ao mesmo tempo; uma em cada processador. 
Atenção 
Não se trata de velocidade de processamento, e sim de garantia 
de tempo de resposta. 
Atenção 
Nem todo dispositivo eletrônico possui um microcontrolador, e nem todo 
aparelho com microcontrolador possui um sistema operacional. 
 6 INTRODUÇÃO A SISTEMAS OPERACIONAIS 
Estruturas dos Sistemas Operacionais Modernos 
Um velho conhecido pelos usuários de microcomputadores é a famosa “tela azul”. Quem já utilizou 
sistemas operacionais antigos, como o Windows 95, certamente já se deparou com este problema. A 
“tela azul” era de fato uma violação de acesso que tornava o sistema instável. 
A partir do 80386, esse problema foi solucionado em termos de hardware através da possibilidade 
de 2 modos de execução: o modo protegido e o modo real. Ficava a cargo do sistema operacional a 
comutação entre esses dois modos por questões de compatibilidade. 
A instabilidade evidenciada pela “tela azul” tem razões históricas. Os primeiros processadores da 
linha x86 possuíam um único modo de operação: o modo real. Dessa forma, todas as operações 
poderiam ser executadasdiretamente pelas aplicações que, ao produzir erros, geravam panes no 
sistema. 
 
Modo Usuário x Modo Kernel 
As aplicações são executadas em modo usuário, ou seja, modo que não possui privilégios para 
operações que coloquem o sistema em risco tais como escrever no disco, criar novas tarefas etc. 
Quando essas aplicações precisam executar tarefas críticas, é necessário que haja uma mudança 
para modo Kernel (núcleo do sistema operacional, responsável pelas tarefas críticas do sistema). 
Essa mudança ocorre através de uma “system call” ou chamada ao sistema. 
 
Voltando à “tela azul”: As aplicações podiam executar diretamente as funções do kernel sem a 
proteção da mudança de modo, ou seja, o erro acontecia após a execução de uma função do kernel. 
Com a mudança de modo, se a execução não for segura, a aplicação será impedida de continuar a 
execução e o sistema permanecerá estável. 
Tipos de Estrutura 
Os sistemas são classificados em relação às atribuições do kernel e a relação entre seus módulos em 
monolíticos, camadas e microkernel. 
Os sistemas modernos são divididos em dois grandes grupos: arquitetura monolítica e microkernel. A 
diferença entre elas está nas atribuições do núcleo do sistema operacional, denominado KERNEL. 
Chamadas ao sistema (System Call) 
Mecanismo responsável pela mudança de modo usuário para modo kernel. Ao invés de executar 
diretamente funções do kernel a aplicação executa uma função intermediária que verifica se o 
acesso ao kernel é seguro e, só então, completa a operação. 
 7 INTRODUÇÃO A SISTEMAS OPERACIONAIS 
Essa característica é muito importante no projeto de um Sistema Operacional e foi alvo de discussão 
entre dois grandes nomes da computação: Andrew Tanenbaum e Linus Torvalds. 
Para mais informações sobre o motivo da discussão, leia o texto a seguir: Tanenbaum x Torvalds. 
De um lado, Torvalds defendia um kernel monolítico por ser mais rápido e, de outro, Tanenbaum 
defendia o microkernel pela elegância e facilidade de adaptação e substituição de módulos. Quem 
ganhou? Os dois. 
Andrew Tanenbaum (Microkernel) x Torvalds (Monolítico) 
Arquitetura Monolítica 
Todo o kernel é compilado e “linkado” em um único bloco, tornando o código eficiente, porém de 
difícil manutenção. A inclusão de um módulo requer que todo o kernel seja recriado. 
 
 
Arquitetura Microkernel 
Somente as funções críticas fazem realmente parte do kernel. Demais funções são tratadas como 
tarefas e executam em modo usuário fazendo chamadas ao kernel quando necessário. 
Essa arquitetura simplifica a manutenção, inclusão e exclusão de módulos do sistema operacional, 
não sendo necessário gerar um novo kernel a cada modificação e nem mesmo reiniciar o 
computador para ativação e desativação do módulo. 
Nota 
O kernel do Linux incorporou características modulares. 
 8 INTRODUÇÃO A SISTEMAS OPERACIONAIS 
 
Interrupções 
São sinais de hardware fundamentais para a existência de sistemas multitarefa, pois provocam a 
suspensão da tarefa em execução pela ocorrência de um evento externo permitindo que outras 
tarefas compartilhem o tempo de uso do processador. 
 
 
Parte do mecanismo é executada pelo hardware (identificação do dispositivo, empilhamento dos 
registradores de sistema) e parte é feita por software através da rotina de tratamento da 
interrupção (interrupt handler). 
Atenção 
Neste caso, o que está sendo compartilhado é o TEMPO DE USO do processador, e 
não o processador em si. Cada tarefa utiliza 100% do processador. 
 9 INTRODUÇÃO A SISTEMAS OPERACIONAIS 
 
Tipos de Interrupções 
As interrupções são geradas por dispositivos de hardware e podem ocorrer de forma síncrona ou 
assíncrona. 
 Relógio (temporizador)  síncrona 
 Dispositivos de E/S (sinalização de conclusão)  assíncrona 
 Falha de hardware (paridade de memória, erro de disco, etc.)  assíncrona 
O termo interrupção é muitas vezes para qualquer atividade que suspenda a execução de uma 
tarefa, mesmo que seja solicitada pelo próprio programa. Utilizaremos, para este fim, o termo 
“estado de exceção”. 
Estados de Exceção: são provocados pela própria aplicação. 
 Estouro aritmético; 
 Divisão por zero; 
 Instrução ilegal; 
 Acesso não permitido; 
 Chamadas ao sistema. 
 
As interrupções podem acontecer de forma sequencial ou em cascata. 
 Sequencial: Uma interrupção só poderá ser atendida se nenhuma outra estiver em 
atendimento. 
 A Rotina de Serviço desabilita as interrupções. 
 Uma nova interrupção só é tratada após o retorno. 
 A interrupção pode demorar a ser tratada, o que pode, eventualmente, ocasionar 
uma perda de dados. 
 Finalizada a Rotina de Serviço de interrupção, o processador verifica por 
interrupções adicionais. 
Atenção 
Mascaramento de interrupções: Capacidade de inibir a ação de uma 
interrupção. As interrupções de segurança não podem ser mascaradas. 
 10 INTRODUÇÃO A SISTEMAS OPERACIONAIS 
 
 Cascata: Uma interrupção pode interromper a ação de uma rotina de tratamento de outra 
interrupção. 
 Interrupções têm prioridade. 
 Interrupções com alta prioridade interrompem rotinas de serviço de interrupções de 
menor prioridade. 
Exemplos de prioridade: 
 Impressora - 
 Disco 
 Comunicação + 
 
Conceitos de Concorrência 
Compartilhar recursos significa que diferentes usuários ou programas usam os recursos de forma 
concorrente. 
Como administrar recursos compartilhados? 
Os recursos são limitados e, assim, o uso dos mesmos pelos diferentes programas ou usuários precisa 
ser controlado e administrado de forma a evitar possíveis conflitos ou uma alocação por tempo 
indeterminado de algum recurso. 
Concorrência: 
 É a capacidade de execução concorrente de 
tarefas permitindo um melhor aproveitamento 
de recursos. 
 11 INTRODUÇÃO A SISTEMAS OPERACIONAIS 
 Uma tarefa pode deixar a CPU por vontade própria, quando precisa aguardar por um 
recurso, ou por uma interrupção. 
 Em particular, uma interrupção de temporizador provoca a substituição da tarefa em 
execução criando uma alternância entre as tarefas. 
 
Síntese do Capítulo 
Você aprendeu: 
 O que é um sistema operacional e quais são suas funções. 
 Como os sistemas operacionais estão classificados. 
 Como são as estruturas dos sistemas operacionais modernos. 
 O que são modos de execução. 
 A importância das interrupções nos sistemas operacionais modernos. 
 O que é compartilhamento. 
Exercícios de Revisão 
1) São funções do sistema operacional: 
 Gerenciar recursos de hardware e fornecer um aplicativo para navegação na internet. 
 Gerenciar recursos de hardware e interface com o usuário. 
 Interface com o usuário e correção ortográfica. 
 Gerenciar recursos de software e interromper uma tarefa em execução. 
2) Para que uma aplicação execute instruções privilegiadas deverá executar um(a): 
 Arquivo específico para gerenciamento de hardware. 
 Interrupção de hardware. 
 Solicitação ao administrador do sistema. 
 Chamada ao sistema. 
Soluções 
1) Gerenciar recursos de hardware e interface com o usuário. 
2) Chamada ao sistema. 
 
 
Atenção 
A alternância entre as tarefas pode dar a impressão de execução 
simultânea de tarefas, mas não é o que ocorre. 
 12 PROCESSOS 
2. PROCESSOS 
Objetivos 
 Compreender os conceitos de processos; 
 Identificar os estados de um processo; 
 Compreender como acontece a mudança de estado. 
Conceito 
Processo é a instância de um programa em execução. É a unidade de 
carga e alocação de uma tarefa. 
Em sistemas mais antigos, também é considerado a unidade de 
execução, mas veremos, na próxima aula, que isso não é verdadenos 
sistemas modernos. 
 Cada processo é único em um sistema 
 O processo é criado quando o programa é carregado para a 
memória principal para ser executado. 
 Um programa é carregado para a memória onde aloca uma 
determinada área para código e dados. 
Componentes 
Um processo é dividido em partes que são armazenadas na memória em uma estrutura denominada 
PCB (Process Control Block). 
Identificação Programa 
Registrador SP 
Registrador PC 
Registradores de uso geral 
Informações de escalonamento 
Relação de arquivos abertos 
Privilégios 
Espaço de endereçamento de memória 
 
 Programa: código executável. 
 Contexto de hardware: características da execução. Armazena o conteúdo dos 
registradores responsáveis pelo controle dos registradores responsáveis pelo controle de 
execução do programa. 
 Contexto de software: características e limites do ambiente onde o programa será 
executado. Fazem parte do contexto de software: identificação, quotas, privilégios, 
identificação do usuário dono do processo. 
 Espaço de endereçamento de memória: área de memória alocada para execução do 
programa. 
 13 PROCESSOS 
Ciclo de Vida de um Processo 
 
Criação 
Quando um processo é criado? 
 Quando executamos um programa. 
 Quando um usuário acesso o sistema. 
 Quando um processo gera um processo-filho. (Exemplo: mouse-over em processo-filho com o 
seguinte texto: processo gerado internamente por outro processo) 
Etapas de criação: 
 Atribui um identificador único. 
 Aloca uma entrada na tabela de processos. 
 Aloca espaço para o processo. 
 Inicializa o PCB (Process Control Block). 
 Coloca o processo na fila apropriada. 
 Cria estruturas auxiliares. 
Execução 
A execução concorrente de processos leva às seguintes situações: 
 Troca de contexto; 
 Troca de modo de execução. 
Trocas de Contexto 
Substituição do processo em execução. 
Causas: 
 Interrupção: Reação a um evento assíncrono. 
 Trap: Associado a erro na execução de uma instrução. 
 System Call: Requisição explícita. 
Ações: 
 Salvo o estado do processador. 
 Muda o estado do processador. 
 Muda o processo para a fila apropriada. 
 Seleciona o novo processo. 
 Atualiza o PCB do novo processo. 
 Modifica os mapeamentos de memória. 
 Restaura o estado do processador. 
Trocas de Modo de Execução 
É uma troca menor e mais rápida que a troca de contexto. O estado do processo corrente não é 
alterado. 
Criação -> Execução -> Término 
 14 PROCESSOS 
Ocorre geralmente quando o processador, ao final de um ciclio de interrupção, detecta a existência 
de interrupção pendente. Nesses casos, o processador realiza os seguintes passos: 
 Salva o contexto do processo em execução. 
 Carrega o PC com o endereço inicial da rotina de interrupção. 
 Troca o modo de execução de usuário para kernel (privilegiado) para que a instruções 
privilegiadas do tratador de interrupções possam ser executadas. 
Término 
 Quando acaba o programa que está em execução. 
 Quando ocorre um erro. 
 Quando é forçado pelo usuário a terminar. 
Estados 
No que diz respeito aos estados de um processo, o diagrama mais comum possui cinco estados e é 
suficiente para o entendimento dos demais estados intermediários. Observe-o abaixo: 
 
 Novo: Estado de admissão onde são geradas as estruturas de dados e alocado espaço para o 
processo. O processo recém-criado é configurado como "pronto". 
 Pronto: Após a admissão, o processo está pronto para ser executado, mas aguarda sua vez. 
 Executando: Apenas um processo por vez pode estar nesse estado. Após ser selecionado, o 
processo recupera seu contexto que é guardado após ter sua execução interrompida. 
 Bloqueado: Um processo é bloqueado quando precisa aguardar um recurso. Esse bloqueio é 
síncrono, ou seja, sempre que o programa executar um determinado trecho, o bloqueio 
acontecerá. (Exemplo: acesso a disco) 
 Fim: Ao terminar a execução do processo, as estruturas criadas são removidas e a área 
alocada é liberada. 
 
 
Atenção 
A substituição do processo em execução é denominada troca de contexto. Quando o 
processo é interrompido, seu contexto é armazenado. Quando o processo retorna 
para o estado de execução, seu contexto é recuperado. 
Atenção 
O sistema operacional não pode provocar troca de contexto, uma vez que é um 
software e para gerar uma ação precisaria estar em execução. 
 15 PROCESSOS 
 
Tipos 
Os processos podem ser classificados em função de características de execução: 
 Processos CPU-Bound: São processos que passam a maior parte do tempo em estado de 
execução ou pronto. Realiza poucas operações de E/S. 
 Processos I/O-Bound: São processos que passam a maior parte do tempo em estado de 
espera, pois realizam um elevado número de operações de E/S. 
 Processos em Foreground: Permitem a comunicação direta do processo com o usuário 
durante sua execução. Em geral, o canal de entrada está associado ao teclado/mouse e de 
saída a um monitor. 
 Processos em Background: Processos em que não existe interação direta com o usuário. 
A estratégia utilizada para ordenar a execução de processos pode variar em função dos tipos de 
processo em um sistema. 
Síntese do Capítulo 
Você aprendeu: 
 O que é um processo. 
 Quais os componentes de um processo. 
 Quais são os estados de um processo. 
 Como ocorre a mudança de estado de um processo. 
Exercícios de Revisão 
1) Sobre o conceito de processos, marque a afirmação verdadeira. 
 Processo é a mesma coisa que programa. 
 Processo é um programa que está em execução. 
 Processo é uma característica do processador. 
 Processo é um programa armazenado no disco. 
2) Pode ser responsável pela troca de contexto. 
 Operação aritmética. 
 Interrupção por tempo provocada pelo temporizador. 
 Sistema operacional. 
 Outro programa que quer executar. 
Soluções 
1) Processo é um programa que está em execução. 
2) Interrupção por tempo provocada pelo temporizador. 
 
 
Atenção 
Não é possivel haver mudança de estado entre pronto e bloqueado. Se o processo 
está em estado de pronto, não está executando, logo, não poderá fazer nenhuma 
requisição. 
 16 THREADS 
3. THREADS 
Objetivos 
 Compreender os conceitos de threads. 
 Entender as diferenças entre um sistema operacional baseado em threads e outro baseado 
em processos. 
 Diferenciar os tipos de threads. 
 Identificar as oportunidades para uso de threads. 
Conceito 
Threads são fluxos de execução distintos dentro de um mesmo processo, um executável. 
Atualmente, uma thread é considerada a unidade de execução de um sistema ao invés do processo 
como um todo. 
Um processo pode ter uma ou mais threads. Veja o exemplo. 
 
Estrutura 
Um processo que contenha threads é composto pelo seu PCB (Process Control Block) e pelos blocos 
específicos para cada thread que contém uma estrutura de contexto de software e uma estrutura de 
contexto de hardware. 
 
Cada thread possui contextos próprios de hardware e software, porém compartilham o mesmo 
espaço de endereçamento alocado ao processo. 
 17 THREADS 
Vamos entender melhor. Pense em funções de um mesmo processo, onde todas as funções são 
capazes, por exemplo, de ver e alterar o conteúdo de variáveis globais. 
Vamos exemplificar com o seguinte trecho de programa: 
 
Como a variável x é visível por todas as funções, o valor final da variável x será 12. As funções 
enxergam a mesma área de memória. 
Nem toda função é uma thread. Quando utilizamos uma função, o módulo que fez a chamada deve 
aguardar o término da função para continuar. No exemplo, o resultado abaixo somenteserá exibido 
após o retorno da função. 
 
Se fosse uma thread (veremos mais tarde como criar uma), a exibição poderia ocorrer antes que a 
função terminasse. 
 
Uma thread pode ser imaginada como uma função de um programa que tem "vida própria" para a 
execução, mas não pode ser criada isoladamente. 
Para mais informações, leia o texto a seguir (Motivação para o uso de threads). 
Motivação Para o Uso de Threads 
Imagine a seguinte situação: 
Precisamos armazenar os tijolos produzidos por um equipamento que, ao término da fabricação de 
um tijolo, espera que haja alguém no final da esteira para pegá-lo. 
Se o procedimento de pegar o tijolo e levá-lo até o depósito for feito por uma única pessoa, 
provavelmente diversos tijolos caíram no chão enquanto essa pessoa leva um dos tijolos para o 
depósito. 
O que fazer? Se houver uma pessoa que fique na saída da esteira retirando os tijolos e os 
entregando para seus assistentes, a chance de que um tijolo caia no chão será muito reduzida, pois 
cada tijolo será entregue em um período de tempo constante ao assistente que o levará ao 
Atenção 
Pode gerar erros? A exibição poderia mostrar o resultado antes da função terminar. 
Esse tipo de problema será tratado em Comunicação entre Processos e é conhecido 
como condição de corrida. Calma! Tem solução. 
 18 THREADS 
depósito. O encarregado de pegar os tijolos está “a postos” em um tempo conhecido, permitindo, 
assim, calibrar o equipamento. 
Pode haver muitos assistentes congestionando o caminho? Sim, identificando que o caminho não é 
suficiente para a demanda. 
Pensando agora em uma aplicação, como um servidor para transferências de arquivos. Uma 
threadfica “a postos” para receber requisições que serão entregues a novas threadscriadas sob 
demanda para atender a cada uma das requisições. A cada requisição, uma nova threadé criada e a 
threadprincipal retorna imediatamente para aguardar novas requisições, evitando (ou reduzindo 
muito) o descarte de mensagens. Poderemos ter várias threadssendo executadas concorrentemente, 
podendo gerar um tempo de resposta maior, mas as requisições não serão perdidas. 
Só para registrar: esse tipo de servidor é chamado de servidor concorrente. 
As threads contribuem para o melhor uso dos recursos com: 
 Melhor aproveitamento da fatia de tempo: Permite que a execução do processo continue 
mesmo que algumas de suas Threads estejam bloqueadas. 
 Compartilhamento de Recursos: Threadscompartilham memória e outros recursos do 
processo. 
 Economia de tempo de gerenciamento: Threadssão mais econômicas de serem criadas e o 
custo da troca de contexto é menor. Todas as threadsde um mesmo processo compartilham 
o mesmo espaço de endereçamento. 
 Utilização de Múltiplos Processadores: Cada Threadpode ser executada em paralelo em um 
processador distinto. 
Tipos 
As threads podem ser classificadas em: 
 Threads de Kernel: As threads de Kernel são criadas e gerenciadas pelo kernel do sistema 
operacional, mas não podem ser diretamente utilizadas pelo usuário. 
O suporte a múltiplas threads é uma característica do sistema operacional. 
 Threads de Usuário: As threads de usuário facilitam aspectos de portabilidade e são criadas 
e gerenciadas por uma biblioteca no nível do usuário. 
O Kernel não enxerga essas threads e, por esse motivo, não podem ser gerenciadas 
individualmente. 
 
Processo Leve ou LWP 
A combinação entre os dois tipos de threads promove uma associação entre threads de usuário e de 
Kernel, porém a forma de associação depende do sistema operacional. 
Exemplos de bibliotecas de threads 
POSIX Pthreads, Win32 threads, Java threads. 
 19 THREADS 
 
 
Vamos conhecer agora os modelos de associação entre threads de usuário e de kernel. 
 
Muitos para um: 
 Gerenciamento da thread é feito no espaço do 
usuário; 
 Usadas em sistemas que não suportam threads; 
 Uma thread bloqueada bloqueia todo o 
processo. 
 
Um para um: 
 Cada thread de usuário é mapeada para uma 
Kernel thread; 
 Criar uma user thread requer a criação de uma 
thread de Kernel; 
 Algumas implementações restringem o número 
de threads suportada pelo sistema; 
 É utilizada pelo Windows e pelo Linux. 
Atenção 
Esta é a solução mais utilizada nos sistemas modernos. 
Pois o uso combinado de threads de usuário e de Kernel permite melhor 
aproveitamento do tempo de CPU, possibilidade de paralelismo e facilidade de 
programação. 
 20 THREADS 
 
Muitos para muitos: 
 Permite que várias threads de usuário sejam 
mapeadas para um número menor ou maior de 
threads de Kernel dinamicamente; 
 Permite que o SO crie um número suficiente de 
threads de Kernel. 
Síntese do Capítulo 
Você aprendeu: 
 O que é uma thread. 
 Quais os tipos de threads disponíveis e suas características. 
 As vantagens e desvantagens do uso de threads. 
Exercícios de Revisão 
1) Uma thread é a execução de um fluxo de processamento, isto significa que um processo pode 
ser composto por várias threads. Neste contexto é correto afirmar que: 
 Uma thread é equivalente a um processo filho, pois a execução de cada thread é 
independente. 
 Uma thread pode ser compartilhada por vários processos, pois o espaço de endereçamento é 
compartilhado. 
 Uma thread pode existir sem estar associada a um processo. 
 Threads de um mesmo processo podem ter suas execuções independentes e compartilham 
espaço de endereçamento de memória. 
2) Considere uma aplicação baseada em threads em um sistema operacional com suporte a 
threads. Se uma das threads for bloqueada por solicitar uma operação de E/S, as demais threads 
do mesmo processo: 
 Poderão continuar executando se não dependerem da thread que foi bloqueada. 
 Serão bloquedas também. 
 Não serão bloqueadas, mas ficarão aguardando o desbloqueio da thread que executou a 
operação de E/S. 
 Serão interrompidas, provocando um erro no processo. 
Soluções 
1) Threads de um mesmo processo podem ter suas execuções independentes e compartilham 
espaço de endereçamento de memória. 
2) Poderão continuar executando se não dependerem da thread que foi bloqueada. 
 
 
 21 COMUNICAÇÃO ENTRE PROCESSOS 
4. COMUNICAÇÃO ENTRE PROCESSOS 
Objetivos 
 Compreender o conceito de concorrência em sistemas multitarefa; 
 Entender os problemas gerados pelo compartilhamento de recursos; 
 Entender o conceito de condição de corrida; 
 Identificar regiões críticas em um programa; 
 Entender o que é exclusão mútua e seus mecanismos; 
 Entender os conceitos de deadlock e starvation identificando a possibilidade de ocorrência 
dessas duas situações. 
Motivação 
Processos e threads em sistemas multitarefa compartilham recursos. 
Aprendemos nos capítulos anteriores que processos e threads não executam direto, ou seja, desde o 
inicio até ao fim. Durante o tempo de execução, sofrem interrupções e ficam bloqueados 
aguardando recursos. 
Suponha que um Processo P1 está executando quando é interrompido 
pelo final da fatia de tempo. 
Outro Processo P2 será selecionado para execução e poderá querer 
utilizar o mesmo recurso que estava sendo utilizado por P1. 
E agora? 
 
Entendendo o exemplo 
Considere que as variáveis A e B, ambas iniciadas com o valor 1, são compartilhadas por duas 
threads de um mesmo processo e cada uma delas deverá executar: 
 Thread 1 Thread 2 
Linha 1 A = A * 2 B = B + 1 
Linha 2 B = B * 2 A = A + 1 
Quais serão as formas possíveis de execução? 
 22 COMUNICAÇÃO ENTRE PROCESSOS 
Caso 1 
 Thread 1 executa linha 1 e linha 2 
 Thread 2 executa linha 1 e linha 2 
 Resultado final: A = 3; B = 3 
Caso 2 
 Thread 2 executa linha1 e linha 2 
 Thread 1 executa linha 1 e linha 2 
 Resultado final: A = 4; B = 3 
Caso 3 
 Thread 1 executa linha 1 
 Thread 2 executa linha 1 e linha 2 
 Thread 1 executa linha 2 
 Resultado final: A = 3; B = 4 
Podemos perceber neste exemplo muito simples que obtivemos 3 resultados diferentes em função 
da ordem em que os processos ocorrem. Esse efeito é denominado condição de corrida. 
 
Há condição de corrida quando existem recursos compartilhados entre duas ou mais threads ou 
entre dois ou mais processos sem as devidas precauções. 
Entendendo uma Condição de Corrida 
O trecho do código que trata recursos compartilhados é denominado região crítica. 
No exemplo, ambas as threads utilizavam as variáveis A e B compartilhadas, então as duas linhas 
apresentadas formam uma região crítica. 
 
Repare que, no exemplo, a ordem de execução das threads, mesmo sem interrupção, já é suficiente 
para permitir resultados diferentes. 
A garantia de ordem de execução será alvo da próxima sessão deste capítulo. 
Condição de corrida 
Conjunto de eventos que geram resultados não determinísticos e deve 
ser evitada. 
O termo “condição de corrida” vem do fato da não previsibilidade do 
resultado de uma corrida onde a velocidade de execução de um 
processo não pode ser prevista, pois depende das atividades dos outros 
processos, da forma como o SO trata as interrupções e das estratégias 
de escalonamento adotadas. 
Região crítica 
Parte do código que trata recursos compartilhados e 
deve ser protegida de forma a garantir acesso 
exclusivo a um processo ou uma thread. 
 23 COMUNICAÇÃO ENTRE PROCESSOS 
Exemplo Prático 
Esse problema aconteceu realmente em um sistema operacional bem conhecido que utiliza uma fila 
de impressão para armazenar temporariamente os documentos que seriam impressos. Essa fila é 
implementada em uma área de memória do sistema operacional compartilhada entre todos os 
processos. 
Quando um processo deseja imprimir, deverá executar a seguinte rotina (fornecida como uma API 
do sistema operacional): 
 
 
 
Considere a seguinte situação: Processo 0 está sendo impresso e, em um determinado momento, o 
processo 1 também irá imprimir. 
1º passo: API irá ler a primeira posição livre da fila (será 1). 
2º passo: API irá incluir o arquivo na posição 1 da fila. 
3º passo: API irá atualizar a posição livre para 2. 
Voltamos para a situação inicial, só que agora utilizaremos dois processos concorrentes: Processo 0 
está sendo impresso e, em um determinado momento, o processo 1 também irá imprimir. 
1º passo: API irá ler a primeira posição livre da fila (será 1). 
2º passo: API irá incluir o arquivo na posição 1 da fila. 
3º passo: A fatia de tempo expira e ocorre uma troca de contexto, deixando a situação 
abaixo: 
 
1 
Ler posição livre da 
fila 
2 
Incluir o arquivo na 
posição indicada 
3 
Atualizar próxima 
posição livre 
API (Application Programming Interface) 
É um conjunto de rotinas para serem utilizadas por 
programas aplicativos sem que estes conheçam 
detalhes de sua implementação. 
 24 COMUNICAÇÃO ENTRE PROCESSOS 
Após a troca de contexto, o processo 2 é selecionado e também irá imprimir. Processo 2 executa a 
API de impressão para enviar um documento para a fila. 
1º passo: API irá ler a primeira posição livre da fila (será 1). 
2º passo: API irá incluir o arquivo na posição 1 da fila. 
3º passo: API irá atualizar a posição livre para 2. 
 
Para o processo 2, está tudo ok. Para o sistema operacional e para o gerenciador de impressão, está 
tudo ok, pois a primeira posição livre é realmente a posição 2. Para o processo 1, também está tudo 
ok – não houve erro; logo, não haverá registro de erro. 
Se está tudo certo, onde está o papel impresso do processo 1? "O gato comeu". 
Simplesmente sumiu sem deixar registros. Alguém já passou por isso? Se sim, agora já sabe que não 
foi culpa do usuário. É erro no código! 
Onde está o erro? 
Tanto a fila de impressão quanto a variável entrada são recursos compartilhados e este 
compartilhamento não está sendo tratado, fazendo com que em determinadas sequências de 
eventos o resultado não seja o esperado. 
Como Evitar a Ocorrência de uma Condição de Corrida 
Para garantir o acesso exclusivo a uma região crítica, será necessário utilizarmos mecanismos que 
garantam a exclusão mútua entre processos e/ou threads. 
 
Para implementação de um mecanismo de exclusão mútua, utilizaremos um protocolo de acesso e 
um protocolo de saída de uma região crítica. Esse protocolo poderá ser baseado em soluções 
algorítmicas, em características do processador ou em primitivas do sistema operacional. 
O código da estrutura ficaria: 
 
De acordo com o exemplo anterior: 
Mecanismo de Exclusão Mútua 
Solução que impede que dois ou mais processos tenham acesso a uma 
mesma região crítica, ou seja, impede acesso simultâneo a um 
determinado recurso. 
Nota: acesso simultâneo a região crítica não é a mesma coisa que 
execução simultânea. 
ENTRAR_RC() 
 Código da região crítica 
SAIR_RC() 
 25 COMUNICAÇÃO ENTRE PROCESSOS 
 
Os mecanismos que implementam a exclusão mútua podem colocar o processo que não deve ter 
acesso ao recurso em “espera ocupada” (busy wait) ou bloqueá-lo ao executar a função 
ENTRAR_RC e deverá permitir o acesso ou desbloqueá-lo ao executar a função SAIR_RC. 
 
 
Para que um mecanismo de exclusão mútua seja efetivo, deve garantir que: 
 Somente um processo por vez possa executar uma região crítica. 
 Um processo interrompido fora de uma região crítica não possa impedir que outro processo 
tenha acesso a essa região crítica. 
 Não possa haver nem deadlock nem starvation. 
 Quando não houver processo executando uma região crítica, qualquer processo que solicitar 
acesso deverá obtê-lo imediatamente. 
 Um processo deve permanecer executando uma região crítica por tempo finito. 
 Nada possa ser assumido sobre a velocidade relativa e dos processos nem o número de 
processadores. 
 
 
 
 
ENTRAR_RC() 
 Ler posição livre da fila 
 Incluir o arquivo na posição indicada 
 Atualizar próxima posição livre 
SAIR_RC() 
Espera Ocupada 
O processo em espera ocupada continua no estado de pronto e, a cada 
execução, tenta continuamente o acesso à região crítica. Esse 
procedimento consome tempo de CPU desnecessariamente. 
Bloqueio 
O processo será bloqueado e, é acordado quando 
o acesso a região crítica estiver liberado. 
Deadlock 
(Impasse) Situação em que dois ou mais processos entram em um impasse 
aguardando um recurso que nunca estará disponível. Essa situação só é 
desfeita por um agente externo (Exemplo: interromper um dos processos). 
Starvation 
Condição em que não há garantia de execução de um processo. 
A execução pode ser adiada por um tempo indeterminado. 
Atenção 
Atenção para as condições de 
ocorrência de deadlock 
 26 COMUNICAÇÃO ENTRE PROCESSOS 
Condições necessárias: 
 Exclusão mútua; 
 Posse e espera (hold & wait); 
 Não preempção. 
Condição suficiente: 
Espera circular: 
 Os processos P1 e P2 precisam dos recursos R1 e R2 para executar. 
 P1 está de posse de R1 e aguardando R2. P1 não executará enquanto não obtiver R2; logo, 
não liberará R1. 
 P2 está de posse de R2 e aguardando R1. P2 não executará enquanto não obtiver R1; logo, 
não liberará R2. 
 
 
Síntese do Capítulo 
Você aprendeu: 
 O que é concorrência entre processos. 
 Quais os efeitos de uma condição de corrida. 
 Como uma condição de corrida pode ser evitada. 
 Os conceitos de deadlock e starvation 
Exercícios de Revisão 
1) A condição de corrida é derivada de: Aplicações concorrentes que não garantem exclusão mútua às regiões críticas. 
 Aplicações baseadas em threads. 
 Sistemas operacionais sem suporte à múltiplas threads. 
 Aplicações em sistemas monotarefa que tentam executar ao mesmo tempo. 
 27 COMUNICAÇÃO ENTRE PROCESSOS 
2) Preciso de giz e apagador para a aula. Peguei a caixa de giz, mas parei para conversar. Ao 
tentar pegar o apagador fiquei sabendo que outro professor, que só daria aula no segundo 
tempo, pegou o apagador e aguardava a caixa de giz que não estava sobre a mesa. Não sabia 
quem era o outro professor então fiquei esperando que fosse devolvido. Como iria ter aula no 
segundo tempo, resolvi guardar o giz e esperar o apagador. Esta situação retrata: 
 Uma condição de corrida. 
 Um deadlock em função da exclusão mútua no acesso aos dois recursos. 
 Um evento que será solucionado assim que terminar a aula. 
 Um deadlock que poderá ser solucionado indo em busca do apagador e arrancando-o da mão 
do professor. 
Soluções 
1) Aplicações concorrentes que não garantem exclusão mútua às regiões críticas. 
2) Um deadlock em função da exclusão mútua no acesso aos dois recursos. 
 
 
 28 SINCRONIZAÇÃO ENTRE PROCESSOS 
5. SINCRONIZAÇÃO ENTRE PROCESSOS 
Objetivos 
 Aprender o funcionamento dos principais mecanismos de exclusão mútua para acesso a uma 
região crítica. 
 Aprender como processos podem ser sincronizados para garantir uma determinada ordem de 
execução. 
 Entender o problema do produtor/consumidor 
Mecanismos de Exclusão Mútua 
A utilização de mecanismos de exclusão mútua é necessária para impedir o acesso a uma região 
crítica por mais de um processo evitando, assim, condições de corrida. 
Os mecanismos estão divididos em três categorias baseados em: 
 Algoritmos; 
 Características de hardware; 
 Primitivas do sistema operacional. 
A implementação de um mecanismo de exclusão mútua implica a utilização de um protocolo de 
acesso à região crítica e um protocolo de saída da região crítica. 
 
Mecanismos Baseados em Algoritmos 
A primeira abordagem baseada em algoritmos possui uma estrutura muito simples onde uma variável 
compartilhada determina se a região crítica está ou não livre. Essa solução possui diversas 
limitações, como veremos a seguir. 
Considere a variável global vez e os processos P0 e P1 disputando uma região crítica: 
Processo 0 
while turn = 0 do { } 
 <RC> 
vez = 1 
Processo 1 
while turn = 1 do { } 
 <RC> 
vez = 0 
 
 ENTRAR_RC 
 
 SAIR_RC 
Um dos processos permanece em espera ocupada até que o outro saía da região crítica executando, 
altere o valor da variável vez permitindo que o outro processo saia do loop e execute a região 
crítica. 
Essa abordagem possui diversos incovenientes: 
 É baseada em espera ocupada. 
 Processos se alternam no uso de suas respectivas RCs, fazendo com que o tempo de 
execução seja ditado pelo processo mais lento. 
 Somente pode ser utilizada por dois processos. 
ENTRAR_RC 
 Acesso ao recurso compartilhado 
SAIR_RC 
 29 SINCRONIZAÇÃO ENTRE PROCESSOS 
 Se um dos processos falhar (abortar, por exemplo), o outro jamais poderá entrar em sua RC 
novamente, pois a variável vez não será alterada, contrariando uma das regras de 
implementação de mecanismos de exclusão mútua. 
Diversos algoritmos foram propostos, porém, até a quarta versão, esses algoritmos apresentavam 
problemas que feriam os princípios de exclusão mútua. 
A primeira solução que garantiu a exclusão mútua entre dois processos foi proposta por Dekker e 
possui uma lógica bastante complexa. Esse algoritmo foi simplificado posteriormente por Peterson 
generalizando o código para n processos. 
Veremos a seguir o Algoritmo de Peterson. 
Algoritmo de Peterson 
Apresenta uma solução para dois processos que pode ser generalizada para N processos. 
1. Antes de acessar a região crítica, o processo sinaliza esse desejo através de uma variável 
booleana flag. 
2. Porém o processo cede o uso do recurso ao outro processo indicado pela variável vez. 
3. Em seguida, o processo executa um loop até a obtenção da variável vez. 
Processo 0 
flag[0] = true 
vez = 1 
while flag[1] and vez = 1 { } 
 <RC> 
flag[0] = false 
Processo 1 
flag[1] = true 
vez = 0 
while flag[0] and vez = 0 { } 
 <RC> 
flag[1] = false 
 
 
 
 ENTRAR_RC 
 
 SAIR_RC 
Mecanismos Baseados em Características de Hardware 
São mecanismos que utilizam determinadas instruções do processador para a implementação de 
exclusão mútua. Iremos estudar duas soluções. 
Inibir Interrupções 
É a solução mais simples para o problema de exclusão mútua, pois permite que um processo 
desligue o recebimento de interrupções antes da execução de uma região crítica, impedindo a troca 
de contexto. As interrupções são novamente habilitadas após o término da região crítica. 
Nesse exemplo, serão utilizadas as instruções da família de processadores x86 para desligar (cli) e 
ligar(sti) as interrupções: 
CLI 
 <RC> 
STI 
 ENTRAR_RC 
 
 SAIR_RC 
Essa solução apresenta alguns problemas: 
 Não habilitar as interrupções por erro de programação (só desligando o computador!); 
 Como somente as interrupções do processador que executou a instrução são desabilitadas, não 
garante exclusão mútua em sistemas multiprocessados. 
 Uma aplicação de usuário não deve ter privilégios para executar essa operação. 
 30 SINCRONIZAÇÃO ENTRE PROCESSOS 
Instruções TSL 
São instruções atômicas que executam a leitura de uma variável utilizada para lock, armazenando 
temporariamente seu valor em um registrador. 
Sem sofrer interrupção, essa instrução valida o conteúdo da variável e faz a alteração se necessário. 
Veja a implementação dessa instrução: 
ENTRAR_RC 
 TSL RX, LOCK 
 CMP RX, #0 
 JNE ENTRA_RC 
 RET 
 
SAIR_RC 
 MOV LOCK, #0 
 RET 
O valor 0 (zero) significa que a região crítica está livre, o valor é configurado para 1 e o acesso é 
obtido. 
Se, ao tentar o acesso, o valor está em 1, o processo permanece em espera ocupada até que o valor 
da variável seja configurado para 0 (zero) pela execução de SAIR_RC. 
Essa implementação apresenta as seguintes características: 
 Utiliza espera ocupada; 
 Possibilidade de starvation; 
 Seleção arbitrária; 
 Deve garantir exclusividade no uso do barramento para multiprocessadores. 
Mecanismos Baseados em Primitivas do Sistemas Operacional 
Nessa categoria, estão incluídas três implementações: 
 Semáforos 
 Um processo é suspenso enquanto não obtém acesso a região crítica. 
 O processo bloqueado é acordado através de um sinal. 
 Monitores 
 O monitor é composto de várias rotinas cujas variáveis somente são acessadas dentro do 
monitor. 
 Um processo entra no monitor chamando uma das suas rotinas. 
 Somente um processo entra no monitor de cada vez. 
 Troca de Mensagens 
 Utilizado também em sistemas distribuídos. 
 Utiliza primitivas send e receive para o envio e recebimento de mensagens. 
 As primitivas podem ou não bloquear o processo. 
 Considere um receive bloqueante e um send não bloqueante. O processo deve aguardar 
um send para liberar o processo bloqueado na instrução receive. 
Os semáforos serão alvo de estudo mais detalhado. 
 31 SINCRONIZAÇÃO ENTRE PROCESSOS 
Detalhando os Semáforos 
O conceito de semáforo foi proposto por Dijkstra para implementação de exclusão mútua e 
sincronização condicional entre processos. 
 
 
Regras de acesso do semáforo: 
 O semáforo deve ser inicializado com um valor não negativo. 
 A operação wait decrementa o semáforo; se o valor ficar negativo o processo é bloqueado. 
 A operação signal incrementa o semáforo;se o valor não ficar positivo o processo bloqueado 
pela operação wait é desbloqueado. 
Vamos ver um exemplo: 
Considere P0, P1 e P2 três processos que desejam acesso a uma região crítica e s o semáforo que 
controla esse acesso, inicializado com 1. 
O acesso à região crítica é dado por: 
 
P0 
Executa wait(s) então s = 0 
Região Crítica 
P1 
Executa wait(s) então s = -1 
BLOQUEIO 
P2 
Executa wait(s) então s = -2 
BLOQUEIO 
Executa signal(s) então s = -1 
Desbloqueia P1 
Região Crítica 
Executa signal(s) então s = 0 
Desbloqueia P2 
Região Crítica 
Executa signal(s) então s = 1 
Sincronização Condicional Utilizando Semáforos 
Além de permitirem a implementação de exclusão mútua, os semáforos também podem ser 
utilizados para sincronização condicional entre processos. 
Um processo é suspenso 
enquanto não obtém permissão 
para executar uma RC e é 
automaticamente "acordado" 
através de um sinal. 
Para liberar um semáforo "s" o 
processo deve executar uma 
primitiva signal(s) e para obter 
acesso a RC, via o semáforo "s", 
o processo deve executar uma 
primitiva wait(s). 
Atenção 
Um semáforo é uma estrutura de dados composta por um 
contador e uma fila que registra os processos pendentes em 
ordem de solicitação. 
O semáforo possui regras de acesso. 
Wait(s) 
 Região Crítica 
Signal(s) 
 32 SINCRONIZAÇÃO ENTRE PROCESSOS 
 
Um problema clássico que exemplifica essa função é o Problema do produtor/consumidor. 
O problema do produtor/consumidor pode ser dividido em duas etapas: 
1. O processo produtor pode produzir incondicionalmente colocando itens em um buffer área de 
armazenamento), mas o consumidor só pode consumir se existirem itens produzidos e 
armazenados no buffer. 
2. Ambos os processos sofrem restrições. Existe uma capacidade máxima para produção, limitada 
ao tamanho da estrutura de armazenamento (buffer). 
Vamos ver agora dois casos. Em ambos os casos, o acesso ao buffer deve ser exclusivo somente pode 
ser acessado por um processo de cada vez. 
Caso 1 
Problema do produtor/consumidor com buffer de armazenamento infinito. 
Neste problema, serão utilizados dois semáforos: 
 s - exclusão mútua 
 n - controle de consumo 
Inicialmente s = 1 e n = 0 
(Região crítica liberada e não há itens para consumo) 
Produtor(i) { 
 while(T) { 
 produz_item() 
 wait(s) 
 adiciona_item() 
 signal(s) 
 signal(n) 
 } 
} 
 
Consumidor(i) { 
 while(T) { 
 wait(n) 
 wait(s) 
 remove_item() 
 signal(s) 
 consome_item() 
 } 
} 
Execução 
1. Se o consumidor executar primeiro: ao executar wait(n), decrementará o valor de n (que é 
zero), ficando negativo. O processo será bloqueado. 
Sincronização Condicional 
Um processo precisa de um resultado de outro processo 
para que possa continuar sua execução. 
 33 SINCRONIZAÇÃO ENTRE PROCESSOS 
2. Quando um produtor executar, obterá acesso à região crítica incluindo um item no buffer e 
sinalizando que há itens produzidos incrementando o valor de n (signal n). Pelo algoritmo da 
função signal, o processo que está bloqueado será acordado. 
Rotina Ação Valor de N Valor de S Resultado 
C wait(n) -1 1 Bloqueado 
P wait(s) -1 0 Acessa RC 
 signal(s) -1 1 Saída da RC 
 signal(n) 0 1 Libera consumidor 
C wait(s) 0 0 Acessa RC 
 signal(s) 0 1 Libera RC 
Caso 2 
Problema do produtor/consumidor com buffer de armazenamento finito. 
Esse problema é semelhante ao anterior, porém será necessário outro semáforo de sincronização 
que controle os espaços vazios no buffer. Têm-se então três semáforos: 
 s - exclusão mútua 
 n - controle de consumo 
 v - controle de espaços vazios 
Inicialmente s = 1, n = 0 e v = tamanho do buffer 
(Região crítica liberada, não há itens para consumo e todos os espaços estão livres) 
Produtor(i) { 
 while(T) { 
 produz_item() 
 wait(v) 
 wait(s) 
 adiciona_item() 
 signal(s) 
 signal(n) 
 } 
} 
 
Consumidor(i) { 
 while(T) { 
 wait(n) 
 wait(s) 
 remove_item() 
 signal(s) 
 consome_item() 
 signal(v) 
 } 
} 
Execução 
 O produtor executará v vezes até que o buffer esteja cheio. Ao tentar executar mais uma vez, 
ficará bloqueado. 
 34 SINCRONIZAÇÃO ENTRE PROCESSOS 
 Quando um consumidor executar, obterá acesso a região crítica removendo um item no buffer e 
sinalizando que há espaço disponível incrementando o valor de v (signal v). Pelo algoritmo da 
função signal, o processo que está bloqueado será acordado. 
 Suponha que o buffer possua três posições (v=3): 
Rotina Ação Valor de N Valor de S Valor de V Resultado 
P wait(v) 0 1 2 Diminui os espaços vazios 
 wait(s) 0 0 2 Acessa RC 
 signal(s) 0 1 2 Libera RC 
 signal(n) 1 1 2 Incrementa n 
 
 wait(v) 1 1 1 Diminui os espaços vazios 
 wait(s) 1 0 1 Acessa RC 
 signal(s) 1 1 1 Libera RC 
 signal(n) 2 1 1 Incrementa n 
 
 wait(v) 2 1 0 Diminui os espaços vazios 
 wait(s) 2 0 0 Acessa RC 
 signal(s) 2 1 0 Libera RC 
 signal(n) 3 1 0 Incrementa n 
 wait(v) 3 1 -1 Bloqueado 
C wait(n) 2 1 -1 Consome um item 
 wait(s) 2 0 -1 Acessa RC 
 signal(s) 2 1 -1 Libera RC 
 signal(v) 2 1 0 Libera produtor bloqueado 
Síntese do Capítulo 
Você aprendeu: 
 Como funciona uma solução baseada em algoritmo e os problemas encontrados. 
 Como características do processador podem ser utilizadas na implementação de exclusão 
mútua. 
 O que são semáforos e como utilizá-los para garantir exclusão mútua. 
Exercícios de Revisão 
1) Considere o problema do produtor/consumidor com buffer infinito (caso 1). O que acontece se 
trocarmos de posição as linhas wait(n) e wait(s) na rotina consumidor? 
 Deadlock 
 Condição de corrida 
 Starvation do produtor 
 Não faz diferença a ordem em que estas linhas são executadas 
 35 SINCRONIZAÇÃO ENTRE PROCESSOS 
2) Considerando o problema do produtor/consumidor com buffer finito (caso 2), o que acontece se 
trocarmos de posição as linhas signal(n) e signal(s) na rotina produtor? 
 Condição de corrida. 
 Deadlock. 
 Starvation do consumidor. 
 Não faz diferença a ordem em que estas linhas são executadas. 
Soluções 
1) Deadlock. 
2) Não faz diferença a ordem em que estas linhas são executadas. 
 
 
 36 GERÊNCIA DE TEMPO DE CPU 
6. GERÊNCIA DE TEMPO DE CPU 
Objetivos 
 Entender os objetivos da gerência de um recurso. 
 Entender o que são estratégias de alocação (escalonamento) de processador. 
 Conhecer as estratégias de alocação usuais. 
 Conhecer os critérios de avaliação de desempenho de uma estratégia de escalonamento. 
Escalonamento 
Escalonar é uma função do Sistema Operacional que consiste em escolher (determinar) dentre os 
processos candidatos aquele que: 
 Ganhará acesso ao ambiente de processamento 
 Será retirado do ambiente de processamento 
 Ganhará a posse da CPU 
Esta tarefa do sistema operacional é de fundamental importância em sistemas multitarefa. 
Estratégias de Escalonamento 
A estratégia de escalonamento adotada deverá: 
 Manter o processador ocupado a maior parte do tempo possível 
 Balancear o tempo de CPU entre as tarefas 
 Oferecer tempos de resposta razoáveis 
 Maximizar a taxa de atendimento (vazão) do sistema (throughput) 
 
 
 
Atenção: 
É importante lembrar que o escalonador só pode 
executar quando o processo que estiver 
utilizando o processador for interrompido ou 
bloqueado. 
A tarefa é executada por um processo 
do sistema operacional denominadoescalonador 
(scheduler). 
Escalonador 
Processo do sistema operacional responsável por 
indicar o próximo processo que será executado dos 
que estiverem prontos para execução segundo uma 
estratégia pré-definida. 
 37 GERÊNCIA DE TEMPO DE CPU 
 
 
Tipos de Estratégia 
As políticas de escalonamento podem ser classificadas segundo a possibilidade do Sistema 
Operacional permitir ou não a interrupção de um processo em execução e substituí-lo por outro. 
 Escalonamento Preemptivo: O escalonamento preemptivo permite que um evento 
externo posso interromper o processo em execução e colocá-lo no estado de pronto para 
que outro processo possa ter direito a execução. 
 Escalonamento NÃO Preemptivo: O escalonamento não preemptivo é utilizado 
tipicamente me processamento em batch. Quando um processo está em execução 
nenhum evento externo poderá interrompe-lo. O processo só deixa o estado de 
execução se terminar ou se executar alguma instrução que o coloque em bloqueio. 
Critérios de Escalonamento 
Existem 5 critérios de escalonamento: 
 FCFS 
 Sem preempção 
 Processos são executados na ordem de chegada 
 Processos curtos podem esperar em demasia 
 Favorece processos CPU-bound 
 Processos I/O-bound esperam processo CPU-bound terminar ou ficar 
bloqueado. Quando este fica bloqueado, a CPU fica ociosa. 
 Prioridade 
 Cada processo recebe uma prioridade ao ser iniciado. 
 O escalonador seleciona o processo pronto de maior prioridade. 
 Existem várias filas “pronto”, uma para cada nível de prioridade. 
 Processos de baixa prioridade podem sofrer Starvation. 
 Uma solução possível é mudar dinamicamente a prioridade de acordo com a “idade” 
ou o histórico de execução do processo. 
 SJF 
 Política sem preempção. 
 Baseado em estimativa do tempo de execução. 
 Processo com o tempo esperado de execução menor é selecionado primeiro. 
 Favorece processos curtos em detrimento dos longos. 
 Utilizado em sistemas batch. 
 Round Robin (Circular) 
 Usa preempção baseado num “Quantum”(time slice, fatia de tempo). 
Dispatcher 
Processo do sistema operacional responsável 
pela troca de contexto. 
Atenção 
Pode haver conflito de interesses: Usuário quer 
que seu processo termine logo (tempo de 
resposta baixo) e sistema quer que vários 
processos sejam atendidos. (throughput alto). 
 38 GERÊNCIA DE TEMPO DE CPU 
 Busca democratizar a distribuição do tempo da CPU. 
 Quantum: tempo máximo que um processo pode executar sem Interrupção: 
 Muito curto: maior o overhead de escalonamento. 
 Muito longo: degenera em FCFS. 
 Múltiplas Filas com Realimentação 
 Penaliza os processos executados há mais tempo. 
 Utiliza múltiplas filas com prioridades dinâmicas**. 
 Favorece processos curtos e I/O bounded. 
 Prioridades dinâmicas. São duas: 
1º - A cada ciclo de execução a prioridade diminui. 
2º - Starvation: prioridade menor implica em quantum maior ou muita 
espera aumenta a prioridade. 
Critérios de Escalonamento 
Critério de escalonamento: conjunto de regras que indicará qual o próximo processo que será 
executado. 
FCFS - Ordem de Chegada 
 1 5 10 15 20 
P1 
P2 
P3 
P4 
P5 
 
Round Robin 
 1 5 10 15 20 
P1 
P2 
P3 
P4 
P5 
 
SJF - Processo Mais Curto 
 1 5 10 15 20 
P1 
P2 
P3 
P4 
P5 
 39 GERÊNCIA DE TEMPO DE CPU 
Atividade Proposta 
Calcule o tempo estimado de cada resposta. Para simplificar os cálculos serão desconsiderados os 
tempos de troca de contexto e a diferença de tempos entre as inserções de cada processo. 
ID do processo (em ordem) Tempo estimado 
A 200 
B 100 
C 50 
D 20 
Considerações importantes para o cálculo de tempo de resposta 
1) FCFS: Computar a soma dos tempos de espera considerando a ordem de chegada e de 
processamento . Para fins de simplificação pode-se considerar que a diferença do instante de 
criação de cada processo é nula. 
2) Prioridade: Não é utilizado sozinho. Para fins de exercício é semelhante ao FCFS porém a ordem 
de execução é dada pela prioridade e não pela ordem de chegada. 
3) SJF: Também é não-preemptivo e a ordem de execução é dada pelo tamanho estimado do 
processo (o menor primeiro). 
4) Round Robin (Circular): Os processos são atendidos na ordem de chegada mas após atingirem o 
tempo máximo permitido (fatia de tempo) são recolocados no final da fila. O retorno de uma 
operação de E/S pode alterar a ordem de execução. (Calcule do tempo de resposta para as 
estratégias FCFS, Round Robin e SJF. Para simplificar os cálculos serão desconsiderados os 
tempos de troca de contexto e a diferença de tempos entre as inserções de cada processo). 
5) Múltiplas filas com realimentação: Cada processo é inicialmente colocado na fila de maior 
prioridade e menor fatia de tempo. Ao término da fatia é recolocada na fila com prioridade 
menor que a primeira mas com uma fatia de tempo maior e assim sucessivamente (depende do 
numero de filas). Ao executar uma operação de E/S o processo retorna a fila onde estava. 
Soluções 
 FCFS 
ID do processo (em ordem) Tempo estimado Tempo de resposta 
A 200 200 
B 100 300 (esperou 200) 
C 50 350 (esperou 300) 
D 20 370 (esperou 350) 
 SJF 
ID do processo (em ordem) Tempo estimado Tempo de resposta 
D 20 20 
C 50 70 (esperou 20) 
B 100 170 (esperou 70) 
A 200 370 (esperou 370) 
 40 GERÊNCIA DE TEMPO DE CPU 
 Round Robin 
Para esta estratégia será necessário definir qual será a fatia de tempo. Neste exemplo a 
fatia de tempo será de 10 ms. 
Para facilitar a visualização, a tabela será dividida em ciclos e o tempo de resposta 
calculado somente no final. 
Execução: ciclo 1 > ciclo 2 > ciclo 3 > ciclo 4 > ciclo 5 > ... > ciclo 20 
A 10 10 10 10 10 10 10 10 10 10 ... 10 > Tempo de resposta = 370ms 
B 10 10 10 10 10 10 10 10 10 10 > Tempo de resposta = 270ms 
C 10 10 10 10 10 > Tempo de resposta = 170ms 
D 10 10 > Tempo de resposta = 80ms 
Síntese da Aula 
Você aprendeu: 
 Quais as estratégias utilizadas para alocação do processador. 
 Como avaliar uma solução de escalonamento. 
 Como estimar o tempo de resposta de um processo em função da estratégia de 
escalonamento. 
Exercícios de Fixação 
1) Cinco jobs, A, B, C, D e E, em batch, chegam ao computador com 1 segundo de intervalo entre 
eles. Seus tempos de processamento são estimados em 10, 7, 3, 4 e 5 segundos de CPU, 
respectivamente. Sendo round-robin a política de escalonamento utilizada, com um time-slice 
de 1 segundo, o tempo médio de turnaround desses processos (ignorando overheads de troca de 
contexto e interrupções e assumindo que um job recém-chegado é colocado no início da fila, ou 
seja, na frente dos outros) é: 
 25,5 segundos 
 13,1 segundos 
 10,0 segundos 
 19,6 segundos 
2) Throughput é: 
 A taxa de utilização da CPU 
 O tempo que um processo leva desde a sua admissão até o seu término 
 O número de processos executados em um determinado intervalo de tempo 
 A fração de tempo de CPU dada a um determinado processo 
3) O escalonamento de processos nos sistemas operacionais baseia-se em escalonadores 
_______________ e _____________. No primeiro caso, os escalonadores aceitam a suspensão 
_____________ da execução de um processo.No segundo caso, quando um processo obtém o 
processador, o mesmo executa até ____________, ou até que o processo peça uma operação 
que ocasione o seu bloqueio. 
Indique a opção que completa, respectivamente e de forma correta, as lacunas acima. 
 não-preemptivos, com preempção, temporária, a metade 
 com preempção, não-preemptivos, temporária, o fim 
 com preempção, não-preemptivos, definitiva, a metade 
 não-preemptivos, com preempção, definitiva, o fim 
 41 GERÊNCIA DE TEMPO DE CPU 
Soluções 
1) 19,6 segundos 
2) O número de processos executados em um determinado intervalo de tempo 
3) com preempção, não-preemptivos, temporária, o fim 
 
 
 42 GERÊNCIA DE ALOCAÇÃO DE MEMÓRIA 
7. GERÊNCIA DE ALOCAÇÃO DE MEMÓRIA 
Objetivos 
 Entender os objetivos da gerência de alocação de memória 
 Conhecer as estratégias de alocação de espaço na memória principal. 
 Entender as características de cada método de alocação. 
Conceito 
Alocar memória consiste em subdividir e alocar espaços para acomodar os processos em 
execução. É necessário que haja uma estratégia definida para esta tarefa porque: 
 Espaços são solicitados e liberados em função da execução de cada tarefa. 
 Cada processo precisar ter seu espaço protegido. 
 Pode ser necessário compartilhar informações com outros processos. 
Abordaremos, neste capítulo, as formas de organização lógica do espaço de memória. A 
organização lógica é a visão do sistema operacional em relação à alocação dos processos. 
Estratégias de Organização Lógica do Espaço de Memória 
Existem cinco estratégias de organização lógica do espaço de memória: 
 Contíguo Simples 
 Estático 
 Estático Relocável 
 Dinâmico 
 Paginado 
 Segmentado 
Contíguo Simples 
Somente uma partição da memória é criada para apenas um único processo. Parte da memória é 
ocupada pelo sistema operacional e outra parte para o processo em execução. 
Este modelo somente pode ser utilizado em sistema monotarefa que não são mais utilizados. 
 
Estático 
Implementação simples em que cada processo recebe um endereço fixo de uma partição para 
executar denominado endereço absoluto. 
 43 GERÊNCIA DE ALOCAÇÃO DE MEMÓRIA 
 
Apresenta baixo desempenho e fragmentação interna. 
 
Processos em fila externa para execução 
 
Estático Relocável 
Semelhante ao particionamento estático, porém os processos podem ser alocados em qualquer 
partição. 
Processos em fila externa para execução 
 
Dinâmico 
A estratégia de alocação dinâmica permite o particionamento sob demanda, ou seja, a partição é 
criada durante a alocação do processo exatamente do tamanho que será utilizada. 
Essa estratégia evita a fragmentação interna, mas permite a ocorrência de fragmentação externa, 
ou seja, fragmentação entre as partições. 
Cada partição recebe apenas um processo e cada 
processo somente poderá utilizar uma partição. 
As partições possuem tamanho fixo determinado na 
inicialização do sistema operacional. 
Fragmentação interna 
Espaço na utilizado dentro de uma partição 
 44 GERÊNCIA DE ALOCAÇÃO DE MEMÓRIA 
 
 
Paginado 
A memória é particionada em pedaços de tamanho igual, assim como os processos. 
Os pedaços que compõem os processos são chamados de  Páginas 
Os pedaços que compõem a memória são chamados de  Molduras de Páginas (Frames) 
Quando um processo é carregado, suas páginas são alocadas em quaisquer molduras disponíveis, não 
necessariamente contíguas. 
Estratégias de Organização Lógica do Espaço de Memória - Paginado 
 Quando um processo é carregado, suas páginas são alocadas em quaisquer molduras disponíveis, 
não necessariamente contíguas. 
 O sistema operacional precisa manter uma tabela de páginas por processo e uma lista de 
molduras disponíveis. 
 Cada processo pode ter fragmentação interna apenas na última página. 
 
Fragmentação externa 
Ocorre em função da diferença do espaço necessário para cada 
processo, permitindo que, ao reutilizar um espaço, parte dele 
não seja ocupado formando buracos. Como esse espaço pode ser 
muito pequeno, ficaria sem utilização posterior. 
Essa fragmentação é menos prejudicial, pois os espaços vazios 
contíguos serão reagrupados. 
 45 GERÊNCIA DE ALOCAÇÃO DE MEMÓRIA 
Tradução de Endereço Lógico em Endereço Físico 
Cada endereço lógico é composto por duas partes: 
Identificação da página onde está o endereço Deslocamento dentro da página 
Cada página é alocada em uma moldura, então cada página precisa estar mapeada para uma 
moldura. 
O deslocamento é o mesmo na página e na moldura já que são do mesmo tamanho. 
Exemplo: O terceiro endereço da pagina x será o terceiro endereço da moldura que recebeu a 
página. 
Considere o exemplo de tradução de endereço: 
 Cada endereço possui 16 bits, sendo 10 para deslocamento e 6 para identificação da página. 
 A quantidade de bits utilizada para o offset é a mesma para o endereço lógico e para o 
físico uma vez que página e moldura possuem o mesmo tamanho. 
 Com 10 bits de tamanho de página, podemos afirmar que cada página possui 210 endereços. 
 Se cada endereço ocupar 32 bits (4 bytes), podemos afirmar que a página ocupa 4 x 210 
bytes, ou seja, 4KB. 
 Como foram utilizados 6 bits para indicação da página, podemos afirmar que cada processo 
pode ter no máximo 26 páginas, ou seja, 64 páginas. 
 Como cada processo possui 26 páginas e cada página possui 4KB (22 x 210 bytes), o tamanho 
máximo de um processo é de 26 x 22 x 210 bytes que é igual a 28 x 210 bytes ou 256KB. 
 
Segmentado 
Cada programa é subdividido em blocos de diferentes tamanhos chamados segmentos. 
Quando um processo é carregado para a memória principal, cada segmento diferente pode ocupar 
qualquer lugar. 
O S.O. mantém uma tabela de segmentos de cada processo. Cada entrada contém: 
 O início do endereço físico daquele segmento. 
 O tamanho do segmento (por proteção). 
Apresenta fragmentação externa. 
 46 GERÊNCIA DE ALOCAÇÃO DE MEMÓRIA 
Tradução de Endereço Lógico em Endereço Físico 
Semelhante à tradução para memória paginada, exceto pela informação adicional do tamanho do 
segmento. 
 
Síntese do Capítulo 
Você aprendeu: 
 Quais as formas de alocação de memória para os processos ativos. 
 Quais as vantagens e desvantagens de cada estratégia. 
 A diferença entre endereçamento lógico e endereçamento físico. 
Exercícios de Fixação 
1) Considere um sistema baseado em memória paginada com endereço lógico de 32 bits sendo 8 
bits utilizados para identificação da página e os demais para o offset. Quantos endereços cada 
página possui? 
 16M 
 2M 
 24M 
 4K 
2) Considere um sistema baseado em memória paginada com endereço lógico de 32 bits sendo 8 
bits utilizados para identificação da página e os demais para o offset. Quantas páginas um 
processo pode ter? 
 8 
 256 
 32 
 1024 
3) Considere um sistema baseado em memória paginada com endereço lógico de 32 bits sendo 8 
bits utilizados para identificação da página e os demais para o offset. Qual o tamanho máximo 
de um processo, considerando que cada endereço ocupa 2 bytes? 
 32GB 
 32MB 
 8MB 
 8GB 
4) Em relação aos métodos de alocação, é correto afirmar que: 
 47 GERÊNCIA DE ALOCAÇÃO DE MEMÓRIA 
 Todas as estratégias apresentam fragmentação interna. 
 A estratégia de memória paginada apresenta fragmentação interna. 
 A fragmentação externa pode ser evitada em sistemas que utilizam segmentação. 
 A ocorrência de fragmentação de memória nem sempre causa desperdício de espaço. 
Soluções 
1) 16M 
2) 256 
3) 8GB 
4) A estratégia de memória paginada apresenta fragmentação interna.