Sistemas Distribuídos

Aula 05 – Programação Multithread/Paralela

Prof. Hélio de Sousa Lima Filho (helio.filho@gmail.com)

Referencial Bibliográfico

• Coulouris, George; Dollimore, Jean e Kindberg, Tim. Sistemas Distribuídos: conceitos e projeto.

• Ribeiro, Uirá. Sistemas Distribuídos, Desenvolvendo aplicações de Alta Performance no Linux.

2Sistemas Distribuídos

Sincronização

public class ContaBancaria {. . .public void depositar(double valor) {

double aux;aux = getSaldo();aux = aux +valor;

setSaldo(aux); } public void sacar(double valor) {

double aux;aux = getSaldo();aux = aux - valor;

setSaldo(aux); }}

3Sistemas Distribuídos

Sincronização

• Se duas threads chamarem depositar(100);

4Sistemas Distribuídos

Thread1 Thread2 Saldo

aux = getSaldo(); //aux = 100

100

aux = getSaldo(); //aux = 100

aux = aux +valor;//aux = 200

aux = aux +valor;//aux = 200

setSaldo(aux); 200

setSaldo(aux); 200

Sincronização

• Como criar seções críticas? – Por meio da palavra synchronized.

5Sistemas Distribuídos

public class ContaBancaria {. . .public synchronized void depositar(double valor) {

setSaldo(getSaldo()+valor); } public synchronized void sacar(double valor) {

setSaldo(getSaldo()+valor); }}

Sincronização

• Todo objeto em Java possui um lock: – informa se o objeto foi ou não “travado” por alguma

thread

• Seja a chamada p.m(): (m é synchronized) – Antes executar m, thread deve adquirir lock de p (i.e.,

travar p). • Se p já estiver travado, thread espera até ser destravado.

– Quando thread terminar execução de m, ela libera o lock de p

– Durante execução de m, thread pode chamar outros métodos synchronized desse objeto (sem esperar)

6Sistemas Distribuídos

Sincronização

• Como colocar uma thread para dormir: – por meio de wait()– Chamado por thread de posse do lock de um

objeto p– Libera-se o lock deste objeto– Execução desta thread é suspensa até uma

execução de notify() ou notifyAll() sobre p– Ao ser “acordada”, thread volta a disputar o

lock de p. Execução reinicia na linha seguinte ao wait()

7Sistemas Distribuídos

Sincronização

• Como “acordar” uma thread? notify() ou notifyAll()

• notify(): – chamado por thread de posse do lock de um

objeto p– Acorda (arbitrariamente) uma das threads que

estejam “dormindo” sobre este objeto– Thread acordada volta a disputar lock de p

• notifyAll(): – acorda todas as threads que estejam dormindo

sobre um determinado objeto.

8Sistemas Distribuídos

Sincronização

• Todo objeto em Java possui dois conjuntos:– Conjunto de entrada:

• threads que estão bloqueadas, disputando o lock desse objeto (i.e., chamaram um método sincronizado, mas não iniciaram a execução do mesmo)

– Conjunto de espera: • threads cuja execução está suspensa

9Sistemas Distribuídos

Sincronização

• Operações:– wait():

• move a thread corrente para o conjunto de espera do objeto sobre o qual a operação foi chamada.

– notify(): • move uma thread arbitrária do conjunto de espera para o

conjunto de entrada– notifyAll():

• move todas as threads do conjunto de espera para o conjunto de entrada

• Quando uma thread libera o lock de um objeto, uma thread arbitrária do conjunto de entrada é desbloqueada

10Sistemas Distribuídos

Produtor/Consumidor Java

public class Produtor extends Thread { private Buffer buf; private int numero; public Produtor(Buffer buf, int numero) { this.buf= buf; this.numero = numero; } public void run() { for (int i = 0; i < 10; i++) { // armazena 10 valores no buffer buf.put(i); System.out.println("Produtor #" + numero + " put: “+ i); try { sleep((int)(Math.random() * 100)); } catch (InterruptedException e) { } } }}

11Sistemas Distribuídos

Produtor/Consumidor Java

public class Consumidor extends Thread { private Buffer buf; private int numero; public Consumidor(Buffer buf, int numero) { this.buf= buf; this.numero = numero; } public void run() { // retira 10 valores do buffer int x; for (int i = 0; i < 10; i++) { x = buf.get(); System.out.println("Consumidor #"+ numero + " get: "

+ x); } }

12Sistemas Distribuídos

Produtor/Consumidor Java

• Suponha um buffer com capacidade para apenas um inteiro e métodos get() e put():

– No método get(), ao sair do wait, • thread deve voltar a testar se buffer

está vazio. • Pode ser que outro consumidor tenha

obtido o lock do objeto na frente e esvaziado o buffer.

– Se isso tiver acontecido, thread volta a dormir

– No método put(), ao sair do wait, • thread deve voltar a testar se buffer

está cheio. • Pode ser que outro produtor tenha

obtido o lock do objeto na frente e ocupado o buffer.

– Se isso tiver acontecido, thread volta a dormir

13Sistemas Distribuídos

public class Buffer { private int valor; private boolean cheio = false; public synchronized int get() { while (!cheio) { try { wait(); } catch (InterruptedException e) { } } cheio= false; notifyAll(); return valor; } public synchronized void put(int valor) { while (cheio) { try { wait(); } catch (InterruptedException e) { } } this.valor= valor; cheio= true; notifyAll(); }}

Leitores e Escritores

• Assuma que threads leitoras e escritoras compartilham um objeto de uma classe BD, a qual possui um atributo inteiro x e dois métodos: read (retorna o valor de x) e write (incrementa o valor de x).

• A solução proposta deve permitir leituras concorrentes.

14Sistemas Distribuídos

Leitores e Escritores

class BD { private int x; private int nr= 0; private synchronized void

startRead() { nr++; } public synchronized void

endRead() { nr--; if (nr==0) notify(); }

public int read() { int t; startRead(); t= x; endRead(); return t; } public synchronized void write() { while (nr > 0) wait(); x++; notify(); }}

15Sistemas Distribuídos

Leitores e Escritores

• Se um escritor ativo: – leitor é bloqueado no startRead()

• Se existe leitor ativo: – novos leitores conseguem ler; – novo escritor fica bloqueado no while

• notify de endRead: – desbloquear escritores

• notify de write; – desbloquear outros escritores

16Sistemas Distribuídos

Comando synchronized

• Permite adquirir o lock de qualquer objeto (por uma duração inferior à execução completa de um método)

• Exemplo:void abs (int [] v) { synchronized (v) { // garante que v é acessado

//em uma seção crítica for (int i= 0; i < v.lenghth; i++) if (v[i] < 0) v[i]= -v[i]; }}

17Sistemas Distribuídos