Você está na página 1de 15

Sistemas Operativos Universidade Santiago TIC Prof.

Girson Monteiro

Processos concorrentes que executam ao mesmo tempo podem ser independentes ou cooperantes.
Independentes no afectam e no so afectados pela execuo de outro processo. Cooperantes podem afectar ou ser afectados pela execuo de outros processos. No possvel determinar a ordem em que os eventos vo ocorrer.

necessrio alguma forma de sincronizao entre processos.

Garantir a sequncia adequada para a execuo de eventos.


um processo espera para adquirir o recurso partilhado (WAIT). o processo quando termina de usar o recurso partilhado emite um sinal (SIGNAL).

Situao onde dois ou mais processos partilham um mesmo recurso:


pex: ler e escrever dados partilhados; resultado depende de quem executou quando (ordem de escalonamento). acesso concorrente a dados podem resultar em inconsistncia dos mesmos. manter a consistncia dos dados requer mecanismos para assegurar a execuo ordenada dos processos cooperantes.

Excluso mtua: Progresso:

Se um processo est a executar cdigo da sua seco crtica, ento nenhum outro processo pode estar a executar cdigo da sua seco crtica. Se nenhum processo est a executar na sua seco crtica e h processos que desejam entrar na seco crtica, ento a entrada destes na seco crtica no pode ser adiada indefinidamente. Tem de existir um limite sobre o nmero de vezes que outros processos so permitidos entrar na sua seco crtica aps um outro processo ter pedido para entrar na seco crtica e antes do respectivo pedido ser concedido

Espera Limitada:

Estrutura geral:
1.do 2.{ 3. entry section 4. 5. critical section 6. exit section 7. 8. reminder section 9.} while (1);

Dois processos concorrentes partilham um buffer de tamanho fixo:


Produtor: colocar dados em um buffer. Consumidor: ler dados de um buffer.

Ordem de eventos:
Produtor coloca dados. Consumidor l dados.

Produtor

Buffer

Consumidor

N = 100; /* nmero mximo de slots inteiro cont = 0; /* nmero de itens no buffer*/

produtor() { Enquanto (TRUE) { produz_item(); if (cont == N) sleep(); /* se buffer t cheio, bloqueia */ entra_item(); /* coloca item no buffer */ cont = cont + 1; if (cont == 1) wakeup(consumidor); } }

consumidor() { Enquanto (TRUE) { if (cont == 0) sleep(); remove_item(); cont = cont - 1; if (cont == N-1) wakeup(produtor); } }

Cdigo mquina para:


cont + 1
register1 = counter register1 = register1 + 1 counter = register1

cont - 1
register2 = counter register2= register2 + 1 counter = register2

Ordem de execuo possvel:


F1: F1: F2: F2: F1: F2: register1 = register1 = register2 = register2 = cont = 6 cont = 4 cont = 5 register1 + 1 = 6 cont = 5 register2 1

Concluso: Se os 2 processos tivessem sido executados correctamente, os dois processos deveriam ter o mesmo resultado (cont = 5).

Problema:

Analise do problema

Suponha que existe um conjunto de processos que partilham um determinado conjunto de dados Existem processos que lem os dados (mas no os apagam!) Existem processos que escrevem os dados
Se dois ou mais leitores acederem aos dados simultaneamente no existem problemas E se um escritor escrever sobre os dados?
Podem outros processo estar a aceder simultaneamente aos mesmos dados?

Soluo

Dados partilhados

Os escritores apenas podem ter acesso exclusivo aos dados partilhados Os leitores podem aceder aos dados partilhados simultaneamente A soluo proposta simples mas pode levar starvation do escritor int readcount //nmero de leitores activos Semaphore mutex //protege o acesso varivel readcount. Semaphore wrt //Indica a um escritor se este pode aceder aos dados Inicializao: mutex=1, wrt=1, readcount=0

Escritor

wait(wrt); writing is performed signal(wrt);

Leitor

wait(mutex); readcount++; if (readcount == 1) wait(wrt); signal(mutex); reading is performed wait(mutex); readcount--; if (readcount == 0) signal(wrt); signal(mutex);

1 Crie um ficheiro pc_one.c que utilize a biblioteca pthreads para criar duas threads, consumer e producer.
Producer deve guardar em uma varivel buffer o valor de i incrementado a cada ciclo. Consumer deve ler 5 vezes o valor de i guardado no buffer pela thread Producer. Output:
Produce: 0 Consume: 0 Produce: 1 Consume:1 ...

2 Crie um ficheiro rw_one.c que utilize a biblioteca pthreads para criar duas threads reader e uma writer.
writer deve escrever por 5 vezes. reader deve ler o que o thread writer escreveu. Output:

Você também pode gostar