Resumo Sistemas Operacionais

Prévia do material em texto

BIOS: É escrita em linguagem de máquina, mas é atualizável. •
SO atuais são "gordurosos" - Já vem com muitos drivers pré-instalados. (Plug and 
Play)
○
Driver é aplicação, fala com o SO e outra aplicação. Ex.: driver de impressora, Word 
chama o driver que fala com o SO, que fala com os níveis mais baixos da máquina 
(dispositivos físicos).
•
Antes do SO a programação era feita por perfuração de cartões.•
Shell - Interpretadores de comandos (terminal)•
Há SO em quase tudo, até no chip do cartão, para validar a senha.•
Arquitetura de Von Neumann é mantida até hoje graça a evolução dos processadores. •
Cluster: Um cluster, ou agregado de computadores, é formado por um conjunto de 
computadores, que utiliza um tipo especial de sistema operacional classificado como 
sistema distribuído. Muitas vezes é construído a partir de computadores convencionais 
(personal computers), os quais são ligados em rede e comunicam-se através do sistema, 
trabalhando como se fossem uma única máquina de grande porte. Há diversos tipos de 
cluster.
•
Controlador de Vídeo = Placa de Vídeo•
Kernel: Centro do SO, aloca o tempo e memória para os programas, cuida do 
armazenamento de arquivos e a comunicação em resposta ao chamado do sistema. 
Onde os quatro gerenciamentos so implementados
•
Shell: Age como uma interface entre o usuário e o Kernel. Quando um usuário loga, o 
programa de login checa o nome de usuário e senha e então inicia outro programa 
chamado shell. Shell é um interpretador de linhas de comandos (CLI). Ele interpreta os 
comandos que o usuário digita e organiza para que eles sejam levados.("casca, escudo")
CPU é o processador.•
IRQ é abreviação de "Interrupt Request Line". Os endereços de IRQ são interrupções de 
hardware, canais que os dispositivos podem utilizar para chamar a atenção do 
processador.
•
O registrador de uma CPU (unidade central de processamento) é uma unidade de 
memória capaz de armazenar n bits. Os registradores estão no topo da hierarquia de 
memória, sendo assim, são o meio mais rápido e caro de se armazenar um dado.
•
Em arquitetura de computadores, um barramento é um conjunto de linhas de 
comunicação (condutor elétrico ou fibra ótica) que permitem a interligação entre 
dispositivos de um sistema de computação (CPU; Memória Principal; HD e outros 
periféricos), ou entre vários sistemas de computação.
•
Buffer: endereço de memória para armazenamento. •
Read: scanf - quando executado, todo programa fica na memória.•
SP- System Pounter -> ler linha por linha (ponteiro)•
Pilha: Ultimo que entra primeiro que sai (processos)•
Fd: identificador de arquivos. •
Fork: Comando no qual a partir de um processo pai, cria-se um processo filho. •
Liga o hardware (linguagem de baixo nível/ nível de máquina) com as aplicações (linguagem de alto nível);○
Controla/Organiza a distribuição de memória RAM (gerência de memória);○
O que é o Sistema Operacional•
Quanto mais baixo, mais próximo da máquina, quanto mais acima, mais próximo as aplicações e dos 
usuários.
○
Tudo que está abaixo da camada sendo analisada é desnecessário saber. ○
(0, 1) - Abstração de impulsos elétricos
Abstração = mais longe, sem preocupar com detalhes.○
Em computação é comum usar modelo de organização em camadas.•
Kernel (núcleo duro): Core do SO (Cérebro) escrito em Assembly, se desligar acabou.○
Partes principais do SO são escritos em Assembly.○
Kernel é o "miolo da cebola".○
Partes periféricas do SO são escritas em C. ○
O sistema operacional fica acima da linguagem de máquina, boa parte é escrita em Assembly.•
Escrito em Assembly: Nível mais próximo do Hardware, para ser compreendido melhor pelo Hardware, melhor 
desempenho (melhor velocidade).
•
Máquina Virtual -> Simulador de hardware -> Abstração;○
Tempo -> Processos = Programa em execução;
Espaço -> Memória.
Gerencia recursos:○
Vírus: Ocupa o espaço que o SO deveria ocupar, congelando o sistema.○
Sistema Operacional•
Mainframes: Computadores de grande porte;•
Antes era analógico: Por cartões, monousuário.○
PC (Personal Computer): Depois da década de 80, Multiusuários;•
Sistema multiusuário, mas com um processador estão em desuso, pois sobrecarrega quando vário usuários 
estão acessando os terminais;
○
Sistema Central (faz todo o processamento)---------> Terminal dumb (Sem processamento), Multiusuário, mas 
monoprocessado, diferente do em rede, onde é multiusuário mas multirpocessado (o processamento é feito no 
terminal).
•
Multiusuário : Vários usuários na mesma máquina, operando ao mesmo tempo;•
Monousuário: Um usuário operando de cada vez;•
Monoprocessado (Monotarefa): exerce um processo por vez (um processador);•
Multiprocessado (Multitarefa) :Exerce várias tarefas ao mesmo tempo (um processador), porém as tarefas saem 
sem terminar (diferente do monprocessado). Entra, roda um pouco, sai (pipeline ou fila circular).É rápido, para o 
usuário parece tudo ao mesmo tempo. Ainda com várias tarefas ao mesmo tempo, mas não termina todas ao 
mesmo tempo. 
•
Multiprogramação = Multitarefas, multiprocessos•
Multiusuário não significa ter várias contas, mas sim vários usuários utilizando ao mesmo tempo (remotamente).•
Mutiprocessadores: Muitas CPU's, ou uma com vários núcleos, dificulta para o SO (Multiprocessadores é diferente 
de Multitarefas)
•
Celular: Pode ser multiusuário, mas não é multitarefa. Executa uma tela por vez, e as atrás estão congeladas.•
Servidores: para usuários em rede;○
Multiprocessadores: mais de uma CPU ou Multi-core (diferente de multitarefa);○
PC: comuns;○
Tempo Real: SO feito especificamente para o Hardware. Automóveis com computador de bordo, freio ABS. 
Dado uma tarefa ela vai ser executada naquele tempo determinado. (tempo constante. Realizados vários 
testes, não há espaço para erros. )
○
Embarcados : Sistemas internos, fechados.○
Cartão inteligente: Uma classificação do embarcado, chip.○
Tipos de SO•
Capítulo 1 - Introdução
quinta-feira, 8 de outubro de 2015 19:00
 Página 4 de Sistemas Operacionais 
Tecla enter no teclado ---> joga no controlador---> joga no barramento----> vai para a CPU --->vai ao 
registrador ---> IR (Interrupt request) o teclado pede para parar a atividade atual e processar a ação RQ3 ---> O SO 
recebe o enter e põe pra rodar na CPU ---> Joga ele de volta.
•
SWAP - Processo diretamente ligado ao gerenciamento de memória.•
Gerenciador de memória é responsável em liberar memória para a execução de processos, estes são gerenciados 
pelo gerenciamento de processos.
•
Atualmente o SO cuida desse gerenciamento, antes o desenvolvedor da aplicação tinha que se preocupar 
com isso. 
○
Em sistemas antigos (ex: Windows 95), não havia limites para o espaço que a aplicação poderia ocupar, assim, ela 
acabava ocupando muita RAM, invadindo até mesmo o SO. Dando a tela azul. 
•
Hoje, para liberar memória, o SO retira quem está ocupando memória e coloca em disco. Quando precisa da 
aplicação , a mesma é recolocada na memória para ser executada. 
•
O SO é um processo, mas ele é fixo, não pode ser liberado da RAM. Se for mal projetado, ocupa boa parte da RAM. 
Ele tem que ser otimizado.
•
Permite a manipulação de arquivos e cria infraestrutura lógica na memória, na RAM ou no HD.○
Pode ser guardado em ordem sequencial ou em posições livres. -> gerenciamento de arquivos -> 
blocos com endereços diferentes (fragmentação de disco)

Quando um arquivo muito grande é baixado, o SO divide em blocos nas trilhas do HD de tamanho 
previamente definidos pelo gerenciador de arquivo. ("Fragmentar o arquivo"), a cada bloco locado, é 
mapeado seu local;
○
Desfragmentar: Junta os pedaços dos arquivos em blocos mais próximos;○
Os blocos são muito pequenos, pela otimização do aproveitamento do espaço em disco. Blocos menores 
evitam o desperdício de espaço, pois apenasum arquivo é colocado em cada bloco, se não for ocupado por 
completo o espaço é desperdiçado.
○
O arquivo em transferência primeiro mapeia os blocos, traça o caminho de resgate do arquivo e 
depois a transferência. 

Transferir um arquivo grande é mais rápido que transferir vários arquivos que tenham o mesmo tamanho do 
grande. Pois no primeiro caso é só um processo (apenas um mapeamento), já no segundo , tem que 
começar vários processos do zero, demorando mais. 
○
Sistema gerenciador de arquivos cria blocos de tamanho fixo no HD. ("Chão da sala.")•
Arquivos são organizados em árvores•
Mais estática que a árvore de processos. Apesar de ter arquivos temporários, que são criados e apagados, e 
da memória SWAP que é um arquivo. Pois a árvore de processos é mais dinâmica, criam processos de pais e 
filhos. O processo A gera dois filhos, B e C, depois B cria D , E, F.
○
Ex.: Abriu o terminal (processo pai), abriu um editor de texto pelo console (processo filho). Se fechar o 
console, fecha o editor de texto.
○
Obs.: Quando abre o editor de texto, o console fica parado , só volta a executar comandos quando o editor é 
fechado. 
○
Obs. 2: Quando coloca & depois do nome do programa que deseja abrir no console, o programa é aberto em 
segundo plano, não travando o console.
○
Pipeline : fluxo de passos, entrando e saindo.○
Pipe "|" - colocado entre dois processos. Quando o primeiro termina e produz dados na saída, o processo que está 
depois dele (direita) ligado pelo pipe recebe esses dados.
•
 Página 5 de Sistemas Operacionais 
Espaço do usuário
O SO impede comandos diretos no núcleo por segurança.□
Espaço do sistema (Kernel) : Apenas comandos que tratam diretamente com desemprenho, algoritmo 
e hardware. Nem usuários, nem programadores mexem nesse espaço (não faz chamada ao usuário).

Ele loca um espaço para guardar, armazenar no buffer (memória) , identifica o tipo de 
arquivo, az a chamada da instrução, transfere o pedido para o registrador na CPU, manda 
para a área do núcleo, recebe, escalona, organiza, executa, recebe os resultados e devolve 
para a área do usuário, retorna para quem chamou e incrementa o SP para executar o 
próximo processo. 
○
Scanf : ler (loca espaço) o comando, faz (preparando) o buffer (o digitado vai para a área do 
buffer), chama o scanf, coloca código no registrador (pequeno buffer para ponteiro), manda 
para o SO na área do Kernel, escalona e prioriza, executa no SO, trata a comunicação com o 
usuário (área) recebendo os resultados e devolvendo, retorna pata quem chamar, vai para o 
próximo comando. 
□
Chamada a nível usuário para o kernel:
Duas áreas de execução:○
Processo chamada ao sistema (System Calls) - mapeamento•
 Página 6 de Sistemas Operacionais 
Shell: faz a comunicação entre o kernel e os utiliarios.•
Unix é a base do Linux•
Linux tem vários sabores. Open Suse, ubuntu, etc.. Cada tipo chamado de uma distribuição (os 
tipos, são distribuições, no SO's). O que muda entre as distribuições é a interface gráfica, o 
shell (a casca) e os comandos. O Kernel permanece o mesmo. (Fedora, ubuntu, Debian - O 
Kernel é o mesmo, muda as versões, atualizações)
•
Vários shells, uma das populares é o bash. .Abriu um processo que retornar no prompt 
dizendo que o comando esta disponível.
•
Ao abrir o terminal/ console (cmd) (terminal no tem processamento próprio, tem entrada e 
saída, mas no há processamento), uma interface gráfica, com interface texto. Escreve 
comandos, o interpretador e o shell(interpretador de comandos).
•
Quando abre uma aplicação é aberta pelo terminal, o terminal foca travado até que a 
aplicação seja finalizada
•
Configurar uma máquina virtual (simulador de máquina)○
Baixar ubuntu (.iso)○
Virtual Box ou VMWare (máquinas virtuais), ou faz dual boot•
ls => mostra os diretórios (diretório )de arquivos ;○
#halt => desliga o pc;○
/dev => (devices) mapeia diretórios/arquivos;○
Ctrl+C => limpa o terminal;○
Pwd => mostra diretório atual;○
Cd => entra no diretório;○
Mkdir => cria diretório○
Rmdir => exclui diretório;○
Cat => mostra conteúdo do arquivo;○
Cp => copia arquivos de diretório;○
Vi => editor;
Comandos(todos os comandos são em minúsculo): •
Aula de Laboratório
quarta-feira, 14 de outubro de 2015 19:06
 Página 7 de Sistemas Operacionais 
Vi => editor;○
Comando -- help => parâmetros de cada comando;○
Sudo => executa comando como root (superusuário);○
Mount => monta um dispositivo;○
Unmount => desmonta um despositivo;○
O d no console indica que um diretório○
Quando pluga um pendrive e coloca alguma coisa nele, primeiro o linux grava em um 
arquivo, depois para o pendrive. Quando manda desconectar o pendrive o linux passa o 
arquivo salvo no HD para o pendrive. Se tirar o pendrive antes de mandar ejetar pode 
perder o arquivo.
○
Cebola e camadas ajudam a abstrair a computação, facilitando sua compreensão○
O Linux mapeia todas as entradas de dispositivos como arquivos.•
SWAP (troca/mudança) - memória swap (memória virtual, memória RAM no disco, 
lenta), espaço em disco reservado no hd que vai receber o trafego que está ocupando a 
RAM, para liberar a mesma. Esse processo e lento. Se tirar um pedaço necessário, tem 
que voltar como o mesmo pedaço. O vai e vem de aplicações na RAM, deixa o 
computador mais lento.
○
Quando a memória RAM fica muito ocupada, o SO começa a ficar lento, porque tem que ficar 
tirando um programa para colocar outro. 
•
Não há vírus para Linux até hoje, ele te protege dele mesmo•
Parte da raiz○
Diretório raiz: contém todos os diretórios•
Endereço absoluto: parte do diretório raiz até onde você quer (início \home)•
Endereço relativo: parte do diretório corrente.•
Tarefa: baixar virtual box, configurar máquina virtual, baixar ubuntu.
http://pt.wikihow.com/Instalar-o-Ubuntu-no-VirtualBox
http://www.ubuntu.com/download
Fazer um scrip que copia todos os arquivos de um diretório para o outro
Emulador de msdos
http://www.pcjs.org/devices/pc/machine/5160/cga/256kb/win101/
 Página 8 de Sistemas Operacionais 
Verificar diretório atual: pwd•
Criar diretorio: mkdir ./...•
Voltar para o diretorio anterior: cd -○
Voltar para o diretório raiz: cd○
Entrar em um diretorio: cd ./nome do diretorio•
Criar um arquivo: cat > nomedoarquivo (o que vier nas linhas depois é o que terá no arquivo)•
Duplicar arquivo: cp nomedoarquivoatual nomedonovoarquivo•
Copiar todos os arquivos com uma certa extensão: cp *.extensão caminhododiretórioquedesejaenviarascopias•
Exibir os arquivos e seus detalhes: ls -l•
Mudar permissão dos arquivos chmod numero da permissão nome do arquivo•
Deletar um arquivo: rm nomedoarquivo•
Deletar uma pasta vazia: rmdir nomedodiretório•
Deletar uma pasta que não esteja vazia: rm -Rf nomedapasta•
Renomear um arquivo: mv nomeatualdoarquivo novonomedoarquivo•
Mover um arquivo: mv caminhodoarquivoatual paraondequermandaroarquiv•
Listar arquivos de uma pasta e salvar em um arquivo: find //bin > listabin.txt•
Abrir um programa: digitar o nome do programa (ex: gedit)•
Compilar e executar um programa: gcc nomedoprograma -o nomedesaidadoprograma | ./nomedesaidadoprograma•
Imprimir na tela: echo•
Ler entrada do teclado: read•
Testar se é um diretório: test -d "$nomedaentrada"•
Testar se é um arquivo: test -f "$nomedaentrada"•
Loop do If : if / elif/ else/ fi•
Limpar o prompt: clear•
Criar inúmeros arquivos no diretório atual: •
for i in {0..10}
do 
touch arq$i.txt
done
Contar as linhas de algo: wc-l•
Listar todos os diretórios e subdiretórios de um diretório: ls -R nomedodiretorio•
Para fazer contas: =$(echo "conta(())"•
Formatar saída de dados: printf "%.quantidadedecasasdecimais tipodevariavel" $variavel•
Quantas casas decimais a considerar: scale: nº | bc -l•
Somar dois valores: resultado=$(( $a+$b))•Falar se um valor é maior que o outro: [ $a -gt $b ]•
Falar se um usuário está cadastrado no sistema:•
function _getUserEx()
{
grep "^$1\:x\:" /etc/passwd | \
cut -d ':' -f 1 | \
wc -c | \
sed 's/[^0-9]//g'
}
if [ $( _getUserEx $USR_EX ) -gt 3 ]; then
SHELL SCRIPT
Comandos
quarta-feira, 18 de novembro de 2015 15:09
 Página 9 de Sistemas Operacionais 
if [ $( _getUserEx $USR_EX ) -gt 3 ]; then
echo " $USR_EX é um usuário cadastrado."
exit 0
else
echo "$USR_EX não é um usuário cadastrado".
exit 2
fi
Lista arquivos do diretório e falar se é arquivo ou diretório•
clear
echo -n "Digite o caminho do diretorio a partir do seu diretorio atual: "
read nome
cd ./$nome
for i in $(ls -d */);
do echo ${i%% }" (dir)";
done
ls -p | grep -v /
Imprimir todos os números até o valor dado:•
cont=0
while [ $cont -le $numero ]; do
printf "$cont "
cont=$((cont +2))
done
echo ""
Verificar se é um arquivo e dizer seu tamanho:•
echo "Digite um nome de arquivo no diretório atual"
read arq
test -f $arq
if test -f "$arq"
then
echo "É um arquivo"
else
echo "não existe"
fi
du -hsb $arq
Shell com diversas funções•
# !bin/bash
pergunta(){
 echo ""
 echo "Pressione ENTER para voltar" 
 echo ""
 read VOLTAR 
}
while true 
do
 clear
 echo ""
 echo "1 - Exibir status da utilização das partições do sistem; (df- h)"
 echo "2 - Exibir relação de usuário logados; (who)" 
 echo "3 - Exibir data/hora; (date)" 
 echo "4 - Sair."
 read op
 case $op in 
 1) while true; do
 clear
 df -h
 pergunta
 while [ -n "$VOLTAR" ]; do
 clear
 df -h
 pergunta
 Página 10 de Sistemas Operacionais 
 pergunta
 done
 if [ -z "$VOLTAR" ]; then
 break
 fi
 done
 ;;
 2) while true; do
 clear
 who -Hum
 pergunta
 while [ -n "$VOLTAR" ]; do
 clear
 who -Hum
 pergunta
 done
 if [ -z "$VOLTAR" ]; then
 break
 fi
 done
 ;;
 3) while true; do
 clear
 echo ""
 echo "Data Horário"
 date "+%d/%m/%y - %H:%M:%S"
 pergunta
 
 while [ -n "$VOLTAR" ]; do
 clear
 echo ""
 echo "Data Horário"
 date "+%d/%m/%y - %H:%M:%S"
 pergunta
 done
 
 if [ -z "$VOLTAR" ]; then
 break
 fi
 done
 ;;
 4) clear ; echo "" ; echo "Finalizando Programa" ; sleep 1; clear; break 
 ;;
 *) echo "" ; echo "Opção Inválida" ; sleep 1 ; echo ""
 ;;
 esac
done
 Página 11 de Sistemas Operacionais 
Processos: processos, threads, comunicação entre processos e threads, escalonamento;○
Memória: Monoprogramação, máquina virtual○
Gerenciadores:•
O sistema pós win 95 : Entrada e saída dos processos da memória, escalonamento.○
Quando o processo atinge o limite, o SO aloca o espaço da aplicação em segundo plano, substituindo-o por outro 
processo. Quando o outro retorna, o espaço anterior é relocado, e entra novamente em execução.
○
Memória dividida em slots, gerenciados por base e limites para cada processo. •
Roda um programa por vez dentro da CPU, mas parece simultâneo com outros processos.○
Processo é um programa em execução. Programa executando o algoritmo e utilizando recursos da CPU, da memória, 
entrada e saída. 
•
Determina os pontos de troca de processos, quando sai da CPU, as informações são congeladas no disco.○
São marcadores dos pontos de parada do processo para a recuperação quando voltar para a CPU.○
Se o programa tem alguma parte de entrada/saída (i/o) o programa/processo é tirado e posto no disco (sempre). 
Quando da o enter na entrada, o processo fica pronto e entra na fila para ser executado. 
○
Alteração entre o uso da CPU pelos processos:○
Tempo de processador = todo o tempo que o processo fica na CPU (mesmo saindo e entrando na CPU. )○
Algoritmo de quantum: normatiza o tempo que o processo permanece na CPU, determina esse intervalo.○
Contador de programa: ajuda o SO a lembrar onde o processamento terminou e depois onde ele tem que retomar.•
Quando o processo faz entrada e saída ele entra e sai da pilha de escalonamento (entra e sai da CPU)•
1 - Inicio do Sistema;○
2 - Execução de chamada ao sistema de criação de processos○
3 - Solicitação do usuário○
Cria serie de instruções, em lote, para executar uma função ou várias funções.▪
4 - Início de job (processo com muitas operações, em lote, em segundo plano) em lote○
Eventos que levam a criação de processos.•
1 - Saída normal (voluntário)○
2 - Saída por erro (voluntario )○
3 - Erro fatal (involuntário)○
4 - Cancelamento por outro processo (involuntário)○
Condições de término•
Porque ultrapassou limite de tempo ou I/O. Não significa que finalizou○
Por que o processo sai da CPU?•
Um processo pai, cria um processo filho e este pode criar seu próprio processo (grupo de processos - UNIX)○
Windows não tem hierarquia de processos, todos os processos são criados iguais.○
Hierarquia de processos:•
Estados de Processos•
Execução - quando está usando a CPU efetivamente○
Bloqueado - aguarda I/O (não está na CPU) ○
1 - Processo bloqueia aguardando entrada e saída;▪
2 - Escalonador seleciona outro processo;▪
3 - Escalonador seleciona este processo;▪
4 - Entrada disponível;▪
Pronto - Pronto para executar, concorrendo com outros na fila (pronto para ser escalonado)○
Algoritmo de escalonamento▪
Em execução para pronto: Passou o tempo previamente determinado. ○
Quando o processo dá erro ele "finaliza" não passa para nenhum estado○
Executando para bloqueado: Espera de I/O○
Bloqueado para pronto: Recebeu/Saiu I/O○
Pronto para executando: Foi escalonado na fila○
Rodando: Pode estar em qualquer um dos estados acima.○
Memória: Espaço para armazenar dados em tempo de 
processo
•
Gerenciador de processos: Tarefas;•
Gerenciador de memória: espaço•
Só para impressão (fila)○
Locação de espaço em um dispositivo intermediário 
para compensar a falta de velocidade. Na 
impressão o terminal manda um sinal ao 
mainframe e ele faz uma cópia do resultado no HD 
para mandar a imagem na impressora, é um buffer. 
○
É também o controlador de fluxo de impressões. ○
Spooling: Spoon •
Processos de E/S não necessitam passar pelo SO, 
não atrapalham os outros processos.
○
É um atalho direto para o E\S○
Acesso direto sem passar pelo processador ou 
memória
○
DMA:•
Algoritmo Time - Slice = Quantun : Algoritmo que defini 
quanto tempo o processo fica na CPU
•
Processo executando: pode estar em qualquer um dos 
estados de processo.
•
Sempre há concorrência pelo recurso (CPU, 
Memória, I/O)
○
Concorrência: Quando dois processos querem acessar, 
mexer no mesmo endereço de memória (região), é 
necessário tratar a concorrência. 
•
Multitarefa = Multiprocessado•
Multiprocessador = Quad-Core•
GPU: Processador gráfico•
JVM: Maquina Virtual Java - Exemplo de VM de software 
(figura 2.8)
•
Buffer: Qualquer espaço de armazenamento de dados, 
temporária.
•
Bloco de controle de Processos - 2.1.6 - página 55•
Capítulo 2 - Processos e Threads
segunda-feira, 19 de outubro de 2015 11:27
 Página 12 de Sistemas Operacionais 
Rodando: Pode estar em qualquer um dos estados acima.○
Concorrência pelo recurso é diferente de ser escolhido para ser executado.○
Trata interrupção, escalonamento (IRQ);○
Motor do gerenciamento de processos.○
Os processosmudam de estado, usam a CPU ou não, usam a memória ou não, usam I/O ou não. O escalonador 
que cuida disso. 
○
SO cria e gerencia todo o escalonamento de processos.○
Escalonador •
A cada interrupção gerada, o escalonador é executado e alterna a execução entre os programas de usuário.○
Relação escalonar processo X Interrupções•
 Página 13 de Sistemas Operacionais 
Threads (2.2 - Livro)•
Executam dentro de outro, não é processo filho. ▪
Um processo pode ser quebrado em mini processos. Esses mini processos são threads (sub 
processos)
○
Linhas de execução, executam operações distintas;○
O objetivo dos threads é diminuir o tempo de processamento do processo em um todo○
Overhead: Operações que ao final não tem resultado satisfatório (o tempo gasto);○
Ex.: Aplicativo Firefox -> Cada aba é um thread - até as threads são escalonadas. ○
Escrever ▪
Imprimir ▪
Cada uma é um thread, que ocorrem QUASE paralelamente•
Não podem ser dependentes uma da outra, pois ficariam esperando a finalização 
da thread anterior.
•
O editor de texto é o processo, e suas ações são os threads.•
O escalonamento das threads é programado por quem criou a aplicação.•
Salvar▪
Ex.2: Word -> mais de uma ação ○
Esses SO's multi-thread tem o overhead (excesso, ruim, desnecessário)▪
SO's comuns são multiprocessos, multiprogramação, multitarefa. Enxerga 
escalonamento de processos
▪
SO não conhece o escalonamento de threads, apenas SO's multi-threads tem isso, mas não são 
os SO's comuns.
○
Processos e threads são manipulados dentro do espaço do usuário. ○
Em java o método main é uma thread;▪
Cada método é um thread▪
A própria JVM escalona as threads, simulando um SO multithread. ▪
JVM é o processo:○
Para um processo rodar ele tem que estar todo na RAM•
Contexto: Toda a informação gerada pelo processo que depois retornara a ser 
executado.
▪
O SO salva o contexto do processo (toda a informação que o processo estava 
processando, e o contador de programa - onde parou a execução) no disco ou em outro 
local.
○
Antes estava tudo na RAM. Pode até ficar na RAM, desde que seja garantido que ○
Quando o processo atinge o tempo quantum, o SO mexe no hardware , interrompendo a CPU. •
Threads
sexta-feira, 13 de novembro de 2015 10:02
 Página 14 de Sistemas Operacionais 
Quando o espaço da RAM que está guardando o programa não executando, é 
necessária para outro processo, o que está nesse pedaço da RAM passa para o 
disco rígido.
▪
Antes estava tudo na RAM. Pode até ficar na RAM, desde que seja garantido que 
nenhum processo mexa naquela região de memória. 
○
 Página 15 de Sistemas Operacionais 
Gera inconsistência de dados.▪
Garantir que apenas um acesse essa região por vez é uma função do SO;▪
Dois programas que necessitam da mesma variável (mesma área de memória)○
Sincronização e Comunicação de Processos:•
Processo gravador = Produtor = Editor de Texto = Alimenta o Buffer;▪
Processo leitor = Consumidor = Impressora = Consome do Buffer;▪
Entre o processo gravador e o Processo Leitor deve haver Sincronização;▪
Controle de Fluxo, pois a velocidade do processador é maior que da impressora, o que pode 
causar perda de dados. 
▪
Impressão;▪
Rede de computadores;▪
Transferência de dados;▪
Processos que precisam de buffer:○
Sincronismo entre Processos•
Encher o buffer = Produtor mais rápido que o consumidor;•
Esvaziar o buffer = Consumidor mais rápido que o produtor;•
Se o buffer encher, o produtor tem que parar, até que o consumidor consuma até o buffer 
esvaziar e então para.
▪
Para o consumidor ou o produtor pararem, eles saem da CPU, vão para o estado bloqueado, 
aguardando I/O
▪
Tem que se evitar que o Consumidor e o Produtor acessem o mesmo espaço de memória 
quase ao mesmo tempo, pois pode causar inconsistência. Concorrência.
▪
Tudo em computação tem limite, até mesmo o buffer○
Mutualmente exclusiva;○
Nem o escalonador de processos pode tirar um thread que esteja executando na região 
crítica até que ele termine de ser executado
▪
Se a região crítica tiver um loop infinito, nunca sairá de lá.▪
Protocolo de Entrada - Verificar se está ocupado;•
Protocolo de Saída - Avisar que saiu;•
Antes de entrar e depois de sair tem sempre que fazer o protocolo de entrada/saída▪
O próprio buffer tem uma região crítica;▪
Trecho do código que não pode ser executado por mais de um processo ao mesmo tempo, para 
assim, garantir a consistência (Protege o trecho);
○
Dois processos simultaneamente na região crítica;1
Não importa a velocidade da CPU, nem quantas há;2
Se o processor estiver fora da região crítica ele não pode bloquear outro processo;3
O processo não deve esperar eternamente para entrar na região crítica.4
Condições para a exclusão mutua:○
Caixas de Bancos são threads, executando o mesmo código, rotina, região crítica. ○
Flag: Acesso a único processo - Exclusão Mútua○
Região crítica:•
Não generalizável(escalável);▪
O rápido fica preso no Loop (espera ocupada) e o lento prende na região crítica 
por processamento demorado. 
○
Processo rápido morre de fome (starvation) quando o processo lento entra na zona 
crítica;
•
Incompatibilidade de velocidade de execução de processos;▪
1º Exclusão Mutua - Espera Ocupada○
Nem sempre garante a exclusão mútua porque as variáveis iniciam de maneira a manterem 
fora do loop ocupado e entram na região crítica, gerando uma exceção.
▪
2º - Exclusão mútua○
Faz verificação antes de entrar no loop;▪
Processo tenta alocar um recurso, outro processo também, mas um terceiro já ocupa 
o recurso.
•
Os dois podem entrar em espera ocupada (deadlock)▪
3º - Algoritmo○
Dois processos entram na região crítica ao mesmo tempo;▪
Starvation;▪
Deadlock;▪
Algoritmo de Peterson: resolve todos os problemas da exclusão mutua. Graças a variável VEZ. 
Problemas:
○
Processos não se comunicam▪
É necessário que se sincronizarem e comunicar▪
Para otimizar o processo que estava na espera ocupada dorme. O processo acordado, 
manda o outro acordar quando for a hora. (Comunicação entre porcessos)
▪
Espera ocupada ainda é um problema○
Algoritmos que tentam proteger a região crítica:•
Função sem retorno = procedimento;○
Função com retorno = função.○
Em programação:•
CPU está processando nada, o processo está preso.○
Loop de entrar na região crítica - Algoritmo de Peterson○
Loop que não faz nada -> Espera ocupada•
Processo que está na CPU e sai tem que salvar o contexto.•
Starvation: Um processo rápido passa fome de recurso esperando um 
processo lento que está rodando na região crítica
•
Deadlock: Um processo tenta alocar um recurso, outro processo tenta 
alocar o mesmo recurso, mas o recurso está ocupado, os processos 
ficam bloqueados eternamente. 
•
PAREN: Em Pascal significa que os processos são disparados para rodar 
quase simultaneamente
•
Rotina = Função•
Condição de Corrida: Quando mais de uma thread quer acessar a região 
crítica - Tem que ser tratado.
•
Ponteiros: Ajudam a dinamizar o tamanho da alocação. Passa o valor por 
inferência. 
•
Sincronização e Comunicação entre Processos
sexta-feira, 13 de novembro de 2015 10:02
 Página 16 de Sistemas Operacionais 
Gabri
Máquina de escrever
Gabri
Máquina de escrever
Uma thread manda a outra dormir/acordar•
Buffer cheio;○
Outro processo na região crítica○
Sleep: Sai da CPU e fica no estado de pronto, quando sai salva o contexto;•
Buffer tiver espaço - Basta 1 - Consumidor consome e avisa;○
Região crítica livre - Consumidor avisa que saiu da região crítica○
Wakeup: Volta para a CPU de onde parou - contexto;•
Ainda há deadlock•
Sleep e Wakeup▪
1965 - Dijkstra - Multithread•
Enfileira wakeups - Base do semáforo.
Wakeup WaitingBits○
Usa uma variável para contar quantos wakeup foram disparados, serão usados depois•
São atômicos ("região crítica"), o que significa que não tem como serem 
interrompidos pela CPU (Foram implementados nos SO's assim)
○
(Protocolo de entrada) Down (P) - Entrar na região crítica, (Protocolo de saída) Up (V) 
sair da região e avisa que o próximo pode entrar
•
Podem ser binários (mutexes - exclusão mútua) ou contadores (valor > 0)•
Semáforos•
Permitia erro de programação.○
Aprimora os semáforos.•
Tem como motivação evitar que ocorram erros de programação.•
Torna mais fácil a escrita de programas corretos.•
Não é necessário como o semáforo, mas é muito usado.•
Monitores•
Mecanismos de sincronização acabam com o problema da espera ocupada, pois há a comunicação 
entre as threads.
○
Sincronização Condicional•
 Página 17 de Sistemas Operacionais 
BEGIN
 Cont:=0;
 CP:=false;
 CC:=false;
 PARABEGIN
 Produtor;
 Consumidor;
 PAREND;
END.
PROGRAM Produtor_Consumidor_1;
 CONST TamBuf = (* Tamanho qualquer*);
 TYPE Tipo_Dado = (* Tipo qualquer *);
 VAR Buffer : ARRAY [1..TamBuf] OF Tipo_Dado;
 Dado_1 : Tipo_Dado;
 Dado_2 : Tipo_Dado;
 Cont : 0..TamBuf;
 VEZ : CHAR
PROCEDURE Produtor;
BEGIN
 REPEAT
 Produz_Dado (Dado_1);
 WHILE (Cont = TamBuf) DO (* Não faz nada*);
 CP := true;
 VEZ:= C;
 WHILE (CC and VEZ=C) DO (* Não faz nada*);
 Grava_Buffer (Dado_1, Buffer);
 Cont := Cont +1;
 CP:= false;
 UNTIL False;
END;
PROCEDURE Consumidor;
BEGIN
 REPEAT
 WHILE (Cont = 0) DO (* Não faz nada*);
 CC := true;
 VEZ:= P;
 WHILE (CP and VEZ=P) DO (* Não faz nada*);
 Le_Buffer (Dado_2, Buffer);
 Cont := Cont -1;
 CC:= false;
 Consome_Dado (Dado_2);
 UNTIL False;
END;
Algoritmo Produtor-Consumidor + Algoritmo de Peterson
sexta-feira, 13 de novembro de 2015 08:31
 Página 18 de Sistemas Operacionais 
Sistema de tempo real;○
Sistema dos PC's comuns;
Sistema interativo: respostas rápidas, questão de milissegundos, segundos;○
Sistema em lotes(batch): demora horas, dias○
Escalonador funciona de maneira diferente em cada tipo de sistema•
Algoritmo justo com os processos mais caro (lento) para a CPU(muitos chaveamentos de contexto) 
ou o inverso. Não há um algoritmo perfeito.

TRADE - OFF : Dilema○
Escalonador é justo: escalona de acordo com o critério mais justo•
Age no começo e no fim do processo (Criação e termino)
A CPU está livre e há mais de um processo no estado de Pronto○
Processos de baixa prioridade podem entrar em starvation
Quando um processo de alta prioridade ficar apto a executar○
Tempo do processo terminou, tem que entrar outro
Interrupção de tempo: Algoritmo de tempo○
O processo sai da CPU, escalonador tem que escolher outro
Interrupção de E/S: O processo aguarda E/S○
Cada pedaço de memória é chamado de página
Isso ocorre quando parte do processo sai da RAM (SWAP) e vai para o disco. Recuperar as 
informações do processo no disco demora, então o processo sai da CPU.

Escalonador tem que escolher outro processo para substituir o mesmo
Interrupção por falta de segmento de memória: Endereço acessado não está carregado na memoria 
virtual
○
Interrupção de erro○
Escalonador age quando:•
Escalonador: define qual processo deve ser executado, toma a decisão○
Expedidor (dispacher): efetua a troca de contexto (salvar e recuperar)○
Escalonador dividido em duas partes:•
Quando estão na fila de prontos e aptos a executar
Curto prazo:○
Quando o processo sai da CPU e controla os eventos que estão na fila de bloqueados em situação 
que não seja I/O (por concorrência, swap, tempo ...)

Médio prazo:○
Escolhe alguém para entrar na fila de processos com outro estado que não seja pronto
Longo prazo:○
Escalonador de •
Até que seja concluída;
I/O;
De maneira não preemptiva:○
O SO decido quando o processo/thread sai da CPU
Todos os sistemas interativos são preemptivos.
De maneira preemptiva:○
Uma vez escalonado utiliza o processador até que :•
Folha de pagamentos, conta, estoque ....
Usados em ambientes coorporativos ○
Não há demanda para interatividade○
FIFO;
Tarefa mais curta primeiro;
Próximo menor tempo restante (Variação do segundo);
O algoritmo mais usado é o S.J.F.
Tipos de escalonamentos:○
Sistema em lote•
Fila de pronto: conjunto de processos que estão no estado de pronto, a ponto de serem 
executados.
•
Swap : tira o processo da memória RAM e manda para o disco, quando a memória está cheia•
Processo que fica mais tempo na CPU, surtos longos, demora a sair da CPU.○
Processo orientado a CPU: CPU Bound•
Processo que fica pouco tempo na CPU, fica boa parte do tempo fazendo surtos de I/O○
Processo orientado A I/O: I/O Bound•
Escalonamento de Processos/Threads
domingo, 29 de novembro de 2015 19:43
 Página 19 de Sistemas Operacionais 
http://www.uniriotec.br/~morganna/guia/shell.html
SHELL
quarta-feira, 4 de novembro de 2015 19:27
 Página 20 de Sistemas Operacionais 
Ligar o hardware (linguagem baixo nível) às aplicações (alto nível);○
Gerenciar a memoria RAM (Controla/Organiza);○
Tempo: Processos(Programa em execução);▪
Espaço: Memória;▪
Gerenciar recursos:○
SO é responsável por:•
Quanto mais baixo, mais próximo da máquina, quanto mais acima, mais próximo das aplicações/ 
usuários;
○
Computação usa o modelo de organização em camadas:•
Boa parte é escrito em Assembly, mais próximo do Hardware, é melhor compreendido pelo 
mesmo, gerando um melhor desemprenho;
○
Kernel (miolo da cebola/ Core do SO) - Cérebro do SO, se desligar acabou;○
Partes periféricas do SO são escritas em C;○
SO fica logo acima da maquina(camadas):•
Multiusuário: Vários usuários na mesma maquina, operando ao mesmo tempo (Não 
significa ter varias contas no computador, mas sim, varias pessoas utilizando ao mesmo 
tempo - remotamente);
▪
Monousuário: Um usuário operando de cada vez;▪
Quanta a usuários:○
Monoprocessado: Monotarefa - Exerce apenas um processo por vez;▪
Multiprocessado: Multiarefa - Multiprogramação - Exerce varias tarefas ao mesmo tempo, 
no mesmo processador, porém as tarefas saem sem terminar (diferente do 
monoprocessado). O processo entra na CPU, roda um pouco, sai e depois volta. Ocorre 
tudo muito rapidamente, para o usuário parece ao mesmo tempo.
▪
Quando ao Processamento:○
Monoprocessador: Apenas uma CPU, com apenas um núcleo, que pode ser mono ou 
multiprocessado;
▪
Multiprocessador: Mais de uma CPU, ou uma com mais de um núcleo, dificulta o controle 
do SO.
▪
Quanto ao Processador:○
Classificações:•
Mainframes: Computadores de grande porte;○
Antes eram analógicos, por cartões, monousuários;▪
PC: Computadores pessoais que surgiram depois dos anos 80, são multiusuários.○
Sistemas monoprocessados multiusuários estão em desuso, pois sobrecarrega o 
processador.
▪
Sistema Central: Sistema que faz todo o processamento, ligado à um terminal dumb (Sem 
processamento), é Multiusuário, mas monoprocessado, diferente de em rede onde é 
multiusuário e multiprocessado (O processamento é feito no terminal);
○
Tipos de Computadores:•
Servidores: Para usuários em redes;○
Multiprocessadores: Multi-core;○
PC: Comuns;○
Automóveis com computador de bordo, freio ABS, é dado uma tarefa e ela será executada 
em um tempo constante. São realizados vários testes, não há espaços para erros;
▪
Tempo Real: SO feito especificamente para o hardware.;○
Cartões inteligentes - Uma classificação do embarcado, chip.▪
Embarcados: Sistemas internos, fechados;○
Tiposde SO's:•
Capitulo 1 - Observações:
Máquina Virtual é um simulador de Hardware, uma abstração;○
Abstração: Olha de um ângulo mais geral, sem se preocupar com os detalhes. (Ex.: 0 e 1 - São 
abstrações de impulsos elétricos) - Facilita a compreensão.
•
Vírus ocupam o espaço que o SO deveria ocupar, congelando o sistema;•
Um programa/SO mal projetado(Sem aplicação de controle), pode fazer com que um programa 
ocupe o espaço do SO gerando a Tela Azul;
•
Tecla enter no teclado ---> joga no controlador---> joga no barramento----> vai para a CPU --->vai 
ao registrador ---> IR (Interrupt request) o teclado pede para parar a atividade atual e processar a 
ação RQ3 ---> O SO recebe o enter e põe pra rodar na CPU ---> Joga ele de volta.
•
Estudo para a 1ª Prova
quarta-feira, 25 de novembro de 2015 09:52
 Página 21 de Sistemas Operacionais 
A parte ocupada pelo SO tem que ser protegida, não pode ser acessada indevidamente. ○
Delimitam as partições da memória identificando os endereços de memória de cada partição.
São endereços de memória especiais controlados pelo SO.
Registradores:○
Memória principal: parte é ocupada pelo SO, a outra parte é ocupada pelos programas (onde vamos estudar)•
Memória continua sem divisões○
Sempre há uma área livre na memória (problema)○
Alocação Contígua Simples•
Depende do programador modularizar o programa.
Técnica do Overlay: sobreposição de módulos na memória, um módulo de cada vez quando não cabe todo o 
programa dentro da memória. 
○
Módulo principal: função main é executada, essa chama as outras funções que são executadas na area 
do overlay 

○
1ª Técnica utilizada em memória pequenas•
O SO define o tamanho das partições no BOOT. ○
Menos complexa que a dinâmica.○
A tabela define o tamanho das páginas e se elas estão livres ou não. 
Há uma tabela que define o tamanho das partições○
Registrador separa logicamente os endereços de memória
Apenas um programa por partição○
Toda vez o SO tem que checar se o programa está em sua faixa de memória permitida.○
Baseado no endereço de memória absoluto, não reloca o endereço dos registradores. 
O SO consegue enxergar o tamanho dos processos que estão na fila de processos. Coloca o processo 
na fila para ser executado na menor partição que couber, para diminuir a perda de memória.

Os processos que estão na fila de partições menores não são executados nas partições maiores, 
mesmo que elas estejam livres.


Absoluto:○
Realocável:
Alocação Particionada Estática:•
Memória não virtual = memória RAM, não utiliza o 
HD
•
Função GOTO não modulariza e dificulta a leitura 
do código. 
•
Fragmentação interna: dentro da partição há 
espaço livre inutilizado.
•
Fragmentação externa: fora da partição, na 
memória.
•
Bloco de controle de processos: tem qual a 
posição da memória que o processo ocupa. Tem 
que corresponder ao mapa de bits. 
•
Arquitetura de Von Neumann: CPU, memórias, 
registradores. Definiu que o programa tem que 
ficar na memória para ser executado. 
•
Quantidade de combinações de bits de 
endereço. 
○
Questão de prova: Diferença entre SO de 32 e 64 
bits. Detalhadamente. De exemplos.
•
Overhead: Tem algo a mais, produz benefício, mas 
tem custo. 
•
Frame: físico•
Página: virtual•
A memória normalmente é dividida em blocos de 4 
K
•
Memória virtual é sempre maior que a Real. •
Page in: página entrando na memória principal. •
Page out: Página saindo da memória principal. •
Bit de Validade: presente/ausente. •
SO cria e mantem a tabela de página na RAM.
Quando o SO da BOOT, o a tabela de páginas está 
vazia. Ela vai sendo preenchida/criada quando 
novos processos são criados.
•
Quanto mais pesado o aplicativo, maior é a tabela 
de páginas. 
•
SO atual usa o algoritmo do menos usado 
recentemente. 
•
Capítulo 3- Gerenciamento de Memória
segunda-feira, 25 de janeiro de 2016 20:22
 Página 22 de Sistemas Operacionais 
É mais esperto que o absoluto.
Os processos podem ser executados a partir de qualquer partição que couberem.
Gera a fragmentação interna: fragmentação dentro da partição, pois sobra espaço livre. 

Realocável:○
Partições são criadas sob a demanda dos processos. ○
Registradores são criados sob demanda. ○
Uma vez alocado um processo, o tamanho da partição não muda, não conseguindo alocar mais memória 
para o programa caso seja necessário. 
○
Quando um processo sai da memória e libera a partição, fica um espaço vazio na memória, gerando a 
fragmentação externa.
○
Ficar realocando processos - desfragmentado - gera custos de potência.○
○
□
Mapa de bits: Técnica do SO para controlar onde cada processo está na memória. Em qual endereço 
de memória há processos fica 1, onde não há, fica 0. Não sabe o endereço, só sabe que está ocupado.

□
Listas ligadas: ponteiros apontam para a próxima partição. 
Desfragmentar: registradores são relocáveis, mas custa para a execução, gera lentidão, pois tem 
que se mudar todos os endereços de memória e o SO tem que saber todos os novos endereços. 
□
Durante a compactação é lento. □
É possível compactar para solucionar o problema de fragmentação externa . 
Estratégias do SO para alocação de memória:○
Alocação Particionada Dinâmica:•
 Página 23 de Sistemas Operacionais 
□
Best-Fit: menor espaço possível - ideal.
Se na fila de processos tiver um processo de tamanho maior, com essa técnica fica maior espaço 
livre contiguo.
□
Worst-Fit: maior espaço disponível.
First-Fit: Primeiro espaço livre - nada é analisado. 
Técnicas de alocações de processos○
Técnica de retirar um processo da memória e colocar no disco - memória virtual- (swap out) para 
inserir um novo programa. 

Recolocar um antigo programa é swap in.
As movimentações são com partições inteiras. 

Swapping: ○
Instrução = endereço final○
Endereço inicial = Endereço inicial que a instrução irá ocupar no swap in.○
Deslocamento = diferença da posição inicial para a final. ○
○
Registrador de relocação: endereço inicial da partição; o registrador que pega a instrução retirada de memória e 
reloca no espaço anterior ideal, guardando o deslocamento. 
•
Processador é o único a acessar o endereço físico. 
Endereço físico (real): endereço efetivo da memória no chip.○
Os endereços que o processador pode endereçar efetivamente dependem se o sistema é 64 bits ou 32 bits 
(Máximo 4GB de RAM)
○
Processos conhecem apenas memória virtual (espaço lógico) - HD, pendrive, etc. - Precisa mapear com a 
memória real. 
○
Tabela de mapeamento grava os endereços de memória, tanto da física quanto da virtual para 
correspondência de acesso uma à outra. 

Mapeamento: Correspondência da alocação da memória virtual na física. ○
Gerencia de Memória Virtual:•
Uma página de um endereço virtual corresponde à um frame da memória física•
Falta de página: Endereço mapeado pela memória virtual na memória real não é encontrado, dados estão no 
disco.
•
O espaço de endereçamento são tabelas de endereço, contem endereços para o hardware. Essas tabelas ficam na 
memória RAM, na parte reservada para o SO.
•
Há apenas um espaço de endereçamento real, o virtual acompanha a quantidade de processos. ○
Cada processo tem um espaço de endereçamento, uma tabela de mapeamento, assim, não consegue invadir o 
espaço de endereço (virtual) de outro processo.
•
MMU: parte do hardware que faz o mapeamento. Encontra o endereço a partir do endereçamento virtual. As 
tabelas são mantidas pelo SO. - faz trabalho de mapeamento com os dados gerados pelo SO.
•
 Página 24 de Sistemas Operacionais 
ETP: Entrada de tabela de página
Tabela de página tem várias ETP
O processo na tabela de páginas pode apontar para a memória principal(dados já estão na RAM) ou 
para a memória secundária (falta pagina)

Dentro do Endereço do Frame: Endereço do Frame + deslocamento
O endereço virtual é diferente do real, mas o deslocamento é igual. Aproveita-
se ele. 

Dentro do NPV: ETP + Endereço do Frame◊
NPV (nº da página virtual- índice) + deslocamento;
Endereço virtual□
Página virtual
Se a RAM estiver cheia. O SO tem que escolher um frame para tirar (swap).
O restante dos bits é chamado do deslocamento e são iguais no endereço real que é 
passado para o MMU.

A tabela mapeia uma página virtual que contém uma parte do endereço real e indica se está na 
memória principal ou não. Se não estive o SO vai no disco e leva para a RAM
□
Os primeiros 4 bits dos 16 do endereço virtual são o índice da tabela de entrada de página - mundo 
virtual

Um programa de 4 GB não rodaria na memória de 2 GB - Com a tabela de página, fica-se 
mapeando os 4 GB em 2 GB.
□
Se não tivesse a tabela de página, o processo ficaria limitado ao tamanho da RAM, a memória virtual 
perderia seu propósito de gerar mais endereços.

O endereço de memória física é menor que o endereço virtual, pois o espago de endereçamento é 
menor. 

Modificado - valor mudado na memória ou na página. 
Presente/Ausente - dados estão na memória ou não
Proteção - Se desligado está tentando invadir a área de outro processo. 
Referenciado - Processo usou esse endereço (É marcado o tempo da última vez que foi 
referenciado) - Se tiver muito tempo que foi referenciado da última vez, o frame será 
retirado se necessário. 

□
Entrada típica de página
Substituição de página: Processo gera um endereço virtual que quando mapeado não está na 
memória principal. Acha a página no disco e a leva para a RAM - ela está cheia, precisa-se substituir 
uma página que está lá. Retira-se uma página da memória principal e a leva para o disco. 

□
A primeira vez que o processo referência um frame dá falta de página porque ainda não está na 
memória. É a primeira vez que inicia um processo, é mais lento por isso. 

Paginação:○
Técnicas de Mapeamento•
Falta de página força uma escolha
Antes de tirar da memória RAM o frame tem que ser salvo no disco para não pegar uma página 
antiga. 
□
Página modificada deve primeiro ser salva
Tira-se a que está mais tempo sem uso. □
Melhor não escolher uma página que está sendo muito usado 
Substitui o frame, mas faz um ajuste na tabela de páginas○
Algoritmos de Substituição de Página - Escolhe um frame para sair. •
FIFO: Substitui a página mais antiga da lista, em relação a entrada na memória RAM, não se importa se foi 
recentemente modificada ou usada. 
○
Segunda Chance: Usa o bit referenciada. Variação do FIFO, mas se a página mais antiga tiver sido 
referenciada (bit 1) ela não é retirada, o bit é zerado e a página é colocada no fim da fila, vira jovem 
novamente, mas se todas as páginas tiverem sido referenciadas, volta-se para FIFO. Minimiza-se o risco de 
tirar uma página que está sendo usada. - Passa de página em página testando o R. 
○
Relógio: As páginas não ficam mais em fila (gera custo para percorrer). Cria-se um ponteiro, fila circular. As 
páginas ficam onde devem e o ponteiro aponta para elas. As páginas não são reorganizadas como no 
algoritmo segunda-chance, mas a substituição é igual. Só tira o custo de percorrer a fila - vetor- Ponteiro é 
um custo menor. 
○
Classe 0: Não referenciada nem modificada.
Classe 1: Não referenciada, mas modificada.
Classe 2: Referenciada, mas não modificada. 
Classe 3: Referenciada e modificada. 
Páginas são retiradas aleatoriamente - sem estrutura de dados, estruturação ruim - não por lista ou 
vetor. Segue da classe mais baixa para a mais alta. 

NUR (Não usado recentemente): Página tem bit referenciado e modificado. Páginas são classificadas em:○
LRU ou MRU (Menos usada recentemente): Assume que página usada recentemente logo serão usadas 
novamente. Lista encadeada de página deve ser mantida; página mais recentemente usada vai para o início 
da fila, tira-se a página do final da fila. 
○
 Página 25 de Sistemas Operacionais 
da fila, tira-se a página do final da fila. 
Algoritmo determina qual página sai.
Memória está cheia, uma página (processo) é retirada para que seja colocado uma nova página. ○
Algoritmo de substituição de página:•
Nem sempre que há falta de página há substituição de página, a memória principal pode ter espaço 
para a nova página. 

Processo requisita determinado endereço de memória, este não está na memória principal - falta de página, 
tem que buscar na memória secundária. 
○
Falta de página:•
 Página 26 de Sistemas Operacionais 
Problemas: Quando um processo sai, fica um buraco no espaço, que pode não caber outro processo, gerando a 
fragmentação. 
□
Pode ser em alocação contígua - vetor
Lista ligada relaciona os blocos espalhados que o processo ocupa, não é contígua, diminui a fragmentação. Sistema 
encadeado. 

FAT: não tem na memória primária, é o mais conhecido. Há uma tabela com blocos. 
Gravar na memória RAM○
Como a memória é alocada:•
Deve ser possível armazenar uma quantidade muito grande de informação - GB1
Persistência - A informação deve sobreviver ao término do processo que a usa. 2
Múltiplos processos devem ser capazes de acessar a informação concorrentemente. 3
Armazenamento de longo prazo - memória secundária. •
Indiferente para o SO, facilita para as aplicações que os rodam. ○
Linux determina se um arquivo é executável pelos modificadores de arquivos. (-x)○
Extensão de arquivo•
O arquivo não passa de um amontoado de bytes organizados em diretórios. i.
Organização não estruturada - Utilizada pelo SO. I.
Há uma preocupação com a busca de um arquivo, que se torna mais rápida. i.
Árvore binária: Tem como objetivo criar uma árvore de busca, rápida. ii.
Organização indexada - Utilizada em Bancos de Dados. II.
Organização dos Arquivos:•
Sequência de bytes - SOa.
Sequência de registro - Struct em Cb.
Árvore - Banco de Dados. c.
Formas de se ver um arquivo•
Lê todos os bytes/registros desde o início
Não pode saltar ou ler fora de sequência
Conveniente quando o meio era a fita magnética
Acesso sequencial - Fita VHS○
Bytes/registros lidos em qualquer ordem
Essencial para sistemas de base de dados
Mover marcador do arquivo - seek - e então ler, ou...□
Ler e então mover marcador de arquivo. □
Ler pode ser:
Aceso aleatório - CD - Acesso direto○
Acesso aos arquivos•
Atributos de um arquivo -•
Recorte de tela efetuado: 24/02/2016 14:44
Operações de E/S - Rotinas de E/S •
Recorte de tela efetuado: 24/02/2016 14:45
Create: SO aloca blocos. ○
Open: Torna o arquivo pronto para acesso. SO enxerga o arquivo no processo. Processo sabe onde está pelo menos o primeiro bloco 
do arquivo. 
○
Função OPEN/CLOSE - garantem a consistência . Um app por vez no arquivo. Arquivo aberto não é deletado. 
Close: Fecha a permissão, concretiza as informações no disco. ○
Apagar um bloco significa sobrescreve-o todo com zeros. Se o espaço for requisitado, vai sendo sobreposto. ->. Qualquer 
sistema de persistência. 

Delete: SO não deleta o arquivo, é marcado como deletado. É uma operação muito cara para deletar. ○
Se um arquivo estiver fechado e ele for criado de novo, é sobrescrito.○
Quando manda copiar um arquivo par ao pendrive, usa-se RAM como buffer, quando manda ejetar que realmente é salvo no 
pendrive. 
○
Diretório: Pasta - forma de organizar arquivos.○
Sistema de diretórios em nível único•
O primeiro bloco armazena onde o outro bloco está. Guarda informação e há mais o endereço para o próximo. ○
O último bloco tem que ter o controle de que é o último bloco.
Alocação Encadeada:•
Curto prazo = RAM•
Dado persistente = armazenadoem longo 
prazo. Persistido = gravado. 
•
SO busca arquivo com força bruta = SO olha de 
arquivo em arquivo. 
•
Em questão de gerenciamento de arquivos - SO 
é diferente de Banco de Dados. 
•
Cartucho de videogame é similar ao cartucho 
que backup - Estende o hardware. 
•
Arquivos são divididos em blocos - Blocos 
menores são mais fáceis de controlar do que 
blocos grandes.
•
Formatação Lógica -Destrói o MBR - primeira 
trilha do disco que diz as partições de um disco
•
I-NODE - Aponta para o diretório○
FAT - Blocos de tamanhos variados. ○
MS-DOS○
NT-FS - Windows ○
Pesquisas:•
Desfragmentação: Usando o computador ao 
mesmo tempo gera lentidão, o SO fica 
analisando qual parte está sendo usada pelo 
usuário. 
•
10- Quanto mais unidos os blocos, 
principalmente no início do disco, mais 
longe do eixo onde a leitura é mais 
rápida. 
○
Ler capítulo 4 do livro e fazer exercícios.•
Diferenças entre as implementações -
prós e contras.
○
Fragmentação○
Espaço Ocupado○
Questão de prova:•
Fica na parte do SO na RAM○
Mapa de Bits, Tabela de Espaço livre: •
Capítulo 4 - Sistemas de Arquivos
domingo, 14 de fevereiro de 2016 10:19
 Página 27 de Sistemas Operacionais 
O último bloco tem que ter o controle de que é o último bloco.○
Se desfragmentar ainda melhora o desempenho, pois os ponteiros ficam mais próximos. 
Diminui a fragmentação pois os blocos estão espalhados e são ordenados por ponteiros.○
Parte dos blocos é gasta com os ponteiros - Alocação encadeada de blocos○
FAT na RAM: navega na RAM, não no disco, não gasta espaço do bloco. 
Não há ponteiros nos disco.
Alocação encadeada com tabela de alocação: ○
Há uma tabela que diz onde um arquivo começa. Há uma tabela na RAM onde dentro de cada arquivo há o endereço de outro bloco.•
Cada bloco sabe onde está o outro, se der algum erro, tem que se iniciar novamente. ○
Perde-se espaço do bloco para guardar o endereço do próximo bloco. ○
Lista Encadeada:•
A tabela tem os endereços dos processos○
FAT fica no disco, quando em execução vai para a RAM para aumentar o desempenho. Quanto mais RAM, melhor
Alocação encadeada com a tabela - FAT○
Ponto negativo: Ocupa RAM○
Ponto positivo: O acesso é direto, mais rápido○
Bloco de indice - arvore leva a informação. 
Alocação indexada○
Alocação em tabela:•
Acesso rápido ao arquivo. Cada arquivo tem os endereços dos blocos que o arquivo ocupa.○
Quando um arquivo é criado, já é definido seus atributos e seu endereço inicial - bloco no disco. ○
Levado para a RAM, que enche - quanto mais RAM melhor
Cada bloco lógico contém um ponteiro para um bloco real - físico○
Desvantagem: Quanto maior o arquivo, maior o I-node do arquivo. ○
Quando um arquivo é aberto seu I-node é carregado para a RAM pelo SO○
No Unix diretórios também tem I-nodes, mas ocupam pouquíssimo espaço no disco○
I-node tem bloco físico, leva ao conteúdo do bloco, onde há o subdiretório que tem seu I-node.○
Quanto mais sub I-node, mais devagar o acesso. 
I-node tem limite de tamanho. Quando atinge o limite, são criados novos I-nodes apontados por ponteiros no I-node inicial. ○
I-nodes: Unix •
SuperBloco : onde fica o FAT•
Bloco de BOOT: da o Start Inicial - há o MBR•
Diretório-raiz: se for corrompido não há como navegar pelos arquivos. •
Gera muito overhead ao SO○
Lista Encadeada○
Tabela/contador = quantos blocos livres há sequencialmente a frente do bloco inicial○
Dado um bloco quer saber quantos há livres depois deles○
Há uma confusão -> fragmentação - livre e ocupados bagunçados. 
SO de tempos em tempos junta os espaços livres
Gerenciador começa procurando pelo início e descendo - percorrendo até achar outros blocos livres para alocar○
O bloco livre pode estar só marcado como livre - deletado○
Tabela não é atualizada o tempo todo. ○
Gerencia de Espaço Livre•
O I-node teria que ser lido no disco, muito mais lento que na RAM - se não houvesse o open. 
Open: I-node vai para a RAM - UNIX○
Chamada de Sistema•
 Página 28 de Sistemas Operacionais 
O Problema do Jantar dos Filósofos (com threads) 
Em ciência da computação, o problema do jantar dos filósofos é um exemplo ilustrativo de 
um problema comum de programação concorrente. É mais um problema clássico de 
sincronização multi-processo.
O problema pode ser resumido como cinco filósofos sentados ao redor de uma mesa 
redonda, cada qual fazendo exclusivamente uma das duas coisas: comendo ou pensando. 
Enquanto está comendo, um filósofo não pode pensar, e vice-versa.
Cada filósofo possui um prato cheio de spaghetti à sua frente. Além disso, um garfo é 
posicionado entre cada par adjacente de filósofos (portanto, cada filósofo tem exatamente 
um garfo à sua esquerda e exatamente um garfo à sua direita).
Como spaghetti é uma comida díficil para se servir e comer com um único garfo, assume-se 
que um filósofo necessita de dois garfos para poder comer. E, além disso, um filósofo só pode 
utilizar um garfo que esteja imediatamente à sua esquerda ou imediatamente à sua direita.
A falta de disponibilidade de garfos é uma analogia à falta de recursos compartilhados em 
programação de computadores (situação conhecida como concorrência). Travar (lock) um 
recurso é um técnica comumemente utilizada para assegurar que o recurso está sendo 
acessado somente por um programa ou trecho de código, por vez. Quando um programa está 
interessado em um recurso que já foi travado por outro, o programa espera até que ele seja 
destravado. Quando existem vários programas envolvidos no travamento de recursos, um 
deadlock pode acontecer, dependendo das circunstâncias.
Para exemplificar, podemos citar um programa que necessita processar dois arquivos. 
Quando duas instâncias desse programa travam um arquivo cada, ambos os programas 
esperam o outro destravar o arquivo que falta, o que nunca irá ocorrerá.
Em geral, o problema do jantar dos filósofos é um problema genérico e abstrato que é 
utilizado para explicar diversas situações indesejáveis que podem ocorrer em problemas que 
tem como principal idéia a exclusão mútua.
Por exemplo, assim como no caso acima, deadlock/livelock é um conceito que pode ser bem 
explicado através do problema dos filósofos.
Abaixo encontra-se uma possível solução para o problema.
A solução apresentada é livre de deadlocks e permite o máximo de paralelismo a um número 
arbitrário de filósofos. Ela usa um arranjo, state, para controlar se um filósofo está comendo, 
Jantar dos Filósofos
domingo, 31 de janeiro de 2016 09:59
 Página 29 de Sistemas Operacionais 
arbitrário de filósofos. Ela usa um arranjo, state, para controlar se um filósofo está comendo, 
pensando ou faminto (tentando pegar garfos). Um filósofo só pode mudar para o estado 
'comendo' se nenhum dos vizinhos estiver comendo. Os vizinhos do filósofo i são definidos 
pelas macros LEFT e RIGHT. Em outras palavras, se i for 2, LEFT será 1 e RIGHT será 3.
O programa usa um arranjo de semáforos, um por filósofo; assim, filósofos famintos podem 
ser bloqueados se os garfos necessários estiverem ocupados. Observe que cada thread 
executa o procedimento philosopher como seu código principal, mas os outros 
procedimentos - take_forks, put_forks e test - são procedimentos ordinários, e não 
processos separados.
Figura1: Saída do Programa
(clique na figura para melhor visualização)
Código:
#include "stdio.h"
#include "stdlib.h"
#include "unistd.h"
#include "fcntl.h"
#include "sys/types.h"
#include "pthread.h"
#include "semaphore.h"
#define N 5 /* número de filósofos*/
#define LEFT (i+N-1)%N /* número do vizinho à esquerda de i*/
#define RIGHT (i+1)%N /* número do vizinho à direito de i*/
#define THINKING 0 /* o filósofo está pensando*/
#define HUNGRY 1 /* o filósofoestá tentando pegar garfos*/
#define EATING 2 /* o filósofo está comendo*/
#define TRUE 1 
<
int state[N]; /* arranjo para controlar o estado de cada um*/
sem_t mutex; /* exclusão mútua para as regiões críticas*/
sem_t s[N]; /* um semáforo por filósofo*/
/* protótipos */
void* philosopher(void* arg);
void take_forks(int i);
 Página 30 de Sistemas Operacionais 
void take_forks(int i);
void put_forks(int i);
void test(int i);
void eat(int i);
void think(int i);
int main() {
int i;
sem_init(&mutex, TRUE, 1);
for(i = 0; i < N; i++) {
sem_init(&s[i], TRUE, 1);
}
pthread_t tphil[5];
/* criando os 5 filósofo - 1 thread para cada*/
for(i = 0; i < N; i++) {
pthread_create(&tphil[i], NULL, (void *) philosopher, (void *) &i);
}
for(i = 0; i < N; i++) {
pthread_join(tphil[i], NULL);
}
return 0;
}
void* philosopher(void * arg) { /*i: o número do filósofo, de 0 a N-1*/
int i = *((int *) arg);
while(TRUE) { /* repete para sempre*/
think(i); /* o filósofo está pensando*/
take_forks(i); /* pega dois garfos ou bloqueia*/
eat(i); /* o filósofo está comendo*/
put_forks(i); /* devolve os dois garfos à mesa*/
}
pthread_exit(NULL);
}
void take_forks(int i) { /*i: o número do filósofo, de 0 a N-1*/
sem_wait(&mutex); /* entra na região crítica*/
state[i] = HUNGRY; /* registra que o filósofo está faminto*/
test(i); /* tenta pegar dois garfos*/
sem_post(&mutex); /* sai da região crítica*/
sem_wait(&s[i]); /* bloqueia se os garfos não foram pegos*/
}
void put_forks(int i) { /*i: o número do filósofo, de 0 a N-1*/
sem_wait(&mutex); /* entra na região crítica*/
state[i] = THINKING; /* o filósofo acabou de comer*/
test(LEFT); /* vê se o vizinho da esquerda pode comer agora*/
test(RIGHT); /* vê se o vizinho da direito pode comer agora*/
sem_post(&mutex); /* sai da região crítica*/
}
void test(int i) {
if (state[i] == HUNGRY && state[LEFT] != EATING && state[RIGHT] != EATING) {
state[i] = EATING;
 Página 31 de Sistemas Operacionais 
state[i] = EATING;
sem_post(&s[i]);
}
}
void eat(int i) { /*i: o número do filósofo, de 0 a N-1*/
printf("Filosofo %d estah comendo!\n", i);
sleep( rand()%5 );
}
void think(int i) { /*i: o número do filósofo, de 0 a N-1*/
printf("Filosofo %d estah pensando!\n", i);
sleep( rand()%10 );
}
De <http://ces33.blogspot.com.br/2009/05/o-problema-do-barbeiro-dorminhoco-com.html> 
 Página 32 de Sistemas Operacionais 
programmerinterview.com February 9, 2016
The reason that semaphores and monitors are needed is because multi-threaded applications (like 
Microsoft Word, Excel, etc) must control how threads access shared resources. This is known as thread 
synchronization – which is absolutely necessary in a multi-threaded application to ensure that 
threads work well with each other. If applications do not control the threads then it may result in 
corruption of data and other problems.
Do I use a monitor or a semaphore?
Monitors and semaphores are both programming constructs used to accomplish thread 
synchronization.
Whether you use a monitor or a semaphore depends on what your language or system supports.
What is a Monitor?
A monitor is a set of multiple routines which are protected by a mutual exclusion lock. None of the 
routines in the monitor can be executed by a thread until that thread acquires the lock. This means 
that only ONE thread can execute within the monitor at a time. Any other threads must wait for the 
thread that’s currently executing to give up control of the lock.
However, a thread can actually suspend itself inside a monitor and then wait for an event to occur. If 
this happens, then another thread is given the opportunity to enter the monitor. The thread that was 
suspended will eventually be notified that the event it was waiting for has now occurred, which means 
it can wake up and reacquire the lock.
What is a Semaphore?
A semaphore is a simpler construct than a monitor because it’s just a lock that protects a shared 
resource – and not a set of routines like a monitor. The application must acquire the lock before using 
that shared resource protected by a semaphore.
Example of a Semaphore – a Mutex
A mutex is the most basic type of semaphore, and mutex is short for mutual exclusion. In a mutex, 
only one
thread can use the shared resource at a time. If another thread wants to use the shared resource, it 
must wait for the owning thread to release the lock.
Differences between Monitors and Semaphores
Both Monitors and Semaphores are used for the same purpose – thread synchronization. But, 
monitors are simpler to use than semaphores because they handle all of the details of lock acquisition 
and release. An application using semaphores has to release any locks a thread has acquired when the 
application terminates – this must be done by the application itself. If the application does not do this, 
then any other thread that needs the shared resource will not be able to proceed.
Another difference when using semaphores is that every routine accessing a shared resource has to 
explicitly acquire a a lock before using the resource. This can be easily forgotten when coding the 
routines dealing with multithreading . Monitors, unlike semaphores, automatically acquire the 
necessary locks.
Is there a cost to using a monitor or semaphore?
Yes, there is a cost associated with using synchronization constructs like monitors and semaphores. 
And, this cost is the time that is required to get the necessary locks whenever a shared resource is 
accessed.
Monitors vs Semaphores
quarta-feira, 10 de fevereiro de 2016 11:39
 Página 33 de Sistemas Operacionais 
stackoverflow.com February 9, 2016
A Monitor is an object designed to be accessed from multiple threads. The member functions or 
methods of a monitor object will enforce mutual exclusion, so only one thread may be performing any 
action on the object at a given time. If one thread is currently executing a member function of the 
object then any other thread that tries to call a member function of that object will have to wait until 
the first has finished.
A Semaphore is a lower-level object. You might well use a semaphore to implement a monitor. A 
semaphore essentially is just a counter. When the counter is positive, if a thread tries to acquire the 
semaphore then it is allowed, and the counter is decremented. When a thread is done then it releases 
the semaphore, and increments the counter.
If the counter is already zero when a thread tries to acquire the semaphore then it has to wait until 
another thread releases the semaphore. If multiple threads are waiting when a thread releases a 
semaphore then one of them gets it. The thread that releases a semaphore need not be the same 
thread that acquired it.
A monitor is like a public toilet. Only one person can enter at a time. They lock the door to prevent 
anyone else coming in, do their stuff, and then unlock it when they leave.
A semaphore is like a bike hire place. They have a certain number of bikes. If you try and hire a bike 
and they have one free then you can take it, otherwise you must wait. When someone returns their 
bike then someone else can take it. If you have a bike then you can give it to someone else to 
return --- the bike hire place doesn't care who returns it, as long as they get their bike back.
Semaphore vs. Monitors - what's the difference?
quarta-feira, 10 de fevereiro de 2016 11:40
 Página 34 de Sistemas Operacionaispaulomotta.pro.br August 25, 2009
Os computadores com mais de um processador chegaram para ficar. Existem pesquisas no sentido de 
substituir o silício usado para construir os processadores por outra substância, mas enquanto isso não 
se torna economicamente viável a saída para o silício, uma vez que chegamos ao limite de velocidade 
que podemos atingir, a alternativa é aumentar a quantidade de núcleos executando. Isso significa na 
prática que agora o sistema operacional pode colocar mais de um programa efetivamente executando 
ao mesmo tempo. Embora possam executar ao mesmo tempo porque haverá mais de um 
processador, as aplicações vão concorrer pelos outros recursos, porque de acordo com nossas 
arquiteturas baseadas no modelo von Neuman, usamos um barramento para fazer as trocas de 
informações e para acessar canais de entrada e saída.
Essa característica já é estudada nos cursos de sistemas operacionais há tempos, até porque quando 
só havia um núcleo disponível (e isso ainda acontece em diversas plataformas) as aplicações 
concorrem também pelo uso do processador. A parte interessante é que este problema, típico da área 
de sistemas, foi trazido para a área de aplicações inicialmente quando tivemos acesso à criação de 
novos processos (via fork por exemplo) e à threads. Neste último caso, as novas linguagens já trazem 
suporte ao trabalho com threads de forma nativa o que ajudou muito a difundir seu uso, no entanto 
talvez não tenhamos dado devida atenção ao domínio das técnicas para usar esse tipo de ferramenta.
Existe muito material disponível sobre threads, mas por hora podemos entender como sendo as linhas 
de execução de um programa, ou seja, mais de uma tarefa do próprio programa acontece (ou tenta 
acontecer) ao mesmo tempo. Com isso temos que nos preocupar com os problemas de concorrência, 
originalmente da área de sistemas, dentro da nossa aplicação.
Condições de corrida (race conditions) – dois ou mais participantes (aplicações) disputam entre 
si por um recurso, ou seja, se assemelha a uma corrida por um troféu.
•
Regiões críticas (critical regions) – são as regiões ou seções do programa em que fazemos uso 
do recurso que é compartilhado, identificando essas partes do programa torna-se possível 
isolá-las de forma que possamos controlar o início e fim do uso de algum recurso 
compartilhado.
•
Para isso vale a pena rever os conceitos ensinados em sistemas operacionais referentes a:
Tendo relembrado desses conceitos a primeira coisa que temos a falar é da exclusão mútua, que 
significa que dois ou mais participantes excluem-se entre si, ou seja, só um pode acessar o recurso 
compartilhado por vez. O problema então é: como conseguir sinalizar isso? Para responder essa 
pergunta temos uma série de técnicas que foram propostas também para a área de sistemas 
operacionais, até porque são técnicas de mais baixo nível. O ideal é que o mecanismo ou estratégia 
de exclusão mútua seja fornecido pelo ambiente (ou pela linguagem, ou pela biblioteca) usado.
A primeira forma que pensamos é a espera ocupada (busy wait), onde o processo que está esperando 
gasta seus ciclos de processador sem fazer nada, basicamente equivale a fazer um laço (while ou for) 
onde testamos a condição para saber se já pode ser executado. Como o sistema operacional faz a 
troca de processos de tempos em tempos, eventualmente o processo que tem controle do recurso vai 
terminar de usar e liberar, e alguém da fila de espera vai ser colocado para executar. Quando essa 
nova troca acontece o laço encerra uma vez que a condição de recurso livre foi atingida. Esses turnos 
vão se alterando, o que percebemos é que essa estratégia desperdiça ciclos de processador sem 
realizar uma tarefa útil, logo só serve como exemplo. Em alguns casos de máquinas com vários 
processadores (ou vários núcleos) pode ser necessário usar essa técnica para sincronizar a leitura de 
registradores compartilhados ou para verificar se um outro núcleo já disponibilizou o conteúdo 
esperado, encontramos exemplos disso em vários dos manuais da IBM para programação do Cell 
Broadband Engine, processador que equipa o Playstation 3 da Sony.
Uma outra alternativa mais de baixo nível (especificamente no nível da máquina exatamente) é ter 
uma instrução capaz de testar uma variável (ou registrador) e no mesmo ciclo trocar seu valor. A ideia 
aqui é que se a variável não estiver com alguma das aplicações concorrentes então quem executou 
essa instrução consegue o recurso, se não estiver disponível então simplesmente retorna. Bom a 
questão aqui é como disponibilizar essa instrução para as linguagens de mais alto nível
Por outro lado se usarmos uma solução baseada no sistema operacional ao invés de uma instrução de 
Exclusão Mútua, Semáforos e Monitores
quarta-feira, 10 de fevereiro de 2016 11:40
 Página 35 de Sistemas Operacionais 
Por outro lado se usarmos uma solução baseada no sistema operacional ao invés de uma instrução de 
máquina, torna-se mais simples de torná-la acessível para as linguagens de programação de alto nível 
A alternativa é usar duas chamadas do sistema SLEEP (dormir) e WAKEUP (acordar), dessa forma 
quando testamos a variável e verificamos que a condição que precisamos não está disponível, 
executamos a chamada SLEEP para que o processo possa esperar até que o recurso esteja disponível 
De forma simétrica quando liberamos um recurso, chamamos WAKEUP dizendo qual processo deve 
executar agora (de forma que vá conseguir o recurso que tem interesse.)
Quando usamos semáforos, essas chamadas de sistema são encapsuladas em chamadas que realizam 
um controle extra. Isso é necessário porque as chamadas SLEEP e WAKEUP não conseguem por si só 
garantir a exclusão mútua. Um semáforo é uma variável especial sobre a qual podemos executar as 
operações DOWN (abaixar) e UP (levantar.) Como chamadas de sistemas, precisam ser implementadas 
com algum código, dentro desse código, além de verificar o valor da variável passada (o semáforo) 
também trocamos o valor se for o caso, como se fosse uma instrução de baixo nível Para garantir que 
o processo executando não vai ser interrompido antes da variável trocar o valor as interrupções da 
máquina são desligadas, isso garante a execução atômica, ou seja, como se fosse uma única instrução, 
logo em seguida as interrupções de máquinas são ligadas e o processo já pode ser trocado pelo 
sistema operacional.
Uma outra característica importante é que o uso de semáforos permite tornar a concorrência uma 
tarefa de mais alto nível já que elimina o uso de referências direta aos outros processos. Se for 
necessário um conjunto grande de processos executando o uso de semáforos permite conhecer 
apenas uma variável, enquanto a referência direta necessitaria de um vetor para armazenar todas as 
referências.
O problema surge quando usamos mais de um semáforo para controlar tanto a exclusão mútua 
quanto o uso do recurso compartilhado. Neste caso se não nos concentrarmos na ordem de execução 
das operações podemos acabar bloqueados
Uma solução para isso é o uso de monitores, que na verdade é uma construção mais ampla composta 
de funções e estruturas de dados próprias. Normalmente o compilador conhece essa estrutura e é o 
compilador que ordena as questões referentes as garantias de exclusão mútua e sincronização, isto 
porque um monitor é construído sobre as soluções oferecidas pelos semáforos. A vantagem disso é 
que o programador passa a usar um mecanismo de mais alto nível e só precisa conhecer as operações 
WAIT (esperar) e SIGNAL (sinalizar,) usadas sobre uma variável que é o monitor, ou seja, quando o 
programador declara a variável, o compilador intervem colocando as instruções necessárias para as 
garantias. Do ponto de vista conceitual, as soluções