Java Threads

Multitarefa e Multithreading

• Multitarefa refere-se à capacidade de um

computador de executar vários trabalhos
simultaneamente
– mais de um programa em execução
simultaneamente, por exemplo, UNIX
 Multitarefa e Multithreading

• Uma thread é uma única sequência de

execução dentro de um programa
• Multithreading refere-se a vários threads
de controle dentro de um único programa
– cada programa pode executar vários threads
de controle dentro dele, por exemplo,
navegador da Web
Concorrência vs. Paralelismo
CPU CPU1 CPU2
 Threads e Processos
CPU

main

run

Process 1 Process 2 Process 3 Process 4

GC
 Para que serve uma thread?
• Manter a capacidade de resposta de um
aplicativo durante uma tarefa longa.
• Permitir o cancelamento de tarefas
separáveis.
• Alguns problemas são intrinsecamente
paralelos.
• Monitorar o status de algum recurso (BD).
 Aplicação de Thread

• Quando executamos uma aplicação:

– A JVM cria um objeto Thread cuja tarefa é
definida pelo método main()
– O thread executa as instruções do programa
uma por uma até que o método retorne e a
thread morra.
– Toda Thread é criada e controlada pela classe
java.lang.Thread
 Multiplas Threads
• Cada thread tem sua pilha de execução privada
• Se duas threads executarem o mesmo método,
cada uma terá sua própria cópia das variáveis
locais que o método usa
• No entanto, todos os threads veem a mesma
memória dinâmica (heap)
• Duas threads diferentes podem atuar no mesmo
objeto e nos mesmos campos estáticos
simultaneamente
 Criando Threads

• Existem duas maneiras de criar nosso

próprio objeto Thread:
– Subclassificando a classe Thread e
instanciando um novo objeto dessa classe
– Implementando a interface Runnable

• Em ambos os casos o método run() deve

ser implementado
 Extends Thread
public class ThreadExemplo extends Thread {
public void run () {
for (int i = 1; i <= 100; i++) {
System.out.println(“Thread: ” + i);
}
}
}
 Métodos Thread
void start()
– Cria uma nova thread e a torna executável
– Método só pode ser chamado apenas uma vez
void run()
– A nova thread começa sua vida dentro deste
método
void stop() (descontinuada)
- A thread é encerrada
 Métodos Thread
• yield()
– Faz com que o objeto thread atualmente em
execução seja pausado temporariamente e
permita que outras threads sejam executadas
– Permitir que apenas threads da mesma
prioridade sejam executados
• sleep(int m)/sleep(int m,int n)
– A thread dorme por m milissegundos, mais n
nanossegundos
 Implementing Runnable
public class RunnableExemplo implements Runnable {
public void run () {
for (int i = 1; i <= 100; i++) {
System.out.println (“Runnable: ” + i);
}
}
}
 Um Object Runnable

• O método run() do objeto Thread chama o

método run() do objeto Runnable

• Permite que threads sejam executadas

dentro de qualquer objeto,
independentemente da herança
 Iniciando as Threads
public class Main {
public static void main (String argv[]) {
new ThreadExemplo ().start ();
new Thread(new RunnableExemplo ()).start ();
}
}
 Threads
start()
Fila prontos

Threads
recém
criada

Thread executada

I/O operation completes

•Esperand operação E/S ser completada

•Aguardando Notificação
•Dormindo
•Aguardando sincronização
 Estados de uma Thread

• New
• Runnable
• Running
• Not Runnable
– Bloqueada para E/S
– Esperando variável de condição
– Sleeping (dormindo)
• Dead
Estados de uma Thread
 Thread State Diagram

Alive

Executando
new ThreadExample(); while (…) { … }

Nova Thread Runnable Dead Thread

thread.start();
run() method returns

Blocked
Object.wait()
Thread.sleep()
Bloqueada IO call
Aguardando um monitor
 Exemplo
public class PrintThread1 extends Thread {
String name;
public PrintThread1(String name) {
this.name = name;
}
public void run() {
for (int i=1; i<500 ; i++) {
try {
sleep((long)(Math.random() * 100));
} catch (InterruptedException ie) { }
System.out.print(name);
}}
 Exemplo (cont)
public static void main(String args[]) {
PrintThread1 a = new PrintThread1("*");
PrintThread1 b = new PrintThread1("-");
PrintThread1 c = new PrintThread1("=");
a.start();
b.start();
c.start();
}
}
 Agendamento

• O agendamento de threads é o mecanismo

usado para determinar como threads
executáveis são alocados no tempo de CPU
• Um mecanismo de escalonamento de
threads é preemptivo ou não preemptivo
 Agendamento Preemptivo

• Agendamento preemptivo – o agendador de

threads antecipa (pausa) um thread em
execução para permitir a execução de
diferentes threads
• Agendamento não preemptivo – o
agendador nunca interrompe um thread em
execução
 Agendamento Preemptivo

• O escalonador não-preemptivo depende da

thread em execução para ceder o controle
da CPU para que outras threads possam
executar
 Starvation

• Um escalonador não-preemptivo pode

causar starvation (threads executáveis,
prontos para serem executados, aguardam
muito tempo para serem executados na
CPU, talvez até para sempre)
• Às vezes, a starvation também é chamada
de livelock
 Agendamento interval de tempo

• Agendamento dividido em intervalos de

tempo – o agendador aloca um período de
tempo em que cada thread pode usar a
CPU
– quando esse período de tempo tiver
decorrido, o agendador interrompe o thread e
muda para um thread diferente
 Agendamento intervalo de tempo

• Agendador sem divisão de tempo – o

agendador não usa o tempo decorrido para
determinar quando antecipar um thread
– ele usa outros critérios, como prioridade ou
status de E/S
 Escalonador Java

• O escalonador é preemptivo e baseado na

prioridade dos threads
• Usa agendamento de prioridade fixa:
– Os threads são agendados de acordo com sua
prioridade em relação a outras threads na fila
pronta
 Escalonamento Java

• A thread executável de maior prioridade é sempre

selecionado para execução acima dos threads de
prioridade mais baixa
• Quando várias threads têm prioridades igualmente altas,
é garantido que apenas um dessas threads esteja em
execução
• Threads Java são garantidas como preemptivos, mas não
com divisão de tempo
 Prioridade Thread

• Cada thread tem uma prioridade

• Quando uma thread é criada, ela
herda a prioridade da thread que o
criou
• Os valores de prioridade variam de 1 a
10, em prioridade crescente
 Thread Priority (cont.)

• A prioridade pode ser ajustada posteriormente

usando o método setPriority()
• A prioridade de uma thread pode ser obtida
usando getPriority()
• Constantes de prioridade são definidas:
– MIN_PRIORITY=1
– MAX_PRIORITY=10
– NORM_PRIORITY=5
 Curiosidade

• A implementação de thread em Java é

baseada no suporte do SO.
• Alguns SOs Windows suportam apenas 7
níveis de prioridade, portanto, diferentes
níveis em Java podem, na verdade, ser
mapeados para o mesmo nível de sistema
operacional
 Executor
• Framework utilizado para tarefas
concorrentes
• Executor executa Runnables, criando e
gerenciando um grupo de threads
denominado de pool de threads
• A interface executor declara um método
denominado execute que aceita Runnable
como argumento
 Executor
• Vantagens na reutilização de threads
existentes, eliminando sobrecarga ao criar
uma nova thread
• Melhora o desempenho otimizando o
número de threadsa fim de ocupar o
processador
public class PrintTask implements Runnable {
private static final SecureRandom generator = new SecureRandom();
private final int sleepTime; // tempo de adormecimento aleatório para a thread
private final String taskName;

// construtor
public PrintTask(String taskName)
{
this.taskName = taskName;
// seleciona tempo de adormecimento aleatório entre 0 e 5 segundos
sleepTime = generator.nextInt(5000); // milissegundos
}
// método run contém o código que uma thread executará
public void run(){
try // coloca a thread para dormir pela quantidade de tempo sleepTime
{
System.out.printf("%s indo dormir por %d milliseconds.%n",taskName, sleepTime);
Thread.sleep(sleepTime); // coloca a thread para dormir
}
catch (InterruptedException exception)
{
exception.printStackTrace();
Thread.currentThread().interrupt(); // reinterrompe a thread
}

// imprime o nome da tarefa

System.out.printf("%s acordada %n", taskName);
}
}
 InterruptedExceptions

• É uma boa prática permitir que thread

em execução trate a exceção
InterruptedExceptions
 ExecutorService

• Gerenciando threads com o método

Executors newCachedThreadPool para
obter um ExecutorService que é capaz
de criar novas threads, à medida que
são necessárias, pelo aplicativo.
• Essas threads são usadas pelo
ExecutorService para executar
Runnables.
public class Main {
public static void main (String [] args) {
PrintTask pt1 = new PrintTask("primeira");
PrintTask pt2 = new PrintTask("segunda");
PrintTask pt3 = new PrintTask("terceira");
System.out.println("Iniciando Executor");
ExecutorService executorService =Executors.newCachedThreadPool();
executorService.execute(pt1);
executorService.execute(pt2);
executorService.execute(pt3);
//fecha ExecutorService - ele decide quando fechar as threads
//parar de aceitar novas tarefas, mas continua executando as tarefas que já foram
submetidas.

executorService.shutdown();
System.out.println("Tarefas finalizadas");
}
}
 ExecutorService

• Repare que as threads terminam depois

da main.
• Apesar da main ter sido encerrada, ela
somente terminará após o final da
execução das threads
 ExecutorService

• Reparem nas ordens das threads

não podemos prever a ordem em que as
tarefas começarão a ser executadas,
mesmo se conhecermos a ordem em que
elas foram criadas e iniciadas.
 Threads Perigosa
• Veja o exemplo da thread perigosa
 Sincronização Threads

Threads que compartilham e modificam um

objeto (dados) pode ter resultados
indeterminados.
É necessário uma sincronização das threads
Somente uma thread por vez pode acessar
exclusivamente um objeto compartilhado.
 Sincronização Threads

Exclusão mútua permite que apenas uma

thread tenha acesso exclusivo a um
objeto compartilhado.
 Condição Corrida

Uma condição de corrida – o resultado de um

programa é afetado pela ordem em que os
threads do programa são alocados no tempo
de CPU
Dois threads estão modificando
simultaneamente um único objeto
Ambos os threads “correm” para armazenar
seu valor
 Exemplo Condição Corrida

Coloca peças
Como alternar Coloca peças
verdes as cores vermelhas
 Monitores

Cada objeto possui um “monitor” que é um token

usado para determinar qual thread do aplicativo
tem controle de uma instância específica do
objeto.
Na execução de um método (ou bloco)
sincronizado, o acesso ao monitor do objeto deve
ser obtido antes da execução
O acesso ao monitor de objetos é enfileirado
 Monitores

Monitores são predefinidos em Java para

garantir o sincronização.
Cada objeto tem um bloqueio de monitor (
bloqueio intrínseco)
Monitor garante que o bloqueio do seu
objeto é mantido por no máximo uma
única thread por vez.
 Monitores

Entrar em um monitor também é conhecido

como bloquear o monitor ou adquirir a
propriedade do monitor
Se um thread A tentar adquirir a
propriedade de um monitor e um thread
diferente já tiver entrado no monitor, o
thread atual (A) deverá esperar até que o
outro thread saia do monitor.
 Monitores

syncronized (objeto)
{

}
Objeto é o que deve ser bloqueado pelo
monitor. Normalmente é o this. Caso
haja vários
 Exemplo

public class ContaBancaria {

private float balanco;

public synchronized void deposita(float valor) {

balanco += valor;
}
public synchronized void saca(float valor) {
balanco -= valor;
}
}
t3 t2 t1 Seção Crítica

deposita()

Conta Bancária
 Deadlock
public class ContaBancaria {

private float balanco;

public synchronized void deposita(float valor) {

balance += valor;
}

public synchronized void saca (float valor) {

balance -= valor;
}
public synchronized void transfere(float valor,
ContaBancaria destino) {
saca(valor);
destino.deposita(valor);
}
}
public class Transferencia implements Runnable {

private ContaBancaria origem, destino;

private float valor;

public transfere(ContaBancaria origem, ContaBancaria

destino, float valor) {
this.origem = origem;
this.destino = destino
this.valor = valor;
}

public void run() {

origem.transfere(valor, destino);
}
}
ContaBancaria anton = new ContaBancaria();
ContaBancaria karl = new ContaBancaria();
...

// em algum lugar
Runnable transaction1 =
new Transferencia(anton, karl, 1200);
Thread t1 = new Thread(transaction1);
t1.start();

// em outro lugar
Runnable transaction2 =
new Transferencia(karl, anton, 700);
Thread t2 = new Thread(transaction2);
t2.start();
 Deadlocks
t1 t2

anton karl

transfere() transfere()

?
saca() saca()

deposita() deposita()
 Bloqueios Java são reentrantes

Qual é o problema com o código abaixo

public class Test {

public synchronized void a() {
b();
System.out.println(“Passando em a”);
}
public synchronized void b() {
System.out.println(“Passando em b”);
}
}
 Declarações Sincronizadas
Um monitor pode ser atribuído a um bloco
Pode ser usado para monitorar o acesso a um
elemento de dados que não é um objeto, por
exemplo, array
Exemplo:
void arrayShift(byte[] array, int count) {
synchronized(array) {
System.arraycopy (array, count,array, 0, array.size - count);
}
}
 Synchronization Thread

Precisamos sincronizar as transações, por

exemplo, o cenário consumidor-produtor
 Wait and Notify
Permite que duas threads cooperem
Baseado em um único objeto de bloqueio
compartilhado
 Marge colocou um cookie, espere e avise Homer
 Homer come um biscoito, espera e avisa Marge
 Marge colocou um cookie, espere e avise Homer
 Homer come um biscoito, espera e avisa Marge
 O método wait()

O método wait() faz parte da interface

java.lang.Object
Requer um bloqueio no monitor do objeto
para ser executado
 O método wait()

wait() faz com que o thread atual espere até

que outro thread invoque o método notify()
ou o método notifyAll() para este objeto
Ao chamar wait(), o thread libera a
propriedade deste monitor e espera até que
outro thread notifique as threads em
espera do objeto
 O método wait()

wait() também é semelhante a yield()

Ambos retiram a thread atual da pilha de
execução e forçam seu reagendamento
No entanto, wait() não é automaticamente
colocado de volta na fila do agendador
notify() deve ser chamado para colocar um thread
de volta na fila do agendador
 Consumidor

synchronized (lock) {
while (!resourceAvailable()) {
lock.wait();
}
consumeResource();
}
 Produtor

produceResource();
synchronized (lock) {
lock.notifyAll();
}
 Sequência Wait/Notify

Lock Object
1. synchronized(lock){ 3. produzRecurso()
2. lock.wait(); 4. synchronized(lock) {
5. lock.notify();
9. consomeRecurso();
6.}
10. } 7. Readquire lock
8. Retorna do wait()
Thread
Thread
Produtora
Consumidora
 Sequência Wait/Notify

Lock Object
1. synchronized(lock){ 3. produzRecurso()
2. lock.wait(); 4. synchronized(lock) {
5. lock.notify();
9. consomeRecurso();
10. } 6.}
7. Readquire lock
8. Retorna do wait()
Thread Thread
Consumidora Produtora
 Sequência Wait/Notify

Lock Object
1. synchronized(lock){ 3. produzRecurso()
2. lock.wait(); 4. synchronized(lock) {
9. consomeRecurso(); 5. lock.notify();
10. } 6.}
7. Readquire lock
8. Retorna do wait()
Thread Thread
Consumidora Produtora
 Sequência Wait/Notify

Lock Object
1. synchronized(lock){ 3. produceResource()
2. lock.wait(); 4. synchronized(lock) {
5. lock.notify();
9. consomeRecurso();
10. 6.}
10. }} 7. Readquire
Reacquire lock
8.
8. Retorna
Return from
do wait()
wait()

Thread Thread
Consumidora Produtora
 Sequência Wait/Notify

Lock Object
1. synchronized(lock){ 3. produceResource()
produzRecurso()
2. lock.wait();
lock.wait(); 4. synchronized(lock) {
5. lock.notify();
9. consomeRecurso();
consumeResource();
10. 6.}
10. }} 7. Readquire
Reacquire lock
8. Retorna
8. Return from wait()
do wait()
Thread Thread
Consumidora Produtora
 Sequência Wait/Notify

Lock Object
1. synchronized(lock){ 3. produceResource()
produzRecurso()
2. lock.wait();
lock.wait(); 4. synchronized(lock) {
5. lock.notify();
9. consomeRecurso();
consumeResource();
10. 6.}
10. }} 7. Readquire
Reacquire lock
8.
8. Retorna
Return from
do wait()
wait()

Thread Thread
Consumidora Produtora
 Sequência Wait/Notify

Lock Object
1. synchronized(lock){ 3. produceResource()
produzRecurso()
2. lock.wait();
lock.wait(); 4. synchronized(lock) {
5. lock.notify();
9. consomeRecurso();
consumeResource();
10. 6.}
10. }} 7. Readquire
Reacquire lock
8.
8. Retorna
Return from
do wait()
wait()

Thread Thread
Consumidora Produtora
 Sequência Wait/Notify

Lock Object
1. synchronized(lock){ 3. produceResource()
produzRecurso()
2. lock.wait();
lock.wait(); 4. synchronized(lock) {
5. lock.notify();
9. consomeRecurso();
consumeResource();
10. 6.}
10. }} 7. Reacquire lock
8.
8. Retorna
Return from
do wait()
wait()

Thread Thread
Consumidora Produtora
 Sequência Wait/Notify

Lock Object
1. synchronized(lock){ 3. produceResource()
produzRecurso()
2. lock.wait();
lock.wait(); 4. synchronized(lock) {
5. lock.notify();
9. consomeRecurso();
consumeResource();
10. 6.}
10. }} 7. Readquire
Reacquire lock
8. Return from wait()

Thread Thread
Consumidora Produtora
 Sequência Wait/Notify

Lock Object
1. synchronized(lock){ 3. produceResource()
produzRecurso()
2. lock.wait();
lock.wait(); 4. synchronized(lock) {
5. lock.notify();
9. consumeResource();
10. 6.}
10. }} 7. Readquire
Reacquire lock
8.
8. Retorna
Return from
do wait()
wait()

Thread Thread
Consumidora Produtora
 Sequência Wait/Notify

Lock Object
1. synchronized(lock){ 3. produceResource()
produzRecurso()
2. lock.wait();
lock.wait(); 4. synchronized(lock) {
5. lock.notify();
9. consomeRecurso();
consumeResource();
6.}
10. } 7. Readquire
Reacquire lock
8.
8. Retorna
Return from
do wait()
wait()

Thread Thread
Consumidora Produtora