Sistemas Distribudos

Processos e Threads

Gustavo Reis
gustavo.reis@ifsudestemg.edu.br
- O que so Processos?
Uma abstrao de um programa em execuo.
Mantm a capacidade de operaes (pseudo)concorrentes,
mesmo quando h apenas uma CPU disponvel.
Transformam uma nica CPU em vrias CPUs virtuais.
Possuem programa, entrada, sada e um estado.
Um nico processador pode ser compartilhado entre os
vrios processos, com algum algoritmo de escalonamento
usado para determinar quando parar o trabalho sobre um
processo e servir outro.
- Criao de Processos
Em sistemas muito simples, ou em sistemas projetados para
executar apenas uma nica aplicao, pode ser possvel que
todos os processos que sero necessrios seja criados quando o
sistema ligado.
Em sistemas de propsito geral, necessrio algum mecanismo
para criar e terminar processos durante a operao, quando for
preciso.
H quatro eventos principais que fazem com que processos
sejam criados:
Inco do sistema
Execuo de uma chamada de sistema de criao de processo por um
processo em execuo
Uma requisio do usurio para criar um novo processo
Incio de uma tarefa em lote (batch lote)
- Estados de Processo
Embora cada processo seja uma entidade independente,
com seu prprio contador de programa e estado interno,
muitas vezes os processos precisam interagir com outros.
Um processo pode gerar uma sada que outro processo usa
como entrada.
Ex.:
cat chapter1 chapter2 chapter3 | grep tree
O primeiro processo, que executa cat, gera como sada a
concatenao dos trs arquivos.
O segundo processo, que executa grep, seleciona todas as
linhas contendo a palavra tree.
- Estados de Processo
Estados:
Em execuo realmente usando a CPU naquele momento.
Pronto executvel; temporariamente parado para dar lugar a outro processo.
Bloqueado incapaz de executar enquanto no ocorrer um evento externo.

Em execuo

1 2
3
Bloqueado Pronto

4
1. O processo bloqueia aguardando uma entrada
2. O escalonador seleciona outro processo
3. O escalonador esse processo
4. A entrada torna-se disponvel
- Comunicao entre Processos
Frequentemente processos precisam se comunicar com
outros (IPC interprocess communication).
H trs tpicos em relao a comunicao de processos:
Como um processo passa informao para outro;
Como garantir que dois ou mais processos no entrem
em conflito (concorrncia pelo mesmo recurso);
Sequncia adequada quando existirem dependncias
(produtor/consumidor).
- Comunicao entre Processos
Condies de Corrida
Dois ou mais processos esto lendo ou escrevendo algum
dado compartilhado e cujo resultado depende de quem
executa precisamente e quando a executa.
Ex.: spool de impresso Diretrio de spool
.
.
.
out = 4
4 abc
5 prog.c
Processo A 6 prog.h
Dois processos querem acessar in = 7
a memria compartilhada ao 7
mesmo tempo
Processo B
.
.
.
- Comunicao entre Processos
Regies Crticas

O que fazer para evitar condies de disputa?

Excluso Mtua modo de assegurar que outros

processos sejam impedidos de usar uma varivel ou um
arquivo compartilhado que j estiver em uso por um
processo.

Parte do programa que acessa um recurso compartilhado

chamada de regio crtica.
- Comunicao entre Processos
Regies Crticas
preciso satisfazer quatro condies para chegar a uma
boa soluo que impea condies de disputa:

Dois processos nunca podem estar simultaneamente em suas

regies crticas;
Nada pode ser afirmado sobre a velocidade ou sobre o nmero de
CPUs;
Nenhum processo executando fora de sua regio crtica pode
bloquear outros processos;
Nenhum processo deve esperar eternamente para entrar em sua
regio crtica.
- Comunicao entre Processos
Regies Crticas

A entra na regio crtica A deixa a regio crtica

Processo A

B tenta B entra na B deixa a

entrar na regio crtica regio crtica
regio crtica

Processo B

B bloqueado
T1 T2 T3 T4
Excluso mtua
Tempo
usando regies crticas
- Comunicao entre Processos
Excluso Mtua
Desabilitando interrupes
Em sistemas de processador nico, a soluo mais simples aquela em
que cada processo desabilita todas as interrupes logo depois de entrar
em sua regio crtica e as reabilita imediatamente antes de sair dela.
Com as interrupes desligadas, a CPU no ser mais chaveada para
outro processo. Desta forma um processo pode verificar e atualizar a
memria compartilhada sem temer a interveno de um outro processo.
De modo geral, esta abordagem no interessante, porque no prudente
dar aos processos dos usurios o poder de desligar interrupes. Pois o
usurio pode desabilitar as interrupes e no mais habilitar. Alm disso,
se o sistema for multicore, desabilitar as interrupes afetar somente a
CPU que executou a instruo disable. As outras continuaro executando e
tendo acesso memria compartilhada.
- Comunicao entre Processos
Excluso Mtua
Variveis do tipo trava (lock)
Outra alternativa com soluo atravs de software.
Existncia de uma nica varivel compartilhada para controle da regio
crtica. Inicialmente o valor da varivel zero.
Para entrar em sua regio crtica, o processo testa antes se o valor da
varivel zero. Em caso verdadeiro, o processo altera essa varivel para
um e entra na regio crtica. Se a varivel j estiver com o valor um, o
processo simplesmente aguardar at que ela se torne zero.
Desvantagem: quando um processo l o contedo da varivel com valor
zero e antes que ele modifique para um, outro processo escalonado e
altera o valor para um. Ao voltar a executar, o primeiro processo tambm
coloca o valor um na varivel e, assim, os dois processos estaro em suas
regies crticas ao mesmo tempo.
- Comunicao entre Processos
Excluso Mtua
Chaveamento obrigatrio
while (TRUE) { while (TRUE) {
while (turn != 0); while (turn != 0);
turn = 1; turn = 1;
critical_region(); critical_region();
turn = 0; turn = 0;
noncritical_region(); noncritical_region();
} }
(a) (b)

Soluo proposta para o problema da regio crtica. (a) Processo 0. (b) Processo 1
- Comunicao entre Processos
Excluso Mtua
Soluo de Peterson
Consiste em duas rotinas (enter_region e leave_region).
Antes de usar as variveis compartilhadas (ou seja, antes de entrar
em sua regio crtica), cada processo chama enter_region com seu
prprio nmero de processo, 0 ou 1, como parmetro.
Essa chamada far com que ele fique esperando, se necessrio,
at que seja seguro entrar.
Depois que terminou de usar as variveis compartilhadas, o
processo chama leave_region para indicar seu trmino e permitir
que outro processo entre, se assim desejar.
- Comunicao entre Processos
Excluso Mtua
Soluo de Peterson
#define FALSE 0
#define TRUE 1
#define N 2 /*nmero de processos*/
int turn; /*de quem a vez?*/
int interested[N]; /*todos os valores 0 ou 1*/
void enter_region(int process); { /*processo 0 ou 1*/
int other; /*nmero do outro processo*/
other = 1 process; /*o oposto do processo*/
interested[process] = TRUE; /*configura qual processo est interessado*/
turn = process; /*altera o valor de turn*/
while (turn == process && interested[other] == TRUE) /*comando nulo*/;
}
void leave_region(int process) { /*processo: quem est saindo*/
interested[process] = FALSE; /*indica a sada da regio crtica*/
}
- Comunicao entre Processos
Excluso Mtua
Instruo TSL
Requer um pequeno auxlio do hardware.
Muitos computadores especialmente aqueles projetados com
mltiplos processadores tm uma instruo TSL RX, LOCK (test
and set lock teste e atualize a varivel de trava).
As operaes de leitura e armazenamento da palavra so
seguramente indivisveis nenhum outro processador pode ter
acesso palavra na memria enquanto a instruo no terminar.
A CPU que est executando a instruo TSL impede o acesso ao
barramento de memria para proibir que outras CPUs tenham
acesso memria enquanto ela no terminar.
- Comunicao entre Processos
Dormir e Acordar
A soluo de Peterson e a soluo com base em TSL so corretas,
mas ambas apresentam o defeito de precisar da espera ociosa.
Em essncia, o que essas solues fazem : quando quer entrar em
uma regio crtica, um processo verifica se sua entrada permitida. Se
no for, ele ficar em um lao esperando at que seja permitida a
entrada.
Problema da inverso de prioridade:
Dois processos H, com alta prioridade, e L, com baixa prioridade.
As regras de escalonamento so tais que H executado sempre que
estiver no estado de pronto.
Em certo momento, com L em sua regio crtica, H torna-se pronto pra
executar.
Agora H inicia uma espera ocupada, mas, como L nunca escalonado
enquanto H est executando, L nunca tem a oportunidade de deixar sua
regio crtica e, assim, H fica em um lao infinito.
- Comunicao entre Processos
Dormir e Acordar
Problema do produtor-consumidor:
Dois processos compartilham um buffer comum e de tamanho fixo.
Um deles, o produtor, coloca informao dentro do buffer e o outro,
o consumidor, a retira.
O problema se origina quando o produtor quer colocar um novo
item no buffer, mas ele est cheio. A soluo colocar o produtor
para dormir e s despert-lo quando o consumidor remover um ou
mais itens.
Da mesma maneira, se o consumidor quiser remover um item do
buffer e perceber que est vazio, ele dormir at que o produtor
coloque algo no buffer e o desperte.
O cdigo do consumidor similar.
- Comunicao entre Processos
Dormir e Acordar
Problema do produtor-consumidor:
#define N 100 //nmero de lugares no buffer
int count = 0; //nmero de itens no buffer
void producer(void) {
int item;
while(TRUE) { //repita para sempre
item = produce_item(); //gera o prximo item
if (count==N) sleep(); //se o buffer estiver cheio, v dormir
inset_item(item); //ponha um item no buffer
count++; //incremente o contador de itens no buffer
if (count==1) wakeup(consumer); //o buffer est vazio?
}
} void consumer(void) {
int item;
while(TRUE) { //repita para sempre
if (count==0) sleep(); //se o buffer estiver vazio, v dormir
item = remove_item(); //retire o item do buffer
count--; //decresa de um o contador de itens no buffer
if (count==N-1) wakeup(producer); //o buffer estava cheio?
consume_item(item); //imprima o item
}
}
- Comunicao entre Processos
Dormir e Acordar
Problema do produtor-consumidor:

Qual o problema que pode acontecer?

- Comunicao entre Processos
Dormir e Acordar
Problema do produtor-consumidor:
Caso acontea condio de disputa seria possvel acontecer a seguinte
situao: o buffer est vazio e o consumidor acabou de ler a varivel count
para verificar se seu valor 0. Nesse instante, o escalonador decide parar
de executar o consumidor temporariamente e comea a executar o
produtor. O produtor insere um item no buffer, incrementa a varivel count e
percebe que seu valor agora 1. Inferindo que o valor de count era 0 e que
o consumidor deveria ir dormir, o produtor chama wakeup para acordar o
consumidor.
Infelizmente, o consumidor ainda no est logicamente adormecido; ento,
o sinal de acordar perdido. Na prxima vez em que o consumidor
executar, testar o valor de count anteriormente lido por ele, verificar que
o valor 0 e dormir. Mais cedo ou mais tarde o produtor preencher todo
o buffer e tambm dormir. Ambos dormiro para sempre.
- Comunicao entre Processos
Semforos
Criado pelo matemtico holands E. W. Dijkstra em1965
um tipo abstrato de dado composto por um valor inteiro e uma fila de
processos.
Permite somente duas operaes: P (down) e V (up).
Quando um processo executa a operao P sobre um semforo, o seu
valor decrementado. Caso o novo valor seja negativo, o processo
bloqueado e inserido no fim da fila desse semforo.
Quando um processo executa a operao V sobre um semforo, o seu
valor incrementado. Caso exista processo bloqueado na fila desse
semforo, o primeiro processo da fila liberado.
- Comunicao entre Processos
Semforos
P(S):
S.valor = S.valor 1;
se S.valor < 0
Ento bloqueia o processo, insere em S.fila;

V(S):
S.valor = S.valor + 1;
se S.valor <= 0
Ento retira processo P de S.fila, acorda P
- Comunicao entre Processos
Semforos
Para que semforos funcionem corretamente, essencial que as
operaes P e V seja atmicas.
Semforos tornam a proteo da seo crtica muito simples.
Para cada estrutura de dados compartilhada, deve ser criado um
semforo S inicializado com valor 1.
Todo processo, antes de acessar a estrutura, deve executar um P(S),
ou seja, a operao P sobre o semforo S associado com a estrutura
de dados em questo.
Ao sair da seo crtica, o processo executa V(S).
- Comunicao entre Processos
Troca de Mensagens
Processos executando em diferentes mquinas no possuem variveis
compartilhadas.
Eles trocam informaes atravs de mensagens via uma rede de
comunicao.
Tipicamente, o mecanismo que permite a troca de mensagens entre
processos implementado pelo sistema operacional.
Ele acessado atravs de duas chamadas de sistema bsica: Send e
Receive.
send(destino,&mensagem);
receive(origem,&mensagem);
- Comunicao entre Processos
Troca de Mensagens
Produtor-consumidor com troca de mensagem (caixa postal)
Local para armazenar temporariamente um certo nmero de
mensagens.
Quando as caixas postais so usadas, os parmetros de endereo
nas chamadas send e receive so as caixas postais, no os
processos.
Ao tentar enviar para uma caixa postal que esteja cheia, um
processo suspenso at que uma mensagem seja removida
daquela caixa postal e d lugar a uma nova.
- O que so Threads?
Tambm chamados de processos leves, permitem
mltiplas atividades dentro de um nico processo;
Fluxo de controle sequencial isolado dentro de um
programa;
Como um programa sequencial qualquer, uma thread
tem um comeo, uma sequencia de comandos e um
fim;
Threads permitem que um programa simples possa
executar vrias tarefas diferentes ao mesmo tempo,
independentemente umas das outras.
- Criando Threads em Java

Em Java, as threads se constituem de instncias da

classe Thread que fornecem suporte a
comunicao concorrente;
A classe Thread prov mtodos necessrios para
criar e controlar threads (independentemente da
plataforma usada) e execut-los concorrentemente;
O corpo de uma thread o seu mtodo run(), e
nele que so executadas as tarefas s quais thread
se destina.
- Duas formas de criar Threads

Criando uma subclasse da classe Thread e

definindo o seu mtodo run() de maneira adequada
realizao da tarefa do thread;

Criando uma instncia de Thread que recebe como

parmetro um objeto que implemente a interface
Runnable - esse objeto providenciar o mtodo
run() para a thread.
- Usando Herana

Usando herana, a classe deve sobrescrever o mtodo

public void run():

class Tarefa1 extends Thread {

public void run() {
for(int i=0; i<1000; i++)
System.out.println(Usando herana);
}
}
- Usando a interface Runnable

A interface Runnable obriga a implementar o mtodo

public void run():

class Tarefa2 implements Runnable {

public void run() {
for(int i=0; i<1000; i++)
System.out.println(Usando Runnable);
}
}
- Exemplo de uso

Para usar as classes Tarefa1 e Tarefa2 devemos

fazer:

Thread threadComHeranca = new Tarefa1();

Thread threadComRunnable = new Thread(new
Tarefa2());
threadComHeranca.start();
threadComRunnable.start();
- Sada do exemplo

A sada do exemplo seria mais ou menos essa:

Usando Runnable
Usando Herana
Usando Herana
Usando Runnable
Usando Herana
Usando Runnable
(...)