Concorrência com Java

1

Programação Concorrente com Java

Elenilson VieiraEmbaixador de Campus da SunUniversidade Federal da Paraíbablogs.sun.com/[email protected]

1

2

Agenda – Parte 1 (Introdução)

1 – Introdução2 – Motivação3 – Arquitetura de Sistemas4 – Tipos de Concorrência5 – Programas e Processos6 – Problemas com Concorrência

2

3

Agenda – Parte 2 (Threads)

1 – Características2 – Threads em Java3 – Classe Threads4 – Interface Runnable5 – Programas e Processos6 – Threads x Runnable7 – Terminando Threads8 – Prioridades9 – Gerenciamento de Threads10 – Ciclo de Vida

3

4

Agenda – Parte 3 (Exclusão Mútua)

1 – Seção Crítica2 – Exclusão Mútua3 – Execução Concorrente4 – Implementando Exclusão Mútua5 – Variáveis booleana compartilhada

4

5

Agenda – Parte 4 (Sincronização)1 – Introdução2 – Semáforos - Tipos de Semáforo - Exclusão Mútua com Semáforo - Semáforo em Java - Problema Produtor-Consumidor - Sincronização com Semáforo3 – Monitores - Introdução - Monitores x Semáforos - Monitores em Java - Métodos Sincronizados - Trechos de Código Sincronizado - Perigo de Deadlock - Problema Produtor-Consumidor

5

Sun Confidential: Internal Only 6

Perguntas?


Começando a brincadeira...

Footnote position, 12 pts.

8

Introdução

7

9



8


• Program a Sequencial> Não m ais que um a operação acontece em um dado m om ento

> É decorrente da form a com o o controle é passado em seqüência entre com andos

> Cada com ando deve ser concluído antes do próxim o com ando iniciar

• Program a Concorrente> É hábil a realizar m ais que um a operação em um dado m om ento



• Concorrência> Concorrência não é um a tarefa trivial

> Torna a program ação m ais difícil

> Dificulta a realização dos testes

> Reduz a efetividade dos testes

Program as seqüenciais são razoavelm ente entendíveis

Com plexidade é proporcional ao tam anho

Program as concorrentes em geral nãocom partilham tais características


Motivação

Escrever program as corretos é difícil

Escrever program as concorrentes corretos ém uito m ais difícil

Porque desenvolver program as concorrentes?


Motivação

• Busca de m aior desem penho

• Representação de aspectos concorrentes do m undo real

• Desenvolvim ento de arquiteturas de com putadores concorrentes


Arquiteturas de Sistemas

• Sistem a M ultitarefa> Perm ite vários processos com partilharem o processador

> Com partilham ento baseado na divisão do tem po

> Concorrência de processam ento e entrada/saída

CPUR

e

g

SOR

e

g

Processo

1

R

e

g

Processo

2

R

e

g

Processo

3

R

e

g

Processo

4

R

e

g

1

2

3 4



• Sistem a M ultiprocessador> Aloca processos nos vários processadores

> Tam bém acontece o com partilham ento de processadores

M em óriaGlobal

CPU

M em óriaLocal

CPU

M em óriaLocal

CPU

M em óriaLocal



• Sistem as Distribuídos> Consiste de vários com putadores que operam independentem ente m as que se com unicam

> Provê m aior desem penho agregado e increm enta a confiabilidade

CPUM em óriaLocal

CPUM em óriaLocal

CPUM em óriaLocal

CPUM em óriaLocal

18



17


Tipos de Concorrência

• Concorrência Física (paralelism o)> Cada unidade é executada em um processador dedicado

• Concorrência Lógica> Processador é chaveada de um a unidade para outra

> Causa a im pressão que as unidades executam sim ultaneam ente


Programas e Processos

• Processo Sequencial> É um conjunto totalm ente ordenado de passos

> Dado quaisquer dois passos é sem pre possível indicar qual é o prim eiro

> Cada passo sendo um a m udança de estado em algum com ponente do sistem a de com putação



• Program a Sequencial> Especifica as possíveis m udanças de estado de um processo seqüencial

> Estrutura de controle do program a determ ina a ordem de execução

> Ações são ordenadas pelas regras de seqüenciação da linguagem de program ação adotada–Define com o o controle é passado de com ando a com ando



• Program a Concorrente> Especifica as possíveis m udanças de estado de dois ou m ais processos seqüenciais

> Nenhum a ordem é im plicitam ente definida entre as m udanças de estados dos processos

> Processos são ditos executar concorrentem ente

> Processos podem até m esm o executar sim ultaneam ente


Problemas com Concorrência

• Determ inism o x NãoDeterm inism o> Program as seqüências corretos são determ inísticos–Seguem um a seqüência de passos que pode ser com pletam ente reproduzida em m últiplas execuções com os m esm os dados de entrada

> Determ inism o torna possível verificar e validar program as via testes



• Determ inism o x NãoDeterm inism o> Um program a concorrente é nãodeterm inístico

– Unidades de execução prosseguem em um a ordem não predefinida

> Não é possível predizer a seqüência de passos que é realizada ou o resultado final

> M últiplas execuções do program a concorrente com os m esm os dados de entrada podem gerar resultados diferentes

> Sequência de passos e resultado final dependem do escalonam ento interno



• Determ inism o x NãoDeterm inism o> Um program a concorrente incorreto . . .

– Pode ter o com portam ento esperado a grande m aioria das vezes

– Pode de form a interm itente e irreprodutível desviarse do com portam ento norm al

> Erros de program ação concorrente são m uito difíceis de diagnosticar

> Nãodeterm inism o é um ponto chave da program ação concorrente

> Torna bastante difícil a program ação



• Dependência de Velocidade> Um program a seqüencial é independente da velocidade

– Corretude não depende da velocidade de execução

> Resultado de um program a concorrente é dependente da velocidade– Depende da velocidade relativa com que os processos seqüenciais constituintes são executados

– Pequenas flutuações randôm icas na velocidade do processador e dispositivos de entrada/saída podem levar ao nãodeterm inism o


Problemas com Concorrência• Dependência de Velocidade

> Quando os resultados são dependentes da velocidade dizse que existe um a condição de corrida (race condition)–Resultados podem ser im previsíveis

P: s := “ABCDE”

Q: s := “FGHIJ”

s = “ABCDE” s = “FGHIJ” s = “ABHIE”



• Dependência de Velocidade> Requer a adoção do conceito de atom icidade

–Um a variável é atôm ica quando é inspecionada e atualizada sem qualquer interrupção no processam ento

> Atom icidade não resolve o problem a geral

P: i := i + 1

Q: i := 2 * i

i = 2 i = 1 i = 0

LD reg, iINC regST i, reg

LD reg, iML reg, 2ST i, reg



• Deadlock> Dois ou m ais processos encontram se im possibilitados de fazer qualquer progresso no processam ento

> Gerado em função das m útuas dem andas incom patíveis por recursos

> Pode ocorrer se e som ente se as seguintes condições são satisfeitas– Exclusão M útua

– Aquisição Increm ental

– Não Preem pção

– Espera Circular



• Deadlock> Exclusão M útua

–Processos possuem acesso exclusivo aos recursos

Enquanto um processo ler dados do teclado, não faz sentido perm itir outro processo usar o

teclado ao m esm o tem po

P1 P2R



• Deadlock> Aquisição Increm ental

–Processo m antém recursos previam ente adquiridos enquanto aguarda por outro recurso

P1

R1 R2 R3

P2

Enquanto um processo espera pelo DVD, não faz sentido liberar o scanner previam ente

adquirido para copiar dados dele para o DVD



• Deadlock> Não Preem pção

–Recursos não podem ser rem ovidos de um processo até que sejam voluntariam ente liberados

P2

RP1

Pn

Um arquivo alocado a um dado processo não pode ser liberado até que

operações de atualização sejam concluídas



• Deadlock> Espera Circular

–Pode existir um ciclo de recursos e processos no qual cada processo está aguardando recursos que são m antidos pelo próxim o processo no ciclo

P1

R1 R2

P2

Processo P1 m antém um DVD, que é requerido pelo processo P2, que, por sua vez, m antém um scanner, que é requerido pelo

processo P1



• Resolvendo Deadlocks> Ignorar e assum ir que não ocorre

–Usuário trata da form a m ais conveniente que encontrar

–Em geral é tratado reinicializando o sistem a



• Resolvendo Deadlocks> Perm itir ocorrer, m as detectar e corrigir autom aticam ente–M antém o sistem a com o um todo funcionando

–Pode representar m atar processos envolvidos

–Pode adotar o conceito de roll back– Restaura os processos a um ponto anterior ao deadlock

– Adota o conceito de checkpoint para m arcar os pontos de retorno



• Resolvendo Deadlocks> Prevenir rem ovendo um a ou m ais précondições

– Elim inar a aquisição increm ental, requisitando todos os recursos em conjunto

– Alocação antecipada pode gerar pobre utilização de recursos

– Elim inar a espera increm ental, im pondo um a seqüência única para requisição dos recursos

– Seqüência bem selecionada pode gerar m elhor utilização

– Não gera boa utilização de recursos em todos os casos

– Im põe disciplina na program ação



• Starvation> Processo é indefinidam ente im pedido de executar em função de escalonam ento injusto–Safety

– Coisas ruins não acontecem

–Liveness– Coisas boas eventualm ente acontecem

– Processo fará algum progresso em um dado intervalo de tem po

> Som ente pode ser evitado se o sistem a é livre de deadlock e adota um escalonam ento justo



• Starvation> Escalonam ento Justo

–Processo é colocado em um a fila associada ao recurso requisitado

–Se recurso tornase disponível, um processo na fila eventualm ente ganha o acesso ao recurso

> Escalonam ento Injusto–Acesso preferencial a processos de alta prioridade

–Pode retardar indefinidam ente um processo de baixa prioridade

39



37

40

Threads

38

41



39


Características

• Perm ite m últiplas linhas de fluxo de controle de program a coexistir em um único processo

• Com partilham recursos de um processo> Espaço de endereços do processo

• Cada thread possui seu contador de program a individual, pilha e variáveis locais

• Com unicação via m em ória com partilhada

• Tam bém denom inado processo leve (lightweight process)


Características

• Em m onoprocessadores . . .> Processador é com partilhado entre os threads

> Sistem a operacional realiza o escalonam ento de threads de um processo

> Threads não são executados sim ultaneam ente

> Provê suporte a concorrência lógica, baseada na divisão do tem po (tim e slicing)


Características

• Em m ultiprocessadores . . .> Cada thread pode ser alocado a um processador

> Sistem a operacional realiza o escalonam ento e alocação de threads a processadores

> Threads podem ser executados sim ultaneam ente

> Provê suporte a concorrência física


Características

• Executam sim ultânea e assincronam ente> Threads podem m odificar variáveis com partilhadas com outros threads

> Pode produzir resultados im previsíveis

• Requer a adoção de m ecanism os explícitos de sincronização


Threads em Java

• Java suporta concorrência a nível de linguagem

> A linguagem C suporta concorrência em bibliotecas de funções

• Adota um m odelo preem ptivo de execução

> Intervalos do processador são alocados aos threads em um m odelo roundrobin

• Suporta o conceito de prioridade

• Im plem entado na classe Thread e na interface Runnable


Threads em Java

• Todo program a consiste de pelo m enos um thread que executa o m étodo main> thread principal (m ain thread)

• Outros threads internos podem ser criados internam ente pela JVM> Depende de cada im plem entação de JVM

• Outros threads a nível de usuário podem ser explicitam ente criados pelo program a


Classe Thread• Devese estender a classe Thread

• Sobrepor o m étodo run

> M étodo executado quando o thread é iniciado

• Instanciar um ou vários objetos thread

• Ativar o m étodo start dos objetos thread para iniciar os threads correspondentes

public class HelloWorldThread extends Thread {

public void run() {

System.out.println(“Hello World”);

}

public static void main(String[] args) {

HelloWorldThread t = new HelloWorldThread();

t.start();

}


Classe Threadclass MyThread extends Thread {

private String message;

public MyThread(String m) {message = m;}

public void run() {

for(int r=0; r<20; r++)

System.out.println(message);

}

}

public class ThreadDemo {


MyThread t1,t2;

t1=new MyThread("primeiro thread");

t2=new MyThread("segundo thread");

t1.start();

t2.start();

}

}


Interface Runnable• Devese im plem entar a interface Runnable

• Im plem entar o m étodo run

> M étodo executado quando o thread é iniciado

• Instanciar um ou vários objetos thread

• Ativar o m étodo start dos objetos thread para iniciar os threads correspondentes

public class HelloWorldThread implements Runnable {

public void run() {

System.out.println(“Hello World”);

}


HelloWorldThread h = new HelloWorldThread();

Thread t = new Thread(h);

t.start();

}


Interface Runnableclass MyThread implements Runnable {

private String message;

public MyThread(String m) {message = m;}

public void run() {

for(int r=0; r<20; r++)

System.out.println(message);

}

}

public class ThreadDemo {


MyThread r1,r2;

Thread t1, t2;

r1=new MyThread("primeiro thread");

r2=new MyThread("segundo thread");

t1 = new Thread(r1);

t2 = new Thread(r2);

t1.start();

t2.start();

}

}


Threads x Runnable

• Estender a classe Thread im possibilita herança de outra classe> Java não suporta herança m últipla

• Im plem entar a interface Runnable perm ite a herança de outra classe> Java perm ite as prim itivas extends e implements serem usadas conjuntam ente

53



51


Terminando Threads

• Um thread term ina quando o m étodo run é concluído> M étodo run retorna norm alm ente

> M étodo run lança um a exceção não capturada

• Threads não podem ser reinicializados> Invocar o m étodo start m ais que um a vez gera a exceção InvalidThreadStateException

• M étodo isAlive pode ser usado para verificar se o thread não foi term inado


Prioridades

• Pode ser usada para expressar a im portância ou urgência de diferentes threads

• Políticas de escalonam ento de threads não são padronizadas em Java> Dependente da im plem entação da JVM

> Em geral, preferência é dada a threads de m aior prioridade


Prioridades• Cada thread possui um a prioridade que varia entre Thread.MIN_PRIORITY (1) e Thread.MAX_PRIORITY (10)

• Por default, cada novo thread tem a prioridade do thread pai> Thread principal associado com o m étodo main tem a prioridade Thread.NORM_PRIORITY (5)

• Prioridade de um thread pode ser identificada e m odificada com os m étodos getPriority e setPriority


Gerenciamento de Threads

• A classe Thread define diversos m étodos para gerenciam ento dos threads

> M étodos estáticos ativados pelo próprio thread– Provêem inform ações sobre o próprio thread

– Alteram o estado do próprio thread

> Outros m étodos que podem ser invocados por outros threads

public static Thread currentThread()

Retorna uma referência ao thread atualmente em execução.



• Pausando a Execução> O m étodo Thread.sleep suspende a execução do próprio thread por um período de tem po especificado– Torna o processador disponível para outros threads

– Pode ser usado para regular o tem po de execução

– Precisão depende dos tem porizadores do sistem a e do escalonador

public static void sleep(long millis)

public static void sleep(long millis, int nanos)



• Pausando a Execução> Tem po de pausa pode ser term inado por interrupções–Gera a exceção InterruptedException

...

try {

Thread.sleep(4000);

} catch (InterruptedException e) {

return;

}

...



• Pausando a Execução> O m étodo estático Thread.yield causa o thread pausar tem porariam ente–Perm ite que outros threads possam executar

public static void yield()


Gerenciamento de Threads• Aguardando o térm ino

> O m étodo join perm ite um thread aguardar o térm ino de um outro thread– Invocação causa o thread pausar até o térm ino do outro thread

> Tam bém é possível especificar um período de tem po para esperar o térm ino do thread– Precisão depende dos tem porizadores do sistem a e do escalonador

> Pode ser term inado por interrupções– Gera a exceção InterruptedException

public final void join()

public final void join(long millis)

public final void join(long millis, int nanos)


Ciclo de Vida

Alive

Runnable

Running

NonRunnablestart()start()

sleep()

suspend()

wait()dispatchyield()

suspend()

resum e()

notify()

stop()stop()

run() returnsrun() returns

63



62

64

Exclusão Mútua

62

65



63


Introdução• Processos ou threads que com partilham dados devem sincronizar o acesso aos dados> Evita que atualizações sejam perdidas em função do acesso concorrente

i := i + 1

i = 0

P: LD reg, iP: INC RQ: LD reg, iQ: INC RP: ST i, regQ: ST i, reg

LD reg, iINC regST i, reg

P: LD reg, iP: INC RP: ST i,regQ: LD reg, iQ: INC RQ: ST i, reg

i = 2 i = 1


Seção Crítica


Seção Crítica

• Trecho de código que precisa ser executado de form a atôm ica> A seção crítica contém as instruções que acessam recursos com partilhados

• Tam bém denom inada região crítica

• Para assegurar que um a seção crítica é executada atom icam ente devese adotar técnicas de exclusão m útua


Exclusão Mútua

• Técnica que assegura que apenas um único processo ou thread pode executar a seção crítica> Se um processo está executando sua seção crítica, outros processos não podem entrar em suas próprias seções críticas

> Um processo não pode entrar em sua seção crítica se qualquer outro processo estiver em sua própria seção crítica


Execução Concorrente

...

Código não crítico...

RequisitaExclusão ...

Seção crítica ...

LiberaExclusão...


...




LiberaExclusão...


...




LiberaExclusão...


Processo AProcesso A Processo BProcesso B Processo CProcesso C


Execução Concorrente

• Processos podem executar concorrentem ente, exceto nas seções críticas

...




LiberaExclusão...


...




LiberaExclusão...


...




LiberaExclusão...




Execução Concorrente• Um único processo entra na seção crítica

> Dem ais processos devem ser bloqueados quando alcançam suas seções críticas

...




LiberaExclusão...


...




LiberaExclusão...


...




LiberaExclusão...




Implementando Exclusão Mútua

• Com o garantir a exclusão m útua?

• O que devem os fazer antes que um processo entre em sua seção crítica?

• O que devem os fazer quando um processo term ina sua seção crítica?



• Entrada na Sessão Crítica (RequisitaExclusão)> Verificar se outro processo está em sua própria seção crítica

> Caso afirm ativo, bloquear o processo até que o outro processo saia da seção crítica

> Senão, passar à execução da seção crítica

• Saída da Sessão Crítica (LiberaExclusão)> Inform ar os outros processos que a sessão crítica foi concluída



• Prim itivas do tipo RequisitaExclusão e LiberaExclusão garantem a exclusão m útua

• M as . . .

Com o im plem entar tais prim itivas?Com o im plem entar tais prim itivas?

É possível im plem entálas?É possível im plem entálas?

São de fácil im plem entação?São de fácil im plem entação?

Existem várias form as de im plem entálas?Existem várias form as de im plem entálas?


Variável booleana compartilhada

• Verdadeira> Um dos processos está na região crítica

• Falsa> Nenhum dos processos está na região crítica



Begin {RequisitaExclusão}

If Ocupado then Wait;

Ocupado = True;

End {RequisitaExclusão}...

Seção crítica...

Begin {LiberaExclusão}

Ocupado = False;

If P2 esperando then reative-o;

End {LiberaExclusão}


If Ocupado then Wait;

Ocupado = True;


Seção crítica...


Ocupado = False;

If P1 esperando then reative-o;


Variável Global

Ocupado: Boolean;

Processo P1Processo P1

Processo P2Processo P2

Pseudocódigo



public interface Lock {

public void requestCS();

public void releaseCS();

}

public class LockImpl implements Lock {

boolean busy = false;

public void requestCS() {

while (busy);

busy = true;

}

public void releaseCS() {

busy = false;

}

} em Java


Variável booleana compartilhadapublic class MyLock extends Thread {

Lock lock;

public MyLock(Lock lock) {

this.lock = lock;

}

public void run() {

while (true) {

lock.requestCS();

// Seção crítica

lock.releaseCS();

}

}

}

public static void main (String[] args) {

Lock lock = new LockImpl();

MyLock t1 = new MyLock(lock);

MyLock t2 = new MyLock(lock);

t1.start();

t2.start();

}

em Java


Perceberam como garantiu a exclusão mútua?


Não garante a exclusão mútua

public class LockImpl implements Lock {

boolean busy = false;

public void requestCS() {

while (busy);

busy = true;

}

public void releaseCS() {

busy = false;

}

}

82



81

83

Sincronização

82

84

Agenda – Parte 4 (Sincronização)

1 – Introdução2 – Semáforos - Tipos de Semáforo - Exclusão Mútua com Semáforo - Semáforo em Java - Problema Produtor-Consumidor - Sincronização com Semáforo3 – Monitores - Introdução - Monitores x Semáforos - Monitores em Java - Métodos Sincronizados - Trechos de Código Sincronizado - Perigo de Deadlock - Problema Produtor-Consumidor

83



Introdução• Soluções para exclusão m útua baseadas na espera ocupada são m uito caras> Processo repetidam ente verifica se a condição de entrada na sessão crítica é satisfeita

> Desperdiça capacidade de processam ento

> Não gera resultado funcional útil

• Soluções devem idealm ente verificar a condição de entrada apenas quando satisfeita> Não consom e ciclos de processador desnecessariam ente

> Requer suporte do sistem a operacional


Introdução• Prim itivas de sincronização são úteis para resolver o problem a da exclusão m útua e da sincronização de processos> Evitam a espera ocupada

> Provêem um m ecanism o de controle da ordem entre várias operações de diferentes processos

• Linguagens de program ação suportam diferentes prim itivas de sincronização> Sem áforos

> M onitores


Semáforos• Proposto por Dijkstra para resolver o problem a da exclusão m útua

• Um sem áforo possui . . .> Um valor inteiro positivo que indica quantos processos podem acessar o sem áforo– Valor inicial depende do propósito do sem áforo

> Um a fila de processos bloqueados a espera da liberação do sem áforo– Fila é inicialm ente vazia

> Duas operações atôm icas P() e V() – M odifica o valor do sem áforo e inclui/libera processos na/da fila


Semáforos• Operações Prim itivas

> P e V advêm dos verbos holandeses testar (proberen) e increm entar (verhoegen)–P tam bém é cham ada Down, W ait ou Test

–V tam bém é cham ada Up, Signal ou Increm ent

P(s): Se s = 0 então

Suspender processo na fila;

s = s – 1;

V(s): s = s +1;

Se fila não vazia então

Liberar um processo da fila;


Semáforos

• Operações Prim itivasP(s): Se s = 0 então


s = s – 1;

V(s): s = s +1;

Se fila não vazia então


P(s): Se s > 0 então

s = s – 1

senão


V(s): Se fila não vazia então


senão

s = s +1


Semáforos• Tipos de Sem áforos

> Sem áforo Binário–Valor do sem áforo é inicialm ente 0 ou 1

–Utilizado para resolver o problem a da exclusão m útua em sessões críticas

> Sem áforo Contador–Valor do sem áforo é inicialm ente qualquer inteiro positivo

–Valor representa o total de recursos com partilhados entre os processos

–Utilizado para sincronização de processos


Semáforos

• Exclusão M útua com Sem áforo> Sessão crítica delim itada por sem áforo binário


P(s);


Seção crítica...


V(s);


Variável Global

s: Semáforo Binário;

P(s): Se s = 0 então


s = s - 1


Semáforos• Exclusão M útua com Sem áforo

> Garante a exclusão m útua

> Processos são independentes– Não alternam a execução das seções críticas

> Processos não se bloqueiam m utuam ente– Não entram em deadlock

> Processos não esperam indefinidam ente, dependendo da política de liberação da fila– Não acontece starvation

> Evita a espera ocupada


Semáforos• Sem áforo em Java Im plem entado pela classe Semaphorepublic Semaphore(int permits)

public Semaphore(int permits, boolean fair)

Cria e inicializa um sem áforo

permits – valor inicial do sem áforo

fair garante política de liberação FIFO (true)

public void acquire() throws InterruptedException

Im plem enta a operação prim itiva P

public void release()

Im plem enta a operação prim itiva V


Semáforos• Sem áforo em Java

> Im plem entando Exclusão M útuapublic class MyLock extends Thread {

Semaphore s;

int id;

public MyLock(Semaphore s, int id) {

this.s = s;

this.id = id;

}

public void run() {

while (true) {

try {

s.acquire();

// Sessão crítica

s.release();

} catch (InterruptedException e) {}

}

}

}


int nproc = 10;

Semaphore s = new Semaphore(1, true);

for (int p = 0; p < nproc; p++)

(new MyLock(s, p)).start();

}


Semáforos

• Sincronização com Sem áforo> Problem a ProdutorConsum idor

–Produtor produz dados e os coloca em um buffer

–Consum idor rem ove os dados do buffer para usálos

Produtor Consum idorBufferProdutorProdutorcolocacoloca

dados nodados nobufferbuffer

Consum idorConsum idorrem overem ovedados dodados dobufferbuffer


Semáforos

• Sincronização com Sem áforo> Problem a ProdutorConsum idor

–Buffer Sim ples / M ensagem Única

...

Armazena dados no buffer

V(s);...

Variável Global

s: Semáforo Binário; {inicialmente 0}

...

P(s);

Remove dados do buffer...

ProdutorProdutor Consum idorConsum idor


Semáforos• Sincronização com Sem áforo

> Problem a

ProdutorConsum idor–Buffer Sim ples /

M ensagem Única

public class SingleBuffer {

Semaphore s;

String value;

public SingleBuffer() {

s = new Semaphore(0);

value = null;

}

public void deposit(String v) {

value = v;

s.release();

}

public String fetch() {

s.acquire();

return value;

}

}



> Problem a ProdutorConsum idor–Buffer Sim ples / M ensagem Única

public class Producer extends Thread {

SingleBuffer buffer;

String value;

public Producer(SingleBuffer b, String v) {

buffer = b;

value = v;

}

public void run() {

buffer.deposit(value);

}

}

public class Consumer extends Thread {


String value;

public Consumer(SingleBuffer b) {

buffer = b;

}

public void run() {

value = buffer.fetch();

}

}



> Problem a ProdutorConsum idor–Buffer Sim ples / M ensagem Única

public class Producer extends Thread {


String value;


buffer = b;

value = v;

}

public void run() {


}

}



String value;


buffer = b;

}

public void run() {


}

}

public class ProducerConsumer {


String message = “Campus IV”;

SingleBuffer b = new SingleBuffer();

Producer p = new Producer(b, message);

Consumer c = new Consumer(b);

p.start();

c.start();

}

}


Semáforos

• Sincronização com Sem áforo> Sem áforos garantem a exclusão m útua e perm item a sincronização de processos– Garantia depende do correto uso das prim itivas

– Prim itivas podem ser esquecidas pelo program ador durante a codificação

– Garantia depende do correto entendim ento do relacionam ento entre as várias prim itivas

– Códigos das sessões críticas são replicados ou dispersos nos diferentes processos

– Prim itivas são dispersas no código dos processos

– É preciso avaliar todo o código para entender o relacionam ento entre as prim itivas


Monitores• M onitores

> Construção que pode ser usada para exclusão m útua e sincronização de processos

> Proposto por Dijkstra e posteriorm ente im plem entado por Hoare e Hansen

> Explicita e centraliza as sessões críticas em um a parte especial do código– Exclusão m útua é autom aticam ente forçada

– Facilita o entendim ento

> Não adota prim itivas para dem arcar regiões críticas– Evita o esquecim ento do uso das prim itivas


Monitores• Um m onitor possui . . .

> Nom e que tem o propósito de identificação

> Variáveis globais que são com partilhadas entre os processos que usam do m onitor

> Procedim entos de entrada (procedure entries) que podem ser ativados pelos processos– Podem possuir variáveis locais e parâm etros

– Um único processo poder ativar os procedim entos do m onitor, a cada instante

– Im põe a exclusão m útua entre processos

– Variáveis globais som ente podem ser acessadas a partir dos procedim entos

> Código de inicialização das variáveis globais


Monitoresmonitor: nomemonitor;

declaração de variáveis globais;

procedure operação1(parâmetros);

declaração de variáveis locais;

begin

código que implementa a operação

end;...

procedure operaçãoN(parâmetros);

declaração de variáveis locais;

begin

código que implementa a operação

end;

begin

código de inicialização das variáveis globais

end


Monitores• M onitores x Sem áforos

Begin

...

oper2(params);

...

End;

Begin

...

operN(params);

...

End;

Begin ...

P(s)

Sessão crítica 1

V(s) ...

End;

Processo 1Processo 1Begin ...

P(s)

Sessão crítica 2

V(s) ...

End;

Processo 2Processo 2Begin ...

P(s)

Sessão crítica N

V(s) ...

End;

Processo NProcesso N

Begin

...

oper1(params);

...

End;

SS

ee

mm

áá

ff

oo

rr

oo

MM

oo

nn

ii

tt

oo

rr


Monitores

• Podem ser im plem entados com o um a classe em linguagens orientadas a objetos

–Nom e da classe ou instância do objeto representa o nom e do m onitor

–Atributos representam as variáveis globais com partilhadas

–M étodos representam os procedim entos de entrada

–Construtor representa o código de inicialização das variáveis com partilhadas


Monitores

• M onitores em Java> Todo objeto Java possui um m onitor associado

> Prim itiva synchronized perm ite acessar o m onitor de um objeto– Prim itiva pode ser usada em m étodos ou trechos de código (statem ents)

– Assegura que, em um dado instante, apenas um único thread pode executar m étodos do objeto

– Thread possui o bloqueio (lock) do m onitor do objeto

– Thread está dentro do m onitor do objeto


Monitores• M onitores em Java

> Prim itiva synchronized–M étodos Sincronizados

– M étodos estáticos tam bém podem ser sincronizados

– Instâncias e classe possuem m onitores (locks) independentes

– Cada m onitor (objeto / classe), em um dado instante, perm ite a execução de um único thread

–Trechos de Código Sincronizados– Pode increm entar a concorrência de threads

– Perm ite execução sim ultânea de diversos m étodos



M étodoM étodosincronizadosincronizadoM étodoM étodosincronizadosincronizado

M étodo nãoM étodo nãosincronizadosincronizadoM étodo nãoM étodo nãosincronizadosincronizado

Dados

OO

bb

jj

ee

tt

oo

Fila de processos doFila de processos dom onitor do objetom onitor do objeto

Fila de processos doFila de processos dom onitor da classem onitor da classe

Conjunto de processosConjunto de processossem bloqueio dos m onitoressem bloqueio dos m onitores



public class SynchClassName { private String globalVar;

public SynchClassName() { }

public synchronized void synchMethod() {

String localVar;

}

public void nonSynchMethod() {

}

public static synchronized void synchStaticMethod() {

}

public static void nonSynchStaticMethod() {

}

}


Monitores

public class SynchClass {

public synchronized void synchMethod(int i) {

while (true) System.out.println(i);

}

public void nonSynchMethod(int i) {


}

public static synchronized void synchStaticMethod(int i) {


}

public static void nonSynchStaticMethod(int i) {


}

}


Monitorespublic class SynchImpl extends Thread {

int id;

SynchClass sc; ...

public void run() {

switch (id) {

case 0:

case 1: sc.synchMethod(id); break;

case 2:

case 3: sc.nonSynchMethod(id); break;

case 4:

case 5: SynchClass.synchStaticMethod(id); break;

case 6:

case 7: SynchClass.nonSynchStaticMethod(id); break;

}

} ...

}


SynchClass sc = new SynchClass();

for (int i=0; i < 8; i++)

(new SynchImpl(i, sc)).start();

}

public SynchImpl(int id, SynchClass sc) {

this.id = id;

this.sc = sc;

}



> Trechos de código sincronizadospublic class SynchClassName { private String globalVar; private Object lock1 = new Object(); private Object lock2 = new Object();

public void nonsyncMethod() {

String localVar;

...

synchronized (this) {

...

}

...

}

public void nonsyncMethod1() {

synchronized (lock1) {

...

}

}

public void nonsyncMethod2() {


...

}

}


Monitores

• M onitores em Java> Prim itiva synchronized

–M étodos Sincronizados– M étodos estáticos tam bém podem ser sincronizados





public class SynchClass {

private Object lock1 = new Object();

private Object lock2 = new Object();

public void synchThisMethod(int i) {

synchronized (this) {


}

}

public void synchLock1Method(int i) {



}

}

public void synchLock2Method(int i) {



}

}

}


Monitores







public class SynchImpl extends Thread {

int id;

SynchClass sc;

public SynchImpl(int id, SynchClass sc) {

this.id = id;

this.sc = sc;

}

public void run() {

switch (id) {

case 0:

case 1: sc.synchThisMethod(id); break;

case 2:

case 3: sc.synchLock1Method(id); break;

case 4:

case 5: sc.synchLock2Method(id); break;

}

} ...

}


SynchClass sc = new SynchClass();

for (int i=0; i < 6; i++)

(new SynchImpl(i, sc)).start();

}


Monitores• Perigo de Deadlocks

> Devese tom ar cuidado para evitar deadlockpublic class BadSynchClass {

private int value;

public synchronized int get() {

return value;

}

public synchronized void set(int i) {

value = i;

}

public synchronized void swap(BadSynchClass bsc) {

int tmp = get();

set(bsc.get());

bsc.set(tmp);

}

}

public BadSynchClass(int v) {

value = v;

}


Monitores







public class BadSynchImpl extends Thread {

BadSynchClass a, b;

public BadSynchImpl(BadSynchClass a, BadSynchClass b) {

this.a = a;

this.b = b;

}

public void run() {

a.swap(b);

System.out.println(“A: “ + a.get() + “ B: “ + b.get());

}


BadSynchClass a = new BadSynchClass(1);

BadSynchClass b = new BadSynchClass(2);

(new BadSynchImpl(a, b)).start();

(new BadSynchImpl(b, a)).start();

}

}


Fonte• Sincronização com M onitor

> Problem a ProdutorConsum idor–Produtor produz dados e os coloca em um buffer

–Consum idor rem ove os dados do buffer para usálos

Produtor Consum idorBufferProdutorProdutorcolocacoloca

dados nodados nobufferbuffer

Consum idorConsum idorrem overem ovedados dodados dobufferbuffer


Monitores

• Problem a ProdutorConsum idor– Buffer Sim ples / M ensagem Única

public class SingleBuffer {

String value;

boolean empty; ...

public synchronized void deposit(String v) {

value = v;

empty = false;

notify();

}

public synchronized String fetch() {

while (empty) wait();

return value;

}

}

public SingleBuffer() {

value = null;

empty = true;

}


Monitorespublic class Producer extends Thread {


String value;


buffer = b;

value = v;

}

public void run() {


}

}



String value;


buffer = b;

}

public void run() {


}

}


Monitores

public class ProducerConsumer {


String message = args[0];

SingleBuffer b = new SingleBuffer();

Producer p = new Producer(b, message);

Consumer c = new Consumer(b);

p.start();

c.start();

}

}

121

Agenda – Parte 4 (Sincronização)


121



Mãos à obra


Fonte

• Slides do professor Glêdson Elias referente à disciplina de LP2 da Universidade Federal da Paraíba, 2008


Perguntas?


Fonte

• Slides do professor Glêdson Elias referente à disciplina de LP2 da Universidade Federal da Paraíba, 2008

126

Programação Concorrente com Java

Elenilson VieiraEmbaixador de Campus da SunUniversidade Federal da Paraíbablogs.sun.com/[email protected]

126

Concorrência com Java

Technology

Transcript of Concorrência com Java