SO - Integrado - Aula 02 - Processos e Threads.pptx

Sistemas Operacionais
Prof. MSc. José Hermano Cavalcanti Filho
http://www.ifpb.edu.br
jose.cavalcanti@ifpb.edu.br

Processos
 Conceito de processo;
 Criação e término de um processo;
 Estado de um processo;
 Implementação de processos;
 Fila de processo;
 Escalonador;
 Comunicação entre processos;

Processos
 Um programa em execução;
 A execução do processo deve progredir de modo
sequencial;
 Um SO executa diversos programas:
 Sistemas batch – jobs;
 Sistemas compartilhados no tempo – programas ou tarefas
do usuário;
 Normalmente job e processo são sinônimos;

Processos
 (a) – Multiprogramação de quatro programas;
 (b) – Modelo Conceitual de quatro processos sequenciais;
 (c) – Somente um programa está ativo a cada momento;

Processos
 Um processo inclui:
 Contador de programa (fluxo de controle);
 Pilha;
 Seção de dados;

Processos
 Exemplo:
 Processo – Fazer um bolo:
 Receita do bolo (programa/algoritmo);
 Ingredientes (dados de entrada);
 Materiais de cozinha (recursos);
 Cozinheiro (processador);
 Processo – Socorro médico:
 Registra onde parou o processo anterior (estado do
processo);
 Busca um livro de primeiro socorros;
 Segue as instruções;
 Volta para o processo anterior;

Criação de Processos
 É criado por um processo existente executando uma
chamada de sistema para a criação de processo;
 Processo pai cria processos filho que, por sua vez, criam
outros processos, formando uma árvore de processos:
 Compartilhamento de recursos;
 Pai e filhos compartilham todos os recursos;
 Filhos compartilham subconjunto dos recursos do pai;
 Pai e filho não compartilham recursos;
 Execução:
 Pai e filhos executam simultaneamente;
 Pai espera até que filhos terminem;

 Espaço de endereços:
 Filho duplica do pai;
 Filho tem um programa carregado;
 Exemplos do UNIX:
 Chamada do sistema fork cria novo processos;
 Chamada do sistema exec usada após um fork para
substituir o espaço de memória do processo por um novo
programa;
 Exemplos do Windows:
 Chamada do sistema CreateProcess cria novo processos;

 Podem ser de acordo com a utilização do processador e dos
dispositivos de E/S:
 CPU-bound – passa a maior parte do tempo em estado de
execução, utilizando o processador, ou pronto. Ex.: Cálculos
científicos;
 I/O-bound – passa a maior parte do tempo no estado de
espera, pois realiza um elevado número de operações de
E/S. Ex.: Processo interativo, aguardar pelo usuário.

 Podem utilizar dois meios de comunicação:
 Foreground (primeiro plano) – interagem com usuários;
 Background (segundo plano) – não estão associados a
usuários em particular;
 Também chamado de Daemon;
 Ex.: aceitar mensagens eletrônicas sendo recebidas,
comando ps linux, gerenciador de tarefas windows, clicar
em um icone de programa no SO;

Término de um Processo
 Mais cedo ou mais tarde o novo processo terminará,
normalmente em razão de alguma das seguintes condições:
 Saída normal (voluntária);
 Saída por erro (voluntária);
 Erro fatal (involuntário);
 Cancelamento por um outro processo (involuntário)

 Exemplos do UNIX:
 Chamada do sistema exit – saída normal;
 Chamada do sistema kill – saída por outro processo;
 Exemplos do Windows:
 Chamada do sistema ExitProcess;
 Chamada do sistema TerminateProcess – saída por outro
processo;

 Processo executa última instrução e pede ao SO para excluí-
la (exit):
 Dados de saída do filho para o pai (via wait);
 Recursos do processo são desalocados pelo SO;
 Pai pode terminar a execução dos processos dos filhos
(abort):
 Filho excedeu recursos alocados;
 Tarefa atribuída ao filho não é mais exigida;
 Se o pai estiver saindo:
 Alguns SO não permitem que o filho continue se o pai
terminar;
 Todos os filhos terminam – término em cascata;

Estados de um Processo
 Novo:
 Processo está sendo criado;
 Executando (running):
 Instruções estão sendo executadas;
 Esperando (wait):
 Processo está esperando que ocorra algum evento;
 Pronto (ready):
 Processo está esperando para ser executado;
 Terminado:
 Processo terminou a execução;

Troca de Contexto
 Quando a CPU passa para outro processo, o sistema deve
salvar o estado do processo antigo e carregar o estado
salvo para o novo processo;
 O tempo de troca de contexto é overhead;
 O sistema não realiza trabalho útil enquanto faz a troca;
 Tempo dependente do suporte do hardware;

Implementação de processos
 É criada uma tabela de processos, com uma entrada para
cada processo;
 Alguns autores chamam essa tabela de PCB – Process
Control Block;
 Ela contém informações associadas a cada processo:
 Estado do processo;
 Contador de programa;
 Registradores da CPU;
 Informação de escalonamento da CPU;
 Informação de gerenciamento de memória;
 Informação de contabilidade;
 Informação de status de E/S;

Filas de Processos
 Fila de job:
 Conjunto de todos os processos no sistema;
 Fila de pronto:
 Conjunto de todos os processos residindo na memória
principal, prontos e esperando para execução;
 Filas de dispositivo:
 Conjunto de processos esperando por um dispositivo de E/S;
 Processos migram entre as diversas filas;

Escalonador
 Responsável pela ordenação das filas de processos;
 Tipos de escalonadores:
 Longo prazo:
 Seleciona quais processos devem ser trazidos para a fila
de pronto;
 É invocado com pouca frequência (segundos, minutos);
 Controla o grau de multiprogramação;
 Curto prazo:
 Seleciona qual processo deve ser executado em seguida
e aloca CPU;
 É invocado muito frequentemente (milissegundos);

Atividades Laboratório – Simulador Sosim (Pág 79)
 Criação de Processos;
 Tipos de Processos;
 PCB;
 Estatísticas;
 Log de execução;
 Suspensão e Eliminação de Processos;

Threads
 É uma linha de execução de código que executa em paralelo
com outras linhas do mesmo processo, compartilhando seu
espaço de memória;
 Na prática uma thread é equivalente a um mini-processo
dentro de um processo;
 Isto permite que várias ações sejam executadas em paralelo
por um mesmo processo.

Threads
 Em um programa muitas vezes é necessário executar mais
de uma atividade ao mesmo tempo;
 Ex.: aguardar a entrada de dados do usuário e reproduzir um
som enquanto aguarda;
 Uma thread é muito mais leve que um processo comum;
 Ganho de performance na criação e destruição de threads se
comparada a processos (10 a 100x);
 Quando uma aplicação tem atividade I/O bound e CPU
bound as threads podem acelerar a execução, pois não
concorrerão por recurso;

Threads
 Exemplo: Utilizar um processador de texto para escrever um
livro de 800 páginas.
 Uma thread para o cursor do editor;
 Uma thread para reformatar o texto;
 Uma thread para salvar o arquivo automaticamente;

Threads
 Se o exemplo anterior tivesse apenas uma thread, então,
sempre que um backup de disco se iniciasse, os comandos
do teclado e do mouse seriam ignorados enquanto o backup
não terminasse;
 O usuário certamente perceberia isso como uma queda de
desempenho;
 Deve estar claro que três processos separados não
funcionariam no exemplo dado, pois todos os três threads
precisam operar sobre o documento;
 Outro exemplo: planilha eletrônica com cálculos em certos
campos;

Threads
 O uso de Threads pode garantir um uso máximo dos vários
processadores existentes em uma CPU;

Threads
 Recursos:
 A thread utiliza os recursos do processo;

Threads
 Recursos:
 Contador de Programa – Posição da sequência da thread;
 Registradores – Área que irá armazenar as threads;
 Pilha – Instruções que serão executadas;
 Estado – O estado da thread (novo, espera, pronto, ...)

Threads
 Comandos comuns:
 Create() – Cria uma nova thread;
 Exit() – Encerra uma thread liberando os recursos alocados
para esta;
 Join() – Aguarda que uma outra thread termine para
continuar a execução, útil quando uma thread necessita de
dados de outra;
 Yield() ou Sleep() – Libera a CPU e volta para fila de pronto,
comum quando a atividade da thread não é necessária no
momento;

Threads
 Implementação:
 Podem ser implementadas em:
 nível de usuário
 em nível de kernel
 forma híbrida;
 As alternativas são válidas e tem vantagens e desvantagens;

Threads
 Em nível de usuário:
 Nesse modelo uma biblioteca de threads é responsável por
gerenciar a multiprogramação e escalonamento das threads;
 Cada processo precisa de sua própria tabela de threads;

Threads
 Em nível de usuário:
 Nesse modelo a mudança de uma thread para outra é rápida
pois não envolve necessariamente uma sytem call;
 A troca entre esses tipos de threads é da ordem de
nanosegundos;
 Permitem que cada processo use o algoritmo de
escalonamento que achar mais adequado;
 São mais econômicas quanto ao espaço de memória (no
kernel) necessário para sua implementação;

Threads
 Em nível de usuário - desvantagens:
 Uma chamada bloqueante pode bloquear todo o processo e
não apenas a thread em questão;
 Uma page_fault pode ocorrer o que causará uma system call
e também parará todo o processo;
 Dentro de um processo não há como o escalonador contar o
tempo de uso da CPU para retirar uma thread de execução a
não ser que esta execute yield;
 A maioria dos processos de usuário que usam threads o
fazem pela característica I/O bound o que implica que
bloquearão o sistema sempre que fizerem I/O;

Threads
 Em nível de kernel:
 Nesse modelo o kernel cuida da criação e escalonamento
das threads de todos os processos;
 O núcleo tem uma tabela de threads;

Threads
 Em nível de kernel:
 As chamadas de criação e fim de threads são gerenciadas
pelo kernel;
 Isso significa um overhead para essas operações;
 Este modelo de implementação resolve um problema grave
das threads em nível de usuário:
 Threads que bloqueiam um processo inteiro;
 Uma estratégia para diminuir o overhead é reciclar threads;

Threads
 Estratégia híbrida:
 Múltiplas threads mapeadas em uma thread do kernel;

Comunicação entre Processos (IPC – Interprocess Comunication)
 Os SO’s hoje em dia são multitarefa;
 Alguns processos precisam cooperar para cumprir seus
objetivos;
 Sugestões de implementação?
 Exemplos:
 Um aplicativo imprimindo um documento.

Comunicação entre Processos (IPC – Interprocess Comunication)
 Problemas:
 Como um processo passa a informação para outro?
 Como garantir que dois processos não entrem em
conflito?
 Ex.: Reservar o mesmo lugar no avião
 Qual a sequência adequada quando existirem
dependências?
 Ex.: P1 produz os dados e P2 os imprime. P2 deve
esperar até que P1 produza os dados.

Comunicação entre Processos
 Condição de Corrida (Race Condition)
 Condição em que dois processos leem e escrevem um dado
compartilhado e o resultado final depende da ordem em que
os processos são executados;
 Lembra-se que em um sistema multitarefa um processo pode
ser retirado da execução para pronto a qualquer momento;
 Essa condições são muito difíceis de debuggar, encontrar
falhas, que podem ocorrer dependendo de fatores externos;

 Dois processos querem acessar a memória compartilhada ao
mesmo tempo;

 Uma solução para o problema da condição de corrida é
evitar que mais de um processo leia/escreva ao mesmo
tempo;
 Essa estratégia é chamada exclusão mútua (mutex);
 É dever do programador, identificar estas situações e
proteger seu código nestas situações;

 Para que a solução seja implementada pelo SO, 4 condições
são necessárias:
 Dois processos não podem estar em sua região crítica
simultaneamente;
 A solução deve funcionar para qualquer número de CPUs
e qualquer velocidade;
 Nenhum processo fora da região crítica pode bloquear
outros processos;
 Nenhum processo deve esperar eternamente para entrar
em sua região crítica;

 Algumas soluções possíveis:
 Desabilitar interrupções;
 Variáveis de trava (lock);
 Chaveamento obrigatório;
 Solução de Peterson;
 Dormir e acordar;
 Semáforos;
 Mutex;
 Monitores;

 Desabilitar interrupções:
 Ao entrar na região crítica ficam desabilitadas as
interrupções;
 Evita que ocorra troca de contexto por tempo;
 Em um sistema multiprocessado pode ser complexo ou
impossível desabilitar a interrupção em todos os
processadores;
 Entregar o controle das interrupções ao usuário pode ser
perigoso se o processo não habilitar novamente estas
interrupções;

 Variáveis de trava (lock):
 Uma única variável lock indica quando há algum processo
em uma região crítica;
 Se lock == 0 não há processo na região crítica;
 Se lock == 1 há processo na região crítica;
 A ideia é: se o seu processo quer entrar na região crítica ele
deve ler lock e só poderá entrar quando lock == 0;
 Quando ele entrar deve fazer lock == 1;

 Chaveamento obrigatório:
 Alterna entre dois processos;
 A variável turn indica qual processo tem direito a entrar na
região crítica;
 Viola a condição que um processo em região não crítica
bloqueia um processo;

 Solução de Peterson:
 Define duas funções enter_region e leave_region;
 Usa um vetor de interessados em entrar na região crítica;
 Usa uma variável turn para definir quem é a vez para usar a
região crítica;

 Dormir e acordar:
 As soluções anteriores são corretas mas empregam a
”espera ocupada” também chamada ”espera ociosa”;
 Se um processo não consegue entrar na região crítica ele
fica preso em um loop consumido tempo de CPU;
 Pode gerar um problema de inversão de prioridades;
 Para resolver este problema podemos usar chamadas do SO
sleep e wakeup;

 Dormir e acordar:
 Sleep() e Wakeup():
 A diferença mais importante desta estratégia para as
outras é que estas permitem que o SO bloqueie o
processo em sleep;
 Assim o processo não consumirá CPU enquanto espera
para entrar em sua região crítica;

 Problema do Produtor Consumidor:
 Paradigma para processos em cooperação, processo
produtor produz informações que são consumidas por um
processo consumidor;
 Quando o produtor quer colocar um novo item no buffer, mas
ele já está cheio, a solução é o produtor dormir e só
despertá-lo quando o consumidor remover um ou mais itens
do buffer;
 Se o consumidor quiser remover um item do buffer e
perceber que está vazio, ele dormirá até que o produtor
ponha algo no buffer;

 Semáforos:
 Um semáforo é uma estratégia que permite que 2 ou mais
processos se alternem no uso de um recurso compartilhado;
 Corrigindo o problema do sinal wakeup perdido, os
semáforos tem um contador interno para os sleep e wakeup;
 Para manter a clareza nos semáforos as instruções são
chamadas down e up;

 Mutex:
 São tipos especiais de semáforos que tem apenas uma
variável binária, permitindo que apenas 1 processo acesse a
região crítica;
 É equivalente a um semáforo iniciado em 1;
 A implementação é mais simples e mais rápida;
 Muito usado para garantir exclusão mútua a uma variável
compartilhada;

 Monitores:
 A última estratégia para o problema da condição de corrida;
 É um artificio de algumas linguagens de programação;
 Permite que se defina um conjunto de métodos e
propriedades dentro de um pacote ou módulo;
 O importante aqui é que Somente 1 processo pode estar
ativo em um monitor por vez;

 Duas formas:
 Memória compartilhada;
 Troca de mensagem;

 Troca de mensagens:
 Sistema de mensagem:
 Processos se comunicam entre si sem lançar mão de
variáveis compartilhadas;
 A comunicação utiliza duas funções:
 Send (destino, mensagem);
 Receive (origem, mensagem);
 Se P e Q quiserem se comunicar, eles precisam:
 Estabelecer um link de comunicação entre eles;
 Trocar mensagens por meio de send/receive;

Escalonamento
 Mais importante em sistemas multiprogramados;
 Trata da ordem em que processos são executados na CPU;
 Trata da prioridade entre estes processos;
 Há vários tipos:
 Batch;
 Interativo;
 Tempo Real;

Escalonamento – Tipos
 Batch:
 Grande tempo alocado a cada processo;
 Um processo não interromperá outro processo;
 Mudança comumente ocorre por bloqueio do processo;

 Iterativo:
 Grande alternância entre processos;
 Mudança rápida;
 Muitas trocas de contexto por segundo;

 Tempo Real:
 Exigem que o sistema tenha um tempo de resposta definido;
 A perda de um determinado limite de tempo de execução
pode ser catastrófica;
 Dividido em Soft Real Time e Hard Real Time;

Escalonamento
 Processos comumente trabalham em fluxos pequenos de
uso de CPU e muito longos de E/S (I/O-bound);
 Mas também há processos que podem consumir muito de
CPU (CPU-bound);

Escalonamento – Objetivos
 Todos os sistemas:
 Justiça – dar a cada processo uma porção justa da CPU;
 Aplicação da política – verificar se a política estabelecida é
cumprida;
 Equilíbrio – manter ocupadas todas as partes do sistema;
 Sistemas em lote(batch):
 Vazão (throughput) – maximizar o número de tarefas por
hora;
 Tempo de retorno – minimizar o tempo entre a submissão e o
término;
 Utilização de CPU – manter a CPU ocupada o tempo todo;

Escalonamento – Objetivos
 Sistemas interativos:
 Tempo de resposta – responder rapidamente às requisições;
 Proporcionalidade – satisfazer às expectativas dos usuários;
 Sistemas de tempo real:
 Cumprimento dos prazos – evitar a perda de dados;
 Previsibilidade – evitar a degradação da qualidade em
sistemas multimídia;

Escalonamento – Atuação
 Troca de Contexto:

Escalonamento
 Critérios:
 Utilização de CPU – mantenha a CPU a mais ocupada
possível;
 Throughput – número de processos que completam sua
execução por unidade de tempo;
 Tempo de turnaround – quantidade de tempo para executar
um processo em particular;
 Tempo de espera – tempo em que um processo esteve
esperando na fila de prontos;
 Tempo de resposta – tempo desde quando uma solicitação
foi submetida até a primeira resposta ser produzida;

Escalonamento – Classificação
 As políticas de escalonamento podem ser classificadas
segundo a possibilidade de o SO interromper um processo
em execução e substituí-lo por outro, atividade esta
conhecida como preempção.
 Não Preemptivos:
 Quando um processo está em execução nenhum evento
externo pode ocasionar a perda do uso do processador;
 Preemptivos:
 O SO pode interromper um processo em execução e passá-
lo para o estado de pronto, como objetivo de alocar outro
processo na CPU;

Escalonamento – Algoritmos
 Algoritmos na literatura:
 FIFO – First In First Out;
 SJF – Shortest Job First;
 Circular – Round Robin;
 Circular com prioridade;
 Filas Múltiplas;
 Filas Múltiplas com realimentação;

Escalonamento – Algoritmo FIFO
 First In First Out (Primeiro que entra, primeiro que sai);
 Também chamado de FCFS ( First Come First Served);
 Conceito de Fila;
 Não-preemptivo;

 Exemplo:
Escalonamento – Algoritmo FIFO

 SJF (Shortest Job First)
 Escolhe o processo de menor custo;
 Dois esquemas:
 Não preemptivo – uma vez a CPU dada ao processo,
ele não pode ser apropriado até que termine seu burst de
CPU;
 Preemptivo – se um novo processo chega com tamanho
de burst de CPU menor que o tempo restante do
processo atualmente em execução, apropria.
Escalonamento – Algoritmo SJF

 Exemplo:
Escalonamento – Algoritmo SJF

 Preemptivo;
 A cada processo é dado um tempo fixo de CPU que este
pode usar;
 Expirado esse tempo o processo é retirado da CPU e
colocado no fim da fila de pronto;
 Na prática há uma alternância circular entre os processos
em estado pronto;
Escalonamento – Algoritmo Circular (Round Robin)

 Exemplo:
Escalonamento – Algoritmo Circular (Round Robin)

 Preemptivo;
 O processo com maior prioridade no estado de pronto é
sempre escolhido para execução, e processos com valores
iguais são escalonados seguindo o critério de FIFO;
Escalonamento – Algoritmo Circular com Prioridade

 Exemplo:
Escalonamento – Algoritmo Circular com Prioridade

 Existem diversas filas de processos no estado de pronto,
cada qual com uma prioridade específica;
 Os processo são associados às filas em função de
características próprias, como importância para a aplicação,
tipo de processamento ou área de memória necessária;
Escalonamento – Algoritmo Filas Múltiplas

 Exemplo:
Escalonamento – Algoritmo Filas Múltiplas

Atividade Laboratório – Simulador Sosim (Pág 143)
 Escalonamento Circular;
 Escalonamento Circular com Prioridades Estatísticas I;
 Escalonamento Circular com Prioridades Estatísticas II;
 Escalonamento Circular com Prioridades Dinâmicas;

Problemas Clássicos de IPC
 Jantar dos filósofos
 Para comer o espaguete é necessário utilizar dois garfos,
pois o espaguete está escorregadio.

 Leitores e escritores
 Se um processo(P1-Escritor) estiver atualizando uma base
de dados, nenhum outro processo pode ter acesso ao banco
de dados, nem mesmo os leitores(P2-Leitor).
 Como programar os leitores e os escritores?

 Barbeiro
 Um barbeiro recebe clientes para cortar cabelo. Na barbearia
há uma cadeira de barbeiro e apenas cinco cadeiras para
clientes esperarem.

Obrigado!
Sistemas Operacionais
Prof. MSc. José Hermano Cavalcanti Filho
http://www.ifpb.edu.br
jose.cavalcanti@ifpb.edu.br

SO - Integrado - Aula 02 - Processos e Threads.pptx

Mais conteúdo relacionado

Semelhante a SO - Integrado - Aula 02 - Processos e Threads.pptx

SO - Integrado - Aula 02 - Processos e Threads.pptx