Programação Concorrente JAVA
Prof. Alexandre Monteiro
Recife
‹#›
Contatos

Prof. Guilherme Alexandre Monteiro Reinaldo

Apelido: Alexandre Cordel

E-mail/gtalk: [email protected]
[email protected]

Site: http://www.alexandrecordel.com.br/fbv

Celular: (81) 9801-1878
Conteúdo

O que é

Motivação

Conceitos

Processos

Threads

Propriedades

Safety

Liveness

Threads em JAVA
Programação Concorrente
[ O que é ]

“Um programa concorrente é um
conjunto de programas seqüenciais
comuns que são executados em um
paralelismo abstrato” (M.Bem-Ari)
Programação Concorrente
[ O que é ]

“Um programa concorrente especifica 2
ou mais processos que cooperam para
realizar uma tarefa. Processos cooperam
através de comunicação; utilizam
variáveis compartilhadas ou troca de
mensagens“(G. R. Andrews)
Programação Concorrente
[ Motivação ]

Aproveitar hardware com múltiplos processadores

Atender a vários usuários simultaneamente

Melhorar o desempenho das aplicações

Aumentar a disponibilidade da CPU para o usuário

Objetos ativos e controle de atividades

Programas paralelos
Programação Concorrente
[ Conceitos ]

Paralelismo
• Processamento simultâneo físico

Concorrência
• Processamento simultâneo lógico (aparente)
• Requer entrelaçamento (interleaving) de ações

Processo
• Execução de um programa (running)

Programa Concorrente
• Vários processos que cooperam para a realização de
uma tarefa ou mais tarefas
Programação Concorrente
[ Conceitos ]

Comunicação
• Variáveis compartilhadas
• Passagem de mensagens

Sincronização
• Exclusão mútua de seções críticas
• Sincronização por condição

Estado de um programa concorrente
• Consiste dos valores das variáveis (explícitas e implícitas)
• A execução de um comando muda o estado

Ações atômicas
• Transformação indivisível de estado
Programação Concorrente
[ Processos ]





Um processo é um programa que está em algum
estado de execução
Tem espaço de endereçamento próprio, que é
mapeado pelo S.O. para memória física
Possui um fluxo de controle ou thread único
Mantém um contador de programa (PC) que indica
o endereço da próxima instrução
A MMU (Memory Management Unit) traduz os
endereços lógicos em endereços físicos, que
normalmente não são contíguos (Memória Virtual)
Programação Concorrente
[ Processos ]

Espaço de Endereçamento Lógico
Pilha
Espaço de
Endereçamento
Lógico de um
Processo
Heap
Dados Globais
Instruções
Programação Concorrente
[ Processos ]

Tabela de Processos
•Estado do processo
•Valores dos registradores
•Arquivos abertos
•Alocação de memória
•PID (Process ID)
•UID (User ID)
•GID (Owner’s Group ID)
Programação Concorrente
[ Processos ]

Estados de um processo
1. Iniciado (Start): processo criado
2. Executando (Running): Utilizando a CPU
3. Executável ou Pronto (Runnable ou Ready):
Esperando para ser escalonado para usar a CPU
4. Suspenso (Suspended): Recebeu um sinal para ser
suspenso
5. Bloqueado (Blocked): Esperando pela conclusão de
algum serviço solicitado ao S.O.
6. Encerrado (Dead): processo morto
Programação Concorrente
[ Processos ]
Ativo
Bloqueado
Executável
Executando
Encerrado
Iniciado
Suspenso
Programação Concorrente
[ Threads ]




Um processo pode ter mais de uma Thread
(Linha)
Cada Thread possui contador de programa e
pilha próprios
Quando um processo é escalonado para ser
executado, uma das Threads entra em
execução
As Threads compartilham as variáveis globais
do processo
Programação Concorrente
[ Threads ]
Espaço de Endereçamento de um Processo
Pilha
Thread 1
Thread 2
Thread n
Pilha
Pilha
Pilha
Contador
de Programa
Contador
de Programa
Contador
de Programa
Heap
Variáveis Globais
Instruções
Programação Concorrente
[ Threads ]

Vantagens sobre processos compartilhando memória
•São muito mais leves de serem criadas
•A troca de contexto é mais suave pois
compartilha instruções, heap e
variáveis globais
•Facilitam o compartilhamento de
memória
Threads
[ Ciclo de Vida ]
Intervalo de tempo expirou
4.sleep()
Dormindo
6.stop()
1.new Thread()
escalonada
Criada
Encerrada
Término
3.run()
2.start()
Pronta
Executando
interrompida
Operação
de E/S
concluída
5.notify()
5.notityAll()
4.wait()
Esperando
Bloqueada
Operação
de E/S
iniciada
Threads
[ Sincronização ]

Sincronizando Threads
•Programação com múltiplas Threads requer
bastante cuidado:
- Acesso / Atualização de variáveis compartilhadas
- Starvation (processo nunca é executado)
- Deadlock (impasse e dois ou mais processos ficam impedidos
de continuar suas execuções e ficam bloqueados)
- Acesso a estados inválidos de outros objetos
Threads
[ Sincronização ]


A sincronização baseia-se na idéia de que para
acessar um método sincronizado ou um entrar em
um bloco sincronizado, é preciso obter (ou já ter)
o lock desse objeto.
A Thread que conseguir esse lock é a única
autorizada a acessar os recursos protegidos
através de sincronização.
Programação Concorrente
[ Propriedades ]






Safety: O programa nunca entra em um estado
inconsistente
Liveness: Em algum momento o programa entra
em um estado consistente
Correção Parcial: Se o programa terminar, o
resultado está correto. Caso contrário, nunca
pode dar o resultado correto
Término: O programa termina eventualmente
Ausência de Deadlock: Nunca todos os processos
estarão bloqueados
Correção Total: O programa sempre termina e
produz o resultado correto
Safety
[ Introdução ]


Objetos interagindo em múltiplas Threads normalmente
provocam interferência
Programas concorrentes devem possuir 2 propriedades:
•Safety: Nada de mau acontecerá durante a
execução do programa.
•Liveness: Algo de bom acontecerá durante a
execução do programa.
Safety
[ Imutabilidade ]

Variáveis de instância constantes (final em Java)

Encapsulamento

Não requer sincronização

Classes sem estado (stateless)
•Como não há estado, não há interferência
Safety
[ Sincronização ]


Um Objeto/variável sempre está pronto para sofrer
modificações, mesmo quando ainda está no meio do
processamento de alguma
Acesso a estados inconsistentes devem ser evitados:
•Conflitos de leitura/escrita: vários lêem
enquanto um escreve
•Conflitos de escrita/escrita: vários lêem e
escrevem ao mesmo tempo
Safety
[ Sincronização ]

No contexto de OO, podemos ter:
•Sincronização Total
- Objetos totalmente sincronizados. Podem
fazer apenas uma operações por vez
•Sincronização Parcial
- Parte do objeto é sincronizado. Somente
métodos sincronizados são travados
Safety
[ Contenção ]


Baseia-se na idéia de manter referências únicas para
objetos internos isolados dos demais.
São acessados apenas através de métodos
sincronizados do objeto no qual estão contidos,
estando, portanto, protegidos.
Safety
[ Contenção ]
•É preciso definir um protocolo que garanta a
exclusividade do recurso
null
null
serviço 1
vizinho
vizinho
serviço 0
serviço 2
vizinho
vizinho
serviço 3
null
Recurso
Liveness
[ Falhas de Liveness ]



São tão sérias quanto falhas de Safety
São mais difíceis de identificar e evitar durante o
projeto
Tipos de falhas
•Contenção: uma thread, apesar de estar
pronta para executar, não executa porque
outra tomou recursos (também conhecida
como starvation ou adiamento infinito)
Liveness
[ Falhas de Liveness ]
•Dormência: uma thread não pronta falha ao
tentar passar para esse estado.
•Deadlock: duas ou mais threads bloqueiamse em um ciclo vicioso enquanto tentam
acessar travas sincronizadas necessárias
para continuar suas atividades
•Término prematuro: uma thread é parada
ou encerrada prematuramente
Threads JAVA
‹#›
Definições Básicas




Threads são sub-procesos no sistema
operacional.
É menos custoso gerenciar threads do que
processos.
As linguagens Java e Ada possuem
funcionalidades MULTITHREADING na própria
estrutura da linguagem.
C e C++ necessitam de biblioteca especifica
para processamento MULTITHREADING
• Posix p_thread
Diagrama de Estados Thread Java
O diagrama mostra os estados de uma thread de Java pode estar e alguns
métodos que podem ser usados para mudar de um estado para outro.
New Thread

Inicialização do thread - feita através do construtor
Thread().
class MyThreadClass extends Thread{
...
}
...
MyThreadClass myThread = new MyThreadClass();


Neste estado, nenhum recurso do sistema foi alocado para o
thread ainda, assim, a partir daqui, tudo que você pode
fazer é um start(), para ativar o thread, ou um stop(), para
"matá-lo".
A chamada de qualquer outro método não faz sentido e
levantará a exceção IllegalThreadStateException.
Runnable


Este é o estado em que o thread está pronto para rodar. O método start()
requisita os recursos do sistema necessários para rodar o thread e chama
o seu método run().
O método run() é a "alma" de um thread; é neste método que definimos o
que o thread vai executar.
Thread myThread = new MyThreadClass();
myThread.start();


Falamos em "Runnable", ao invés de "Running", porque o thread pode não
estar realmente sendo executado. Imagine um computador com um único
processador - seria impossível executar todos os threads "Runnable" ao
mesmo tempo. O que ocorre é que a CPU deve ser escalonada entre os
vários threads.
Quando um thread está "Running", ele está também "Runnable", e, as
instruções do seu método run() é que estão sendo executadas pela CPU.
Not Runnable

O estado "Not Runnable" significa que o thread está impedido
de executar por alguma razão. Existem 4 maneiras através
das quais um thread ir para o estado "Not Runnable":
•Alguém manda-lhe a mensagem suspend().
•Alguém manda-lhe a mensagem sleep().
•O thread bloqueia, esperando por I/O.
•O thread usa seu método wait() para esperar por uma
variável de condição.
Not Runnable

O exemplo abaixo coloca “myThread” para dormir por 10
segundos...
Thread myThread = new MyThreadClass();
myThread.start();
try {
myThread.sleep(10000);
} catch (InterruptedException e){
}
Not Runnable

Cada uma destas maneiras tem a sua forma específica de sair do estado
"Not Runnable".
•Se o thread foi suspenso, alguém precisa mandar-lhe a
mensagem resume().
•Se o thread foi posto para dormir, ele voltará a ser
"Runnable" quando o número de milisegundos
determinado passar.
•Se o thread está bloqueado, esperando por I/O, a I/O
precisa ser completada.
•Se o thread está esperando por uma variável de
condição, o objeto que a "segura" precisa liberá-la,
através de um notify() ou de um notifyAll()
Dead

Um thread pode morrer de "causas naturais" (quando o seu
método run() acaba normalmente) ou pode ser morto
(AssAssINAdO pelo método stop()).
Thread myThread = new MyThreadClass();
myThread.start();
public void run() {
int i = 0;
while (i < 100) {
i++;
System.out.println("i = " + i);
}
}

Este thread vai morrer naturalmente quando o loop do run()
acabar.
Dead

O que vai acontecer com este thread?
Thread myThread = new MyThreadClass();
myThread.start();
try {
Thread.currentThread().sleep(10000);
} catch (InterruptedException e){
}
myThread.stop();
Método yield()

O método yield()

Cede a CPU para outros threads
Thread em Java

Em Java, threads são implementadas como uma CLASSE
•Pacote java.lang.Thread
•É uma extensão da classe Thread
•Contrutores:
- public Thread (String nome_da_thread);
- public Thread ( ); // o nome sera Thread-#
• Thread-1, Thread-2,…
Principais Métodos
•run(): é o método que executa as
atividades de uma THREAD. Quando este
método finaliza, a THREAD também
termina.
•start(): método que dispara a execução de
uma THREAD. Este método chama o
método run( ) antes de terminar.
•sleep(int x): método que coloca a THREAD
para dormir por x milisegundos.
Principais Métodos
•join( ): método que espera o término da
THREAD para qual foi enviada a mensagem
para ser liberada.
•interrupt( ): método que interrompe a
execução de uma THREAD.
•interrupted( ): método que testa se uma
THREAD está ou não interrompida.
Estados de uma Thread em Java
nascimento
Término do tempo de dormida
start( )
Fim da E/S
notify( )
notifyAll( )
pronta
run( )
Alocar um processador
executando
E/S
wait( )
sleep( )
esperando
dormindo
stop( )
morta
Fim do Método run( )
bloqueada
Prioridade de Thread

Em Java, a prioridade é determinada com um
inteiro entre 1 e 10.

A prioridade padrão é o valor 5.

10 é a maior prioridade e 1 é a menor.

A THREAD herda a prioridade da THREAD que
acriou.

void setPriority(int prioridade);

int getPriority( );
Algoritmo de Escalonamento
Prioridade 10
Prioridade 9
A
B
C
Prioridade 8
.
.
.
Prioridade 3
D
E
Prioridade 2
Prioridade 1
G
F
Exercício 01


O programa cria 04 threads e as coloca para
dormir.
ThreadBasica é uma extensão da classe Thread.
Exercício 01
•Analise como se chama o método sleep().
•Crie n THREADs, onde n é definido pelo
usuário.
•Utilize o método join no main para esperar
as THREADs terminarem.
try {
uma_thread.join( ); //
uma_thread.join(tempo)
…
}catch (InterruptedException e) {
…
}
Escalonamento de Threads
Prioridade 10
Prioridade 9
A
B
C
Prioridade 8
.
.
.
Prioridade 3
D
E
Prioridade 2
Prioridade 1
G
F
Exercício 02


Prioridades de Threads
Utilize o método setPriority(int) para mudar a
prioridade de threads
•Utilize 01 thread com prioridade 1, 01 com
prioridade 09 e as outras com prioridade 05.
•Faça com que uma das threads de alta
prioridade durma por 10 ms antes de
terminar.
•Faça com que outra thread de alta
prioridade faça uma entrada de dado.
Exercício 03

Problema Produtor X Consumidor
- Com buffer de tamanho 1.
- Variáveis compartilhadas.
- A solução do problema seria utilizar-se duas
THREADS: 01 consumidor e 01 produtor.
- O que ocorre se não houver sincronização
entre a leitura e escrita?
Exercício 04



Problema do Produtor X Consumidor com
sincronização do Buffer.
Em Java, a sincronização entre threads é feita
através do conceito de monitores.
Monitor é um agrupamento de funções, cujas
execuções não podem se dar de forma
concorrente.
Exercício 04



Utilizar os métodos multuamente excludentes
de um objeto como do tipo synchronized em
Java.
Utilizar os métodos wait( ) e notify( ) para
bloquear e liberar, respectivamente, as
threads.
Resolver o problema de Produtor-Consumidor.
A interface Runnable

A solução encontrada em Java foi a utilização de uma
interface: Runnable
•No caso, tem-se de implementar esta
interface, que possui o método run( ).
public class Filho extends Pai implements Runnable
• Ao implementar uma interface, a classe se capacita
a ser tratada como se fosse um objeto do tipo da
inteface implementada.
- Se a classe Filho implementar a interface Runnable, ela
pode ser tratada como tal.
A interface Runnable


Para utilizar multithreads em Java é
necessário instanciar um objeto de uma classe
que estende a classe básicaThread, certo?
Uma vez que Java não possui herança
múltipla, como eu posso utilizar um objeto,
cuja classe já é derivada, como no caso da
ClasseThread?
public class Filho extends Pai extends Thread {
……………….
} // isto nao eh possivel em Java
A interface Runnable

Cria-se uma thread (Classe Thread), passando para o seu
construtor uma referência do objeto que implementa a
interface Runnable.
Thread uma_Thread = new Thread(Runnable obj_thread)
Thread uma_Thread = new Thread(Runnable obj_thread, String nome_da_thread)
Exercício 5



Crie um programa onde o usuário possa escolher a quantidade de
processos a serem criados para execução em concorrência.
Estes devem ser nomeados e atribuída prioridades valores de 1
até um valor máximo 10, passado para cada um deles.
Quando o processo atingir o número correspondente a metade do
valor máximo do número de processos, deve entrar em espera de
um tempo calculado de maneira randômica entre 1 e 5 segundos
e posteriormente ser liberado.
O programa deve ter um menu com as seguintes opções:
1) Criação de processos (qtd e nomes)
2) Prioridades dos processos (int de 1 a 10)
Exercício 6



Veja a classe a seguir
É uma classe que implementa Runnable e, no método run(),
apenas imprime dez mil números.
Vamos usá-las duas vezes para criar duas threads e imprimir os
números duas vezes simultaneamente:
Exercício 6
Exercício 6




Se rodarmos esse programa, qual será a saída? De um a mil e
depois de um a mil? Provavelmente não, senão seria sequencial.
Ele imprimirá 0 de t1, 0 de t2, 1 de t1, 1 de t2, 2 de t1, 2 de t2 e
etc? Exatamente intercalado?
Na verdade, não sabemos exatamente qual é a saída.
Rode o programa várias vezes e observe: em cada execução a
saída é um pouco diferente.
Depois mude a prioridade e veja como ocorre a execução.
Exercício 6



O problema é que no computador existe apenas um processador
capaz de executar coisas. E quando queremos executar várias
coisas ao mesmo tempo, e o processador só consegue fazer uma
coisa de cada vez? Entra em cena o escalonador de threads.
O escalonador (scheduler), sabendo que apenas uma coisa pode
ser executada de cada vez, pega todas as threads que precisam
ser executadas e faz o processador ficar alternando a execução
de cada uma delas.
A ideia é executar um pouco de cada thread e fazer essa troca
tão rapidamente que a impressão que fica é que as coisas estão
sendo feitas ao mesmo tempo.
Exercício 6


O escalonador é responsável por escolher qual a próxima thread a ser
executada e fazer a troca de contexto (context switch). Ele
primeiro salva o estado da execução da thread atual para depois
poder retomar a execução da mesma. Aí ele restaura o estado da
thread que vai ser executada e faz o processador continuar a
execução desta. Depois de um certo tempo, esta thread é tirada do
processador, seu estado (o contexto) é salvo e outra thread é
colocada em execução. A troca de contexto é justamente as
operações de salvar o contexto da thread atual e restaurar o da
thread que vai ser executada em seguida.
Quando fazer a troca de contexto, por quanto tempo a thread vai
rodar e qual vai ser a próxima thread a ser executada, são escolhas
do escalonador. Nós não controlamos essas escolhas (embora
possamos dar "dicas" ao escalonador). Por isso que nunca sabemos ao
certo a ordem em que programas paralelos são executados.
Exercício 6

Todo esse processo é feito automaticamente pelo escalonador do
Java (e, mais amplamente, pelo escalonador do sistema
operacional). Para nós, programadores das threads, é como se as
coisas estivessem sendo executadas ao mesmo tempo.
Referências


Concurrent Programming - Hartley (capítulo 1)
Concurrent Programming in Java - Lea
(capítulo 1, 2 e 3)
Programação Concorrente JAVA
Prof. Alexandre Monteiro
Recife
‹#›