Programação Paralela e Distribuída - Fundamentos da UTFPR

PR
UNIVERSIDADE TECNOLGICA FEDERAL DO PARAN
PROGRAMAO PARALELA E DISTRIBUDA

Fundamentos
Prof. Cesar Augusto Tacla
http://www.dainf.ct.utfpr.edu.br/~tacla
JAVAProgParSD/0030-ProgParalelaDistribuida.ppt
Sumrio
1. Introduo
a.
b.
c.
d.
e.
f.
g.
Definio de sistemas paralelos e distribudos

Conceitos: programa, processo e thread
Criao de threads
Yield, Sleep, Join
Prioridade entre threads
Compartilhamento de memria
Mquina de estados de uma thread
2. Problemas de concorrncia
a. Race condition
b. Vivacidade (deadlock, livelock, starvation)
c. Solues (mutex, semforos, monitor)
Programao Paralela e Distribuda - Fundamentos/UTFPR Prof. Cesar Augusto Tacla
REFERNCIAS BIBLIOGRFICAS
(Coulouris et al., 2003) George Coulouris, Jean Dollimore, Tim Kindberg.
Distributed Systems - Concepts and Design, Addison Wesley Publ.
Comp., 3a edio, 2003.
(Tanenbaum & Steen, 2002) Andrew S. Tanenbaum, Maarten van Steen.
Distributed Systems, Prentice-Hall International, 2002.
(Garg, 2004) Vijay K. Garg. Concurrent and Distributed Computing in
Java, Wiley Inter-Science, 2004, 309p.
Concurrent programming in Java : design principles and patterns - 2nd
ed / c2000 - Livros - Acervo 225079
LEA, Douglas. Concurrent programming in Java: design principles
and patterns. 2nd ed. Reading: Addison-Wesley, c2000. 411 p.
(Java series) ISBN 0201310090 Nmero de Chamada: 005.133 L433c
2. ed.
3
Sumrio
1a
Definio de sistemas paralelos e distribudos
Sistema Paralelo
Mltiplos processadores conectados por uma memria compartilhada
Memria
Compartilhada
barramento
CPU
CPU
CPU
CPU
MEM
LOCAL
MEM
LOCAL
MEM
LOCAL
MEM
LOCAL
Sistema Distribudo
Mltiplos processadores conectados por uma rede de comunicao
Troca de mensagens
Rede de
Comunicao
Segundo (Garg, 2004), so sistemas compostos por

mltiplos processadores conectados por uma rede de
comunicao, sendo a rede de comunicao uma LAN
(Ethernet) ou WAN (Internet). Neste tipo de sistema os
processadores se comunicam por troca de mensagens
(no por memria compartilhada)
Necessidades
Sistemas paralelos e distribudos
Necessitam de ferramentas e tcnicas
Distintas das utilizadas em software sequencial
Distribudo x Paralelo (1)

Em relao ao hardware,
Se pensarmos em desempenho, melhor termos sistemas
distribudos ou paralelos?
R: combinao
Computadores multiprocessados conectados por uma rede
Rede de
Comunicao
Memria
Compartilhada
CPU
CPU
CPU
CPU
MEM
LOCAL
MEM
LOCAL
MEM
LOCAL
MEM
LOCAL

Por que no sistemas completamente paralelos?

Escalabilidade
Modularidade e heterogeneidade
Compartilhamento de dados
Compartilhamento de recursos
Estrutura distribuda por si
Confiabilidade
Baixo custo

Por que no sistemas completamente distribudos?
Melhor desempenho no processamento local
mais rpido atualizar uma memria local do que enviar uma
mensagem para outro processador, especialmente quando o valor
de uma varivel deve ser comunicado para vrios processadores
10

Em relao ao software (API programao),
Pode ser independente do hardware?
Na realidade, reflete a estrutura de hardware

Modelo de objetos distribudos (ex. RMI) tem-se
Processos que se comunicam por mensagens
Processos que podem ter vrias threads
Threads que se comunicam por memria compartilhada
Rede de
Comunicao
Memria
Compartilhada
CPU
CPU
CPU
CPU
MEM
LOCAL
MEM
LOCAL
MEM
LOCAL
MEM
LOCAL
11
Sumrio
1b
Conceitos: programa, processo e thread
12
Programa, processo, thread

Programa conjunto de instrues numa linguagem de
alto nvel ou de mquina
Processo resulta da execuo do programa, tem um
ambiente de execuo autocontido e privado.
O que o usurio enxerga como aplicao ou sistema, normalmente
composto por vrios processos
Sequencial = 1 processo
Concorrente = vrios processos
Processo 1
programa
execuo
Processo 2
Processo n
13

Thread so chamadas de processos peso-pena
Tanto threads como processos provm um ambiente de
execuo ou contexto de execuo
Multithread uma caracterstica essencial de Java
Toda aplicao possui pelo menos uma thread main
Threads compartilham o mesmo "espao de
endereamento (memria)
mais rpido chavear a execuo entre threads do que
entre processos.
Threads compartilham recursos do processo: memria e
arquivos abertos.
14
Programa, processo e thread

Uma thread recebe recursos prprios durante a execuo:
uma pilha (stack) de execuo para poder chamar mtodos,
passar parmetros, alocar variveis locais
um "Program Counter"
Estes elementos formam o contexto de execuo da thread
15
Stack: armazena o estado de

cada invocao de mtodo:
variveis locais, argumentos,
retorno e dispatch de
excees. So vrios frames
empilhados stack overflow
Heap: armazena instncias de

objetos criadas em tempo de
execuo. Tambm armazena
arrays OutOfMemoryError
Processos que compartilham cdigo e

dados so chamados de threads, so
tambm chamados de processos lightweight
Program Counter Register
PCR
PCR
PCR
Stack
Thread 1
Stack
Thread 2
Stack
Thread 3
Contexto de
execuo de uma
thread
heap
Method area
Compartilhado
pelas threads
Method area: informaes da classe (nome,

modificadores), superclasse, atributos e seus
modificadores, atributos estticos com valores,
mtodos e seus modificadores, bytecodes
16
Exemplos de threads
Threads demos
Links na pgina do curso
http://www.doc.ic.ac.uk/~jnm/concurrency/classes/ThreadDemo/ThreadDemo.html
http://www.dsc.ufcg.edu.br/~jacques/cursos/map/html/threads/threads1.html
17
Sumrio
1c
Criao de Processos/Threads
18
UNIX, C++
Criao de processos
Processo pai
programa
pid = fork();
if (pid == 0) {
cout << processo filho;
else
cout << processo pai;
pid = fork();
if (pid == 0) {
else
Processo filho
pid = fork();
if (pid == 0) {
else
19
Criao de threads em Java

H 2 mtodos
Extends Thread
Implements Runnable
Thread
Runnable
<<realizes>>
MinhaThread
+run():void
MinhaThread
+run():void
Possibilita estender outra classe

20

Exemplo de criao de Thread por extends
public class MinhaThread extends Thread {
public void run() {
System.out.println(Ola!!!!);
}
}
:Main
new
:MinhaThread
start()
run()
public class Main {

public static void main(String[] args) {
MinhaThread t = new MinhaThread();
t.start();
}
}
21

Exemplo de criao de Thread por implements
public class MinhaThread implements Runnable {
public void run() {
System.out.println(Ola!!!!);
}
}
public class Main {

MinhaThread t = new MinhaThread();
Thread t2 = new Thread(t);
t2.start();
}
}
:Main
new
:MinhaThread
start()
run()
22

Exemplo bsico: threads contadoras
Cdigo fonte e .jar disponvel em
http://www.dainf.ct.utfpr.edu.br/~tacla/JAVARepositorio/JThreads/JThreadContadoras
Duas threads so criadas, cada uma conta at

1.000. Os resultados podem aparecer intercalados.
Para compilar e executar
Ir ao subdiretrio src/jthread
Salvar o arquivo em Main.java <dir>/jthread/
Lance o shell: executar cmd
Posicione no diretrio <dir>
Compile: javac jthread/Main.java
Execute: java -cp . jthread/Main
Para executar somente

Ir ao subdiretrio dist
Salve o arquivo .jar em <dir>
Lance o shell: executar cmd
Posicione no diretrio <dir>
Execute: java -jar JThreadContadoras.jar
JAVARepositorio\JThreads\JThreadContadoras
23
Criao de Threads em Java

class MinhaThread implements Runnable {
public void run() {
// a interface Runnable exige a implementao do mtodo run
String name = Thread.currentThread().getName();
System.out.println(name + " rodando");
for (int i=0;i < 1000; i++) {
System.out.println(name + ": " + i);
}
System.out.println(name + " FIM ***");
}
}
public class Main {
System.out.println("INICIO DA THREAD MAIN ***");
Thread t1 = new Thread(new MinhaThread(), "thread 1");
Thread t2 = new Thread(new MinhaThread(), "\t\tthread 2");
t1.start();
t2.start();
}
}
24
Criao de Threads em Java

Quem faz o chaveamento de contexto?

25

Exerccio 1: modifique o programa das threads contadoras
de forma a cri-las estendendo a classe Thread
....
Exerccio 2: criar vrias threads (> 4) e observar o

chaveamento de contexto.
26
Sumrio
1d
Yield, Sleep e Join
27
Java THREADS: YIELD

YIELD
suspende a execuo da thread atual
e permite que outra ocupe o
As flechas pontilhadas indicam swap.
processador.
O label das flechas indicam omotivo do swap:
Swap: escalonador do SO;
yield(): a chamada ao mtodo causou a mudana.
:Main
new
t1:MinhaThread
new
start()
Incio do run()
t2:MinhaThread
start()
swap
Incio do run()
swap
yield()
yield()
28
Java THREADS: YIELD

Exemplo de utilizao de yield
public void run() {
// a interface Runnable exige a implementao do mtodo run
String name = Thread.currentThread().getName();
System.out.println(name + " rodando");
for (int i=0;i < 1000; i++) {
System.out.println(name + ": " + i);
// eh possivel passar o controle para outra thread implicitamente
Thread.yield();
}
System.out.println(name + " FIM ***");
}
}
public class Main {
t1.start();
t2.start();
}
}
29
Java THREADS: YIELD

Exerccio: no exemplo das threads contadoras, habilite o
yield fazendo: java jar JThreadContadoras.jar YIELD
30
Java Threads: SLEEP

Sleep: suspende a execuo da thread por um perodo
Libera o processador para outras threads
Faz a thread dormir por milisegundos ou nanosegundos
Tempo de sleep no preciso, depende do SO
No exemplo das threads contadoras, cada

thread dorme 2s a cada 3 contagens.
Execute-o fazendo:
java jar JThreadContadoras.jar NO 2000
if (i%3==0) {
try {
thread.sleep(2000); // dorme 2 seg
catch (InterruptedException e) {}
}
31
Java THREADS: SLEEP

SLEEP
suspende a execuo da thread atual por pelo menos x
milisegundos e permite que outra ocupe o processador.
:Main
new
t1:MinhaThread
new
start()
t2:MinhaThread
start()
Incio do run()
swap
swap
Incio do run()
sleep(2000)
Timed
waiting
swap
32
Java Threads: SLEEP

Exerccio [JAVA]: faa a simulao de um cruzamento
controlado por dois semforos utilizando apenas sleep para
controlar os tempos de verde, amarelo e vermelho.
Observe que o sleep far sinaleiros no sincronizados.
Para simplesmente execut-lo, ver prximo slide.
Sol. JAVARepositorio\JThreads\JCruzamento-v1
33
Java Threads: SLEEP

Para executar o cruzamento fazer:
Baixar o .jar de
http://www.dainf.ct.utfpr.edu.br/~tacla/JAVARepositorio/JThreads/JCruzamento-v1/dist/
>java -jar JCruzamento.jar

Estado SEM1:VERMELHO
Estado SEM2:VERDE
Estado SEM1:VERDE
Estado SEM2:AMARELO
Estado SEM2:VERMELHO
Estado SEM1:AMARELO
Estado SEM2:VERDE
...
As linhas em destaque mostram que o semforo SEM1

e o SEM2 ficaram verde ao mesmo tempo!!!
34
Java Threads: JOIN

Thread.join(): permite que uma thread espere pelo
trmino de duas ou mais threads
:Main
new
t1:MinhaThread
new
start()
join (t1, t2)
t2:MinhaThread
start()
Incio do run()
swap
waiting
Fim join (t1, t2)
swap
Incio do run()
fim t1
fim t2
A thread main fica a espera de t1 e t2

35
Java Threads: JOIN
public static void main (String[] args) {

t1.start();
t2.start();
try {
t1.join(); // a thread main aguarda o trmino de t1
t2.join(); // a thread main aguarda o trmino de t2
} catch (InterruptedException e) {
System.out.println(interrupcao");
}
System.out.println("*** As duas threads encerraram a
contagem ***");
// outras coisas da thread main
}
36
Java Threads: JOIN

JOIN: une as execues das threads
No exemplo das threads contadoras, para testar o

JOIN, faa:
java jar JThreadContadoras.jar NO 2000 JOIN
37
Sumrio
1e
38

Qual thread escolhida para rodar?
Depende...
da implementao da JVM (ex. se utiliza threads nativas do SO)
da prioridade da thread
da poltica/algoritmo de escalonamento do sistema operacional
(ex. round-robin = rodzio por fatia de tempo = quantum)
39
Exemplo: escalonamento no Linux

[fonte http://www.inf.pucrs.br/~celso/SchedulerLinuxWindows.pdf]

Cada processo possui uma prioridade, recalculada dinamicamente.

O escalonador d a CPU ao processo de maior prioridade
O escalonador preemptivo
Para processos interativos (I/O bound) -> round-robin
Para processos tempo-real -> FCFS (first come, first served)
40
Prioridade entre Threads

Windows (2000/NT/XP) ESCALONAMENTO
[fonte http://www.inf.pucrs.br/~celso/SchedulerLinuxWindows.pdf]
No Windows 2000/XP o escalonador utiliza mltiplas filas e as threads

interativos (I/O bound) possuem prioridade sobre os CPU bound.
O escalonamento baseado em prioridades. Cada thread possui uma
prioridade, que varia de 0 a 31 (0 a menor e 31 a maior).
A prioridade 0 atribuda a uma thread especial, chamada zero thread,
que responsvel por zerar as pginas livres no sistema. Somente esta
thread pode receber a prioridade 0.
As prioridades definem trs classes de threads:
Real time: prioridades de 16 a 31;
Normal: prioridades de 0 a 15.
Existe ainda uma classe especial chamada idle, a de mais baixa
prioridade. Threads nesta classe somente executam quando no
existem outras threads aptas (portanto, threads dessa classe no
interferem na performance no causam overhead).
41
Prioridade entre Threads

Windows (2000/NT/XP) ESCALONAMENTO
O escalonador escolhe sempre a thread de maior prioridade.
As threads da classe real time executam at terminar ou se bloquear
(FCFS).
As threads com prioridade normal (0 a 15) recebem fatias de tempo (RR).
no Windows 2000 professional, a fatia de tempo de 20 ms (para
favorecer a interatividade).
no Windows 2000 Server, a fatia de 120 ms (para gerar menos trocas
de contexto).
Cada thread recebe uma prioridade base ao ser criada. Para os processos
de tempo real (prioridade entre 16 e 31) esta prioridade no se altera.
Alm disso, uma thread tem uma prioridade inicial que indica sua
prioridade relativa dentro do processo.
Threads com prioridade entre 0 e 15 tm a prioridade ajustada em tempo
de execuo:
Preemptadas por operaes de I/0 recebem um bnus de aumento,
que depende do perifrico (ex. 1 para disco e 6 para teclado).
Preemptadas por esgotar o quantum: prioridade reduzida.
42

Mapeamento de threads
H de se considerar o mapeamento das threads da JVM para threads nativas do
sistema operacional. Por exemplo, a JavaHotSpot VM na Solaris mapeia uma thread
Java em uma thread nativa.
Maiores detalhes em http://java.sun.com/j2se/1.5.0/docs/guide/vm/thread-priorities.html
http://msdn.microsoft.com/en-us/library/ms685100(VS.85).aspx
As prioridades das Threads setadas no cdigo Java so lgicas e dependem

da implementao da JVM:
public final void setPriority(int newPriority)
public final int getPriority()
MAX_PRIORITY = 10 constante inteira
MIN_PRIORITY = 1
constante inteira
NORM_PRIORITY = 5 prioridade atribuda por default
43

Exerccio: modificar a prioridade das threads contadoras e
observar efeito na execuo. Os dois ltimos parmetros
modificam respectivamente as prioridades da thread 1 e 2.
Recorda-se que a prioridade deve estar no intervalo [1, 10]
No exemplo das threads contadoras, para testar o a

prioridade, faa:
java jar JThreadContadoras.jar OFF 0 OFF 1 10
Prioridade thread 1
Prioridade thread 2
Cdigo fonte e jar disponveis em
http://www.dainf.ct.utfpr.edu.br/~tacla/JAVARepositorio/JThreads/JThreadContadoras/
44

Exerccio: considere um simulador de corridas de frmula
1 que simula uma disputa entre dois pilotos: Schumacker e
Barrichelo.
Cada carro funciona de forma independente
O tempo de cada volta dado por um valor randmico. O
programa deve esperar por este tempo sem fazer nada para
ento iniciar a prxima volta
Ao final da corrida (quando os dois carros completam 5 voltas), o
simulador mostra o tempo acumulado para cada um dos pilotos e
aponta o vencedor ou empate.
Responda
Que comandos da linguagem Java voc utilizaria para resolver
cada um dos itens acima?
JAVARepositorio\JThreads\JCarrosCorrida
45

O cdigo abaixo uma soluo do problema anterior. [JAVA] Altere o
programa atribuindo maior prioridade a uma das threads (Schumaker ou
Barrichelo). [TELEINFO] Execute o .jar for fun!
Cdigo fonte e .jar disponveis em
http://www.dainf.ct.utfpr.edu.br/~tacla/JAVARepositorio/JThreads/JCarrosCorrida/
* No exemplo seguinte, simulamos dois carros de corrida: Schumacker e Barrichelo.
* Cada carro funciona de forma independente na sua thread e demora x milisegundos
* para percorrer um determinado trecho da pista (x um valor aleatrio).
* Para simular este tempo, utilizamos o mtodo Sleep. Na thread Main aguardamos que
* os dois carros terminem a prova para encerrar a corrida. Isto feito atravs do join.
*
* * Rodar a partir da linha de comando
* ===================================
* 1. Salve este arquivo em <dir>/jcarroscorrida/
* 2. Lance o shell: executar -> cmd
* 3. posicione no diretrio <dir>
* 4. compile: javac jcarroscorrida/Main.java
* 5. execute: java -cp . jcarroscorrida/Main
*/
JAVARepositorio\JThreads\JCarrosCorrida
46
Sumrio
1f
47
Compartilhamento de memria um subtpico de
comunicao inter-processos (IPC)

fila de mensagens (SO)

pipeline (SO) proc1 >> proc2 >> proc 3
rea de memria compartilhada (SO) POSIX, threads
envio de mensagens (rede) CORBA, JRMI, RPC, MPI
Threads se comunicam por compartilhamento de

memria
Atributos (membro de classe e de instncia)
Objetos compartilhados
48
Exemplo de compartilhamento de memria
class AreaMem {
static String compartilhada= Thread.currentThread().getName();;
}
class Escritora extends Thread {
public void run() {
AreaMem.compartilhada = Thread.currentThread().getName();
}
}
public class Main {
Escritora E0 = new Escritora();
Escritora E1 = new Escritora();
E0.start();
E1.start();
System.out.println("Compartilhada = " + AreaMem.compartilhada);
}
}
http://www.dainf.ct.utfpr.edu.br/~tacla/JAVARepositorio/JThreads/JCompartMemStaticSimples/
O atributo esttico AreaMem.compartilhada compartilhado entre as threads E0, E1 e main
49
Exerccio
Execute vrias vezes o cdigo do slide anterior
Anote os valores impressos
Qual a explicao?
50
Cenrios de execuo do exemplo

Um dos cenrios possveis de execuo; o valor impresso main
main:Thread
c=main
new
E0:Thread
E1:Thread
start()
start()
print c
run()
run()
c=Thread-0
c=Thread-1
X
X
51
Exemplo por atributo esttico

public class Main extends Thread {
static int c = 0; // compartilhado
private int ini, fim; // nao compartilhados
public Main(int ini, int fim) {
this.ini = ini;
this.fim = fim;
}
public void run() {
System.out.println(Thread.currentThread().getName() + "
while (c >= ini && c <= fim) {
System.out.println(Thread.currentThread().getName()
c = (int)(Math.random()*10);
System.out.println(Thread.currentThread().getName()
}
System.out.println(Thread.currentThread().getName() + "
}
!!! wait ");

+ "
antes " + c);
+ " depois " + c);

!!! fim ");

new Main(0, 4).start();
new Main(5, 10).start();
}
}
JAVARepositorio\JThreads\JCompartMemStatic
52
Cenrio de execuo do exemplo

main:Main
<<create>>
Thread-0:Main
Thread-1:Main
start()
start()
swap
run()
0c4
c:=2
0c4
c:=5
swap
5 c 10
c:=6
5 c 10
c:=2
X
O atributo esttico c
compartilhado pelas
threadas
53
Exerccio
Explique porque a seguinte
sequncia de mensagens no
possvel
main:Main
<<create>>
Thread-0:Main
Thread-1:Main
start()
start()
swap
run()
0c4
c:=2
swap
run()
5 c 10
swap
0c4
c:=5
swap
5 c 10
c:=6
5 c 10
c:=2
X
54
Exerccio
Objetivo: entender o
compartilhamento de memria por
atributos estticos
Para a classe abaixo

class Schedule
static int x = 0;
static int y = 0;
public static int op1() {
x = 1;
return y;
}
public static int op2() {
y = 2;
return 3*x;
}
Se uma thread chama op1 e outra, op2, que resultados podem ser retornados
pelos mtodos op1 e op2?
(Vijay K. Garg, 2004, p. 15)
55
Exemplo por objeto compartilhado

class Conta {
int saldo = 0;
}
class Retirada extends Thread {
private Conta c;
public Retirada(Conta c) {
this.c = c;
}
public void run() {
int vlrs[] = {10, 20, 30, 40, 50, 60};
for (int i=0; i <vlrs.length; i++)
c.saldo -= vlrs[i];
}
}
Objeto compartilhado
class Deposito extends Thread {
private Conta c;
public Deposito(Conta c) {
this.c = c;
}
public void run() {
int vlrs[] = {40, 50, 60, 10, 20, 30};
for (int i=0; i <vlrs.length; i++)
c.saldo += vlrs[i];
}
}
public class Main {

Conta c = new Conta();
Thread d = new Deposito(c);
Thread r = new Retirada(c);
d.start();
r.start();
try {
d.join();
r.join();
} catch (InterruptedException e) { }
System.out.println("Saldo=" + c.saldo);
}
}
http://www.dainf.ct.utfpr.edu.br/~tacla/JAVARepositorio/JThreads/JCompartMemObjetoCC/
56
Exerccio
Faa uma classe Java que faa busca paralela num array
de inteiros. A classe deve implementar o mtodo:
public static int busca(int x, int[] A, int nThreads)
O mtodo cria nThreads
Estas threads devem compartilhar o objeto A.
Cada thread busca pelo inteiro x em uma parte de A, por exemplo,
da posio 0 at a 10, outra da 11 a 20, ...
Se uma das threads encontra x, ento retorna-se o ndice i, tal que
A[i] = x
Caso contrrio, o mtodo retorna -1
Quando uma das threads encontra o nmero x, as outras devem
parar a busca!
sol. JAVARepositorio\JThreads\JBuscaParalela
57
Sumrio
1g
Mquina de estados de uma thread
58
Estados de uma thread

As transies observadas at o momento esto em destaque
Object.wait(timeout)
Thread.join(timeout)
Thread.sleep(delay)
TIMED WAITING
Object.notify()
Object.notifyAll()
join thread termina
fim do sleep
Obteu lock
new()
NEW
start()
Escolhida pelo
scheduler Thread.yield()
swap do scheduler
RUNNING
Object.wait()
Thread.join()
BLOCKED
RUNNABLE
Object.notify()
Object.notifyAll()
join threads terminam
WAITING
TERMINATED
Fim do mtodo run()
Synchronized(obj)
http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Thread.State.html
59
Estado de uma thread: detalhe do runnable
RUNNING
Thread.yield()
Escolhida pelo scheduler
Em runnable, a thread pode ser

escolhida pelo scheduler
para entrar em execuo. Uma vez em
execuo, pode liberar o processador
por yield ou por swap do scheduler.
swap do scheduler
RUNNABLE
60
Sumrio
2
PROBLEMAS DE CONCORRNCIA
61
Sumrio
2a
Problemas de Concorrncia
62
Problemas de concorrncia
Processos compartilham dados
Sincronizar acesso aos dados necessrio
Exemplo

x uma varivel compartilhada (inicialmente zero)

Thread T0 faz x := x + 1
Thread T1 faz x := x + 1
x deve ser 2 ao final
Porm, se x := x + 1 no for uma operao atmica...
63
RACE CONDITION: atualizao perdida

x = x + 1 em cdigo de mquina (inicial x=0)
LD R, x load registrador R com x
INC R
incrementar R
ST R, x store R em x
A execuo de T0 e T1 intercalada
P0: LD R, x
R=0
P0: INC R
R =1
0
10
10
Varivel x
P1: LD R, x R = 0
P0: ST R, x
Registrador R
P1: INC R
R =1
P1: ST R, x
x =1
10
1
x =1
Resultado final: x = 1 problema da atualizao perdida

64
Problemas de concorrncia
x := x + 1 deve ser executada atomicamente
Regio/Seo crtica necessida atomicidade
Para garantir atomicidade, excluso mtua
processos querem o recurso,

mas s um pode utiliz-lo, caso
contrrio o recurso pode ficar
num estado inconsistente
Recurso
compartilhado
Processo 2
Processo 1
Quem ganha a disputa?

65

CC = Conta corrente
Saldo: R$ 100,00
Transao T1:
crdito de R$5,00
Transao T2:
crdito de 10% de juros
Situao desejada:
1) Aplica-se o juros
2) credita-se R$ 5,00
Funcionamento das transaes
1)
2)
3)
s:=CC.getSaldo()
Crdito na varivel s
CC.setSaldo(s)
Saldo da conta deve ser:

(R$100,00 * 1,1) + 5,00 = R$ 115,00
Problemas:
Leitura suja
Atualizao perdida
66

Quando uma transao sobrescreve valores
produzidos por outra
TRANSAO T2
Juros de 10%
TRANSAO T1
Creditar R$ 5,00
S:= CC.getSaldo()
S:= S + 5
// R$100
// S = 105
S = CC.getSaldo( ); // R$100
S = S * 1,10;
// R$ 110,00
CC.setSaldo(S);
// R$ 110,00
CC.setSaldo(S) // R$105
Sobrescreve o valor produzido por T2

Saldo final = R$ 105,00
67
RACE CONDITION: leitura suja

Quando uma transao l valores intermedirios de
outro transao - atributos que esto sendo modificados
em outra transao
Saldo A = R$ 200,00
Saldo B = R$ 300,00
TOTAL = R$ 500,00
Transfere R$100,00 da
Conta A para a conta B
TRANSAO T1
A.retirar(100)
Aps transferncia
Saldo A = R$ 100,00
Saldo B = R$ 400,00
TOTAL = R$ 500,00
Relatrio com o saldo total das

agncias
TRANSAO T2
total = A.saldo( ); // R$100
total = total + B.saldo( ); // R$300
Mostrar total = R$ 400,00
B.depositar(100)
68
CONCORRNCIA
Exemplo de leitura suja/atualizao perdida: executar o cdigo
abaixo e observar que o nmero apontado pelo contador central difere
da soma dos contadores locais devido aos problemas de leitura suja e
atualizao perdida.
Cdigos fonte e .jar disponveis em
http://www.dainf.ct.utfpr.edu.br/~tacla/JAVARepositorio/JThreads/JRaceConditionRoletas/
Contador central
160.000.000
Atualizado pelas
duas roletas de
forma concorrente
40.000.000
120.000.000
Roleta e contador local
69
Sumrio
2b
Vivacidade: deadlock, livelock e starvation
70
Vivacidade
VIVACIDADE: um pedido de uma thread para entrar/acessar
uma seo crtica ser atendido mais cedo ou mais tarde
DEADLOCK: uma thread t1 bloqueia a espera de uma seo crtica
ocupada por t2 que, por sua vez, est bloqueada a espera da
seo crtica ocupada por t1 grafo wait-for cclico
STARVATION: quando uma thread solicita entrada numa seo
crtica e nunca atendida (ex. porque as outras tem maior
prioridade)
LIVELOCK: duas threads no conseguem avanar porque uma muda
seu estado em resposta mudana de estado da outra (ex. duas
pessoas no corredor que sempre escolhem o mesmo lado para
desviarem).
71
Exemplo de deadlock
DEADLOCK: filsofos podem bloquear-se.
Applet demo disponvel em

http://www.doc.ic.ac.uk/~jnm/concurrency/classes/Diners/Diners.html /
72
Exemplo de starvation
STARVATION: um dos filsofos nunca come porque o outro
tem maior prioridade.
Prioridade por
ser o mais sbio
73
Exemplo de livelock
LIVELOCK: filsofos podem bloquear-se porque mudam de
estado continuament em funo do outro.
74
Problema dos filsofos

1.
2.
S um dos filsofos decide comer

Os dois decidem comer ao mesmo tempo, cada um pega um pauzinho
P1 c/ F1
Filsofo 1
termina de
comer
F1
F1
pega
decide
2 pauzinhos comer
P2 c/ F1
P1 c/ F21
Pauzinho 1
F1 e F2
pensam
F2
decide
comer
Pauzinho 2
F2
pega
2 pauzinhos
Filsofo 2
termina
de comer
P2 c/ F2
75

Soluo para o problema dos filsofos: coordenar as
aes
Um dos filsofos devem solicitar os recursos na ordem inversa dos
outros
Ex. todos pegam o objeto da esquerda e depois o da direita.
Facilmente visvel com dois filsofos
76

SOLUO: coordenar as aes. Inverter a ordem.
WAIT
77
Soluo para filsofos
Primeiro o p1 depois o p2
Se os dois decidem comer ao mesmo tempo,

somente um deles conseguir pegar o pauzinho
1
P1 c/ F1
P1 c/ F21
Pauzinho 1
Filsofo 2
termina
de comer
Filsofo 1
termina de
comer
P1 e P2
C/ F1
F1
decide
comer
F1 e F2
pensam
F2
decide
comer
P1 E P2
c/ F2
Pauzinho 2
78

Exerccio
Verificar se a soluo apresentada funciona para 4 filsofos sendo o f2
aquele que pega na ordem invertida. Represente em um diagrama de
seqncia a situao na qual todos tentam pegar os pauzinhos ao mesmo
tempo.
f1
p1
p4
f2
f4
p3
p2
f3
79
Sumrio
2c
Solues aos problemas de concorrncia
80
SOLUES PARA CONCORRNCIA

Como resolver os problemas de acesso seo crtica?
Algoritmos de excluso mtua (mutex)
Busy-wait (Peterson)
Excluso mtua por hardware
Desabilitar interrupes
instrues de mquina atmicas de mais alto-nvel
Primitivas de sincronizao
Semforos
monitor
Monitores
81
MUTEX BUSY-WAIT
BUSY-WAIT: um processo verifica continuamente se pode
entrar na seo crtica desperdiando assim ciclos do
processador.
public class Lock1 implements Lock {
boolean livre = true;
public void requestSC(int i ) {
while (!livre); // busy wait
livre = false;
}
public void releaseSC(int i) {
livre = true;
}
}
JAVARepositorio\JThreads\JExclusaoMutuaLock\src\jexclusaomutualock/Lock1.java
82
MUTEX BUSY-WAIT
Algoritmo de excluso mtua de Peterson
Trs verses incrementais
1. no garante excluso mtua
2. Pode entrar em deadlock
3. Alternncia estrita
Verso final
Deadlock (livre de impasse)
Starvation (livre de inanio)
Vivacidade
Busy-wait: soluo de Peterson
Exerccio: algoritmo de Dekker

Sujeito a deadlock?
Sujeito a Starvation?
Possui a propriedade de vivacidade?
83
MUTEX por HARDWARE

Que solues existem em hardware para o problema de
excluso mtua?
Desabilitar interrupes: antes de entrar na SC, o processo
desabilita as interrues
Em mquinas monoprocessador pode funcionar com alguns
incovenientes...
interrupes do clock (time-slice) ficam desabilitadas
mas, em mquinas multiprocessadores? possvel desabilitar
interrupes em todos os processadores?
Instrues atmicas mais abstratas fornecidas pelo hardware

Test and set
Swap
84
SEMFOROS
SEMFORO (Dijkstra): uma primitiva de sincronizao de
acesso seo crtica que soluciona o problema de busywait.
API do sistema operacional (SO)
Disponvel na API do S.O.
Java no oferece semforos
Dois tipos de semforos

Binrio
contador
85
SEMFORO BINRIO
Semforo binrio:
Valor inicial: verdadeiro
Fila de processos em wait: vazia
Operaes bsicas
P() wait
V() signal (notify)
86
Semforo binrio
T1:thread
S:SemaforoBinario
T2:thread
true
P( )
false
P( )
Na seo
crtica
V( )
true
false
wait
notify( )
Na seo
crtica
V( )
true
87
SEMFOROS
Semforo contador:
Valor inicial: valor inteiro = nmero de processos permitidos na SC
Operaes bsicas
P() wait decrementa um contador
V() signal (notify) incrementa contador
Ver cdigo
88
Semforo contador
T1:thread
S:SemaforoContador
T2:thread
T3:thread
2
P( )
1
P( )
0
Na seo
crtica
P( )
V( )
1
wait
notify( )
V( )
1
H dois recursos, neste caso o
semforo inicializado com 2
89
PRODUTOR-CONSUMIDOR
Problema do Produtor-Consumidor
Soluo utilizando semforos
K=5
PRODUTOR
CONSUMIDOR
BUFFER COMPARTILHADO
90
PRODUTOR-CONSUMIDOR
PRODUTOR-CONSUMIDOR Soluo utilizando semforos
entrada
...
sada
TAM -1
91
PRODUTOR-CONSUMIDOR
Problemas
Excluso mtua no acesso ao buffer
(ou o produtor ou o consumidor)
Consumidor no deve buscar itens quando o buffer est vazio
Produtor no pode produzir se buffer estiver cheio
SINCRONIZAO CONDICIONAL: Um processo aguarda que uma
condio se torne verdadeira antes de continuar suas operaes.
Exemplos:
Consumidor aguarda a existncia de um item
Produtor aguarda espao no buffer para produzir
92
PRODUTOR-CONSUMIDOR
Exerccio (soluo utilizando semforos)
Baixe o cdigo fonte
Faa o diagrama de sequncia para o cenrio seguinte:
O produtor produz um item (double)
O consumidor consome.
O consumidor tenta consumir um item que no existe.
Cdigo fonte e .jar disponvel em
JAVARepositorio/JThreads/JProdutorConsumidorSemaforos
93
SEMFOROS
Outros problemas bem-conhecidos
Leitor-escritor em banco de dados
No acessam o BD concorrentemente
Leitor e escritor
Dois escritores
Mltiplos leitores acessam concorrentemente

Filsofos
94
MONITOR LOCK
MONITOR: mais alto nvel e mais fcil de utilizar que
semforo
Java s trabalha com monitores
Todo objeto em Java um monitor
95
MONITOR LOCK
Quando uma thread executa um bloco de cdigo
sincronizado, ela fecha o acesso s demais. Outra thread
que tentar acessar a seo crtica (o bloco de cdigo) no
conseguir at que a primeira libere o acesso.
Em java, o bloqueio feito no objeto e no no mtodo.
Isto til quando duas ou mais threads devem atualizar
a mesma rea de mmria (atributo compartilhado).
96
EXEMPLO MONITOR LOCK

T1:thread
obj:Compartilhado
T2:thread
Lock livre
mtodo sincronizado( )
Lock ocupado
Na seo
crtica
mtodo sincronizado( )
fim mtodo
waiting
notify( )
Na seo
crtica
fim mtodo
Lock livre
97
Exemplo em JAVA
Problema das roletas e contador central
/**
* Contador um objeto compartilhado pelas threads roleta 1 e roleta 2.
*/
class ContadorCentral {
protected int numPessoas=0;
/**
* O cdigo que faz a atualizao da varivel numPessoas uma seo crtica.
* Somente um processo (ou thread) pode execut-lo por vez. Para impedir que
* mais de uma thread atualize numPessoas, utiliza-se a palavra-chave
* synchronized.
**/
protected synchronized void somarNumPessoas(int n) throws InterruptedException
{
numPessoas += n;
}
}
Ao executar somarNumPessoas de uma certa instncia de ContadorCentral o lock fica retido.

Qualquer outro mtodo (se houvesse) da instncia no poderia ser executado enquanto o
somarNumPessoas no terminasse (lock liberado).
JAVARepositorio\JThreads\JRaceConditionRoletasSol
98
Exemplo em JAVA: outra forma

Problema das roletas e contador central (equivale ao anterior, s
muda a sintaxe)
/**
* Contador um objeto compartilhado pelas threads roleta 1 e roleta 2.
*/
class ContadorCentral {
protected int numPessoas=0;
/**
* O cdigo que faz a atualizao da varivel numPessoas uma seo crtica.
* Somente um processo (ou thread) pode execut-lo por vez. Para impedir que
* mais de uma thread atualize numPessoas, utiliza-se a palavra-chave
* synchronized.
**/
protected void somarNumPessoas(int n) throws InterruptedException {
synchronized (this) {
numPessoas += n;
}
}
}
JAVARepositorio\JThreads\JRaceConditionRoletasSol
99
SINTAXE PARA SYNCHRONIZED

So construes equivalentes
public synchronized void metodo() {
.
.
.
}
public void metodo() {

synchronized (this) {
.
.
.
}
}
Mtodos estticos podem ser

sincronizados equivale
a um lock de classe
100
MONITOR LOCK: SEMNTICA

A thread deve obter o
lock deste objeto para
entrar na SC
Semntica
synchronized (object)
{
como
uma
seo
crtica
.
.
.
Lock para objeto

(no para o bloco de
cdigo ou mtodo)
enterMonitor():
se obtm o lock
entra no monitor
se no aguarda;
exitMonitor():
libera o lock e
notifica processos
bloqueados
101
EXERCCIO
Baixar o programa JRaceConditionRoletas do repositrio e corrigir o

problema de condio de corrida na atualizao do contador central
utilizando bloco de cdigo synchronized.
Cdigo fonte disponvel em
JAVARepositorio/JThreads/JRaceConditionRoletas/
Idem para o programa que atualiza saldo da conta corrente

Cdigo fonte disponvel em
JAVARepositorio/JThreads/JCompartMemObjetoCC/
FIM
Soluo em RepositorioJAVA/JThreads/JRaceConditionRoletasSol
102
MONITOR LOCK: WAIT/NOTIFY

H situaes onde, duas threads devem executar de forma
concorrente dois blocos de cdigo sincronizados do
mesmo objeto.
Mas foi dito que uma vez que uma thread pega o lock de
um objeto ela s o libera ao final do mtodo!!!
Foi uma meia verdade... ;-)
103
THREAD 1
tira
pe
THREAD 2
WAIT pedestal vazio

Tira pea
Notifica que tirou
WAIT pedestal vazio

Pe pea
Notifica que colocou
Pedestal
Objeto compartilhado
104

class Pedestal {
boolean livre = true;
}
class RoboProdutor implements Runnable {
Pedestal p;
RoboProdutor(Pedestal p) {
this.p = p;
}
public void run() {
while (true) {
synchronized (p) {
while (!p.livre) {
p.wait();
}
println("Pea colocada");
p.livre=false;
p.notifyAll();
}
}
}
}
class RoboConsumidor implements Runnable {

Pedestal p;
RoboConsumidor(Pedestal p) {
this.p = p;
}
public void run() {
while (true) {
synchronized (p) {
while (p.livre) {
p.wait();
}
println("Pea retirada");
p.livre=true;
p.notifyAll();
}
}
}
}
Catch e try foram omitidos

Wait libera o lock; Notify no libera o lock
JAVARepositorio\JThreads\JExemploWaitNotifyPedestal
105
EXEMPLO MONITOR LOCK

Produtor:Runnable
p:Pedestal
Consumidor:Runnable
Lock
Incio do run()
synchronized(p)
Obtm o lock de p
Incio do run()
Lock
synchronized(p)
Pea Colocada
p.livre = false
Livre=false
notifyAll( )
waiting pelo lock
fim bloco sync: libera o lock

synchronized(p)
Obtm o lock de p
wait p.livre
Lock
Lock
Lock
Obtm o lock
p.livre = true
Livre=true
Pea Retirada
106
EXERCCIO
Baixe o cdigo fonte dos robs e pedestal
Inclua mais um rob consumidor
Identifique na mensagem impressa qual rob consumidor
que faz a retirada da pea
Verifique se o programa funciona corretamente.
http://www.dainf.ct.utfpr.edu.br/~tacla/JAVARepositorio/JThreads/JExemploWaitNotifyPedestal/
107
MONITOR LOCK: WAIT, NOTIFY

Cada monitor tem uma fila de processos bloqueados
3 mtodos especiais podem ser usados dentro do monitor
synchronized
(object) {
.
object.wait();
.
object.notify();
.
object.notifyAll(
);
.
}
Thread Libera o lock do object e

passa ao estado waiting
Se a fila no estiver vazia, pega um

processo qualquer da fila e o
desbloqueia
Se a fila no estiver vazia,

desbloqueia todos os processos da
fila que vo disputar o lock mas s
um ser escolhido pelo escalonador
(ineficiente se houver muitas threads)
108
NOTIFY x NOTIFY ALL
Utilizar notify no lugar de notify all somente quando as

duas condies abaixo forem verdadeiras:
1. Threads em waiting possuem mesma condio de espera (ex.
estahVazio). Todas as threads executam a mesma lgica quando
saem do wait.
2. One-in, one-out. A notificao sobre a varivel utilizada na
condio habilita somente uma thread a prosseguir.
Fonte: Goetz, B. Java Concurrency in Practice, ed. Pearson Education,

2006, seo 14.2.4
109
Exemplo tpico
synchronized(obj) {
while(<condio>)
{
try {
wait();
}catch (InterruptedException e) { }
}
// alguma coisa
notifyAll();
}
110
Mtodosde bloco de cdigo sincronizado

Usar somente em blocos de cdigo sincronizado (caso
contrrio, erro de execuo IllegalMonitorStateException)
Object.wait( ) libera o lock
Object.wait(<t em ms>) libera o lock
Object.notify()
Object.notifyAll()
Importante: no manipulam lock

Thread.yield() no libera o lock

Thread.sleep(<t em ms>) no libera o lock
Thread.suspend() no utilizar deprecated
Thread.resume() no utilizar - deprecated
111
Tipos de monitores
H duas implementaes clssicas de monitores
Hoare: o processo que faz a notificao interrompido
Estilo Java: o processo que faz a notificao no
necessariamente interrompido
112
Dois tipos de monitores
Processo 0
synchronized (object) {
.
object.wait();
Processo 1
.
object.notify();
Qual processo continua a execuo nesse ponto?

.
Somente um processo pode estar no monitor: 2 possibilidades
113
TIPO 1: MONITOR DE HOARE
Process 0
.
object.wait();
Process 1
.
object.notify();
.
}
.
}
Processo 0 assume a execuo

assim que o 1 faz notify
114
Tipo 1: MONITOR DE HOARE
Process 0
if (x != 1)
object.wait();
A condio de sincronizao
(x=1) seguramente verdadeira quando o processo
notificado
Process 1
x=1;
O processo que notifica
object.notify(); interrompido
assert(x==1); // x igual a 1
x++;
}
// x pode ser 0 neste ponto
}
No monitor HOARE, possvel fazer

condio sincronizada com if
115
TIPO 2: MONITOR ESTILO JAVA
Process 0
.
object.wait();
Process 1
.
object.notify();
// cdigo
// cdigo
}
.
}
No monitor estilo Java, o Processo 1 continua

a executar aps o notify
116
Tipo 2: MONITOR JAVA
Process 0
if (x != 1)
object.wait();
P0 realiza operaes
assumindo x=1, sendo
que x pode ter outro
valor
Process 1
x=1;
object.notify();
assert(x == 1); // x must be 1
x++;
}
assert(x==1); // falso
x++;
}
Processo 1 continua a executar e pode modificar o valor de x. A

sincronizao condicional com um simples if pode no funcionar.
117
Tipo 2: MONITOR JAVA
Process 0
while (x != 1)
S sai do while
object.wait(); quando x=1
P0 realiza operaes
assumindo x=1, sendo
que x ser igual a 1
Process 1
x=1;
object.notify();
assert(x == 1); // x must be 1
x++
}
assert(x==1); // verdadeiro
x++;
}
Para solucionar o problema do slide anterior, preciso colocar um

while (tambm resolve o caso de interrupes esprias).
118
Dois tipos de monitores

O monitor Java mais usual
Porm, prudente verificar o tipo de monitor quando for utilizar
outra linguagem
Cdigo de sincronizao extremamente difcil de

debugar
Muitos bugs ficam escondidos durante anos sem que ningum
perceba
Faa certo da primeira vez!
119
Resumo
Por que necessitamos de primitivas de sincronizao?

Busy waiting desperdia ciclos de CPU
Primitivas de sincronizao necessitam suporte do SO
Semforo:
Binrio, contador
Produtor-consumidor
Monitor:
Mais fcil e mais popular que semforos
Dois tipos: Hoare e estilo Java
120
EXERCCIO
Problema do barbeiro dorminhoco

Um barbeiro corta o cabelo de qualquer cliente.

Se no h clientes, o barbeiro tira uma soneca.
H vrias threads, uma para cada cliente.
Um cliente aguarda pelo barbeiro se h ao menos uma cadeira
vazia na barbearia,
Caso contrrio, o cliente sai da barbearia imediatamente.
Se h uma cadeira disponvel, ento o cliente senta.
Se o barbeiro est dormindo, ento o cliente acorda-o.
Existem <n> cadeiras na barbearia.
Faa um programa para a classe BarbeiroDorminhoco

utilizando monitor
121

Programação Paralela e Distribuída - Fundamentos da UTFPR

Caricato da

Informazioni sul documento

Descrizione originale:

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Programação Paralela e Distribuída - Fundamentos da UTFPR

Caricato da

Copyright:

Formati disponibili

PR

UNIVERSIDADE TECNOLGICA FEDERAL DO PARAN

PROGRAMAO PARALELA E DISTRIBUDA

Definio de sistemas paralelos e distribudos

Programao Paralela e Distribuda - Fundamentos/UTFPR Prof. Cesar Augusto Tacla

Programao Paralela e Distribuda - Fundamentos/UTFPR Prof. Cesar Augusto Tacla

Programao Paralela e Distribuda - Fundamentos/UTFPR Prof. Cesar Augusto Tacla

Programao Paralela e Distribuda - Fundamentos/UTFPR Prof. Cesar Augusto Tacla

Segundo (Garg, 2004), so sistemas compostos por

Programao Paralela e Distribuda - Fundamentos/UTFPR Prof. Cesar Augusto Tacla

Distribudo x Paralelo (1)

Programao Paralela e Distribuda - Fundamentos/UTFPR Prof. Cesar Augusto Tacla

Distribudo x Paralelo (2)

Programao Paralela e Distribuda - Fundamentos/UTFPR Prof. Cesar Augusto Tacla

Distribudo x Paralelo (3)

Programao Paralela e Distribuda - Fundamentos/UTFPR Prof. Cesar Augusto Tacla

Distribudo x Paralelo (4)

Na realidade, reflete a estrutura de hardware

Programao Paralela e Distribuda - Fundamentos/UTFPR Prof. Cesar Augusto Tacla

Programao Paralela e Distribuda - Fundamentos/UTFPR Prof. Cesar Augusto Tacla

Programa, processo, thread

Programao Paralela e Distribuda - Fundamentos/UTFPR Prof. Cesar Augusto Tacla

Programa, processo, thread

Programao Paralela e Distribuda - Fundamentos/UTFPR Prof. Cesar Augusto Tacla

Programa, processo e thread

Programao Paralela e Distribuda - Fundamentos/UTFPR Prof. Cesar Augusto Tacla

Programa, processo, thread

Stack: armazena o estado de

Heap: armazena instncias de

Processos que compartilham cdigo e

Method area: informaes da classe (nome,

Programao Paralela e Distribuda - Fundamentos/UTFPR Prof. Cesar Augusto Tacla

Programao Paralela e Distribuda - Fundamentos/UTFPR Prof. Cesar Augusto Tacla

Programao Paralela e Distribuda - Fundamentos/UTFPR Prof. Cesar Augusto Tacla

Criao de threads em Java

Possibilita estender outra classe

Criao de threads em Java

public class Main {

Programao Paralela e Distribuda - Fundamentos/UTFPR Prof. Cesar Augusto Tacla

Criao de threads em Java

public class Main {

Programao Paralela e Distribuda - Fundamentos/UTFPR Prof. Cesar Augusto Tacla

Criao de threads em Java

Duas threads so criadas, cada uma conta at

Para executar somente

Criao de Threads em Java

Criao de Threads em Java

Quem faz o chaveamento de contexto?

Criao de threads em Java

Exerccio 2: criar vrias threads (> 4) e observar o

Programao Paralela e Distribuda - Fundamentos/UTFPR Prof. Cesar Augusto Tacla

Programao Paralela e Distribuda - Fundamentos/UTFPR Prof. Cesar Augusto Tacla

Java THREADS: YIELD

Programao Paralela e Distribuda - Fundamentos/UTFPR Prof. Cesar Augusto Tacla

Java THREADS: YIELD

Programao Paralela e Distribuda - Fundamentos/UTFPR Prof. Cesar Augusto Tacla

Java THREADS: YIELD

Programao Paralela e Distribuda - Fundamentos/UTFPR Prof. Cesar Augusto Tacla

Java Threads: SLEEP

No exemplo das threads contadoras, cada

Programao Paralela e Distribuda - Fundamentos/UTFPR Prof. Cesar Augusto Tacla

Java THREADS: SLEEP