View
221
Download
0
Category
Preview:
Citation preview
ThreadsCapítulo 8
Threads Introdução Criando e
executando threads A classe
java.lang.Thread A interface
java.lang.Runnable Estados da thread
O Scheduler Prioridades das
threads Interação entre
threads Sincronização Bloqueios Deadlock
2
Introdução às threads Uma thread representa uma linha de
execução de sua aplicação Java, onde as instruções são executadas uma por vez.
Quando executamos uma aplicação Java, o JVM dá início à thread raiz da aplicação através do método main()
3
Introdução às threads
main()
metodo1()
metodo2()
metodoN()
...()
4
Programação multithreaded Através do uso de múltiplas threads
podemos realizar o processamento simultâneo de partes diferentes de sua aplicação.
O desenvolvimento de aplicações que possuem múltiplas threads é chamada programação multithreaded ou programação concorrente.
5
Programação multithreaded
main()
run()
x()
y()
z()
b()
c()
run()
m()
run()
k()d() n()
a()
6
Criando e executando threads Forma 1
Uma das formas mais simples de criar e executar uma nova thread é através da classe java.lang.Thread:
1. Crie uma nova classe derivada (filha) da classe java.lang.Thread e sobrescreva o método run() inserindo as instruções a serem executadas pela nova thread
2. A partir de sua aplicação principal crie uma instância desta classe thread e execute o seu método start()
7
Criando e executando threads Forma 1
public class MinhaThread extends Thread {public void run() {
...
... <instruções da thread secundária>}
}
public class Principal {public static void main(String[] args) {
Thread t = new MinhaThread();t.start();...... <demais instruções da thread
principal>}
} 8
Criando e executando threads
main()
demais instruções da
thread principal
9
run()
instruções da thread
secundária
t.start()
t
Criando e executando threads Forma 2
Uma outra forma de criar e executar uma nova thread é através da interface java.lang.Runnable:
1. Crie uma nova classe que implementa a interface java.lang.Runnable e implemente o método run() inserindo as instruções a serem executadas pela nova thread
2. A partir de sua aplicação principal crie uma instância da classe java.lang.Thread passando em seu método construtor uma instância de sua classe de sua classe thread e então execute o seu método start() da thread
10
Criando e executando threads Forma 2
public class MinhaThread implements Runnable {public void run() {
...
...}
}
public class Principal {public static void main(String[] args) {
Thread t = new Thread(new MinhaThread());
t.start();......
}} 11
Prioridade da thread Toda thread possui uma prioridade.
A prioridade de uma thread é um número inteiro entre 1 e 10.
Quanto maior a prioridade da thread, maior será sua preferência de execução sobre as outras.
Caso a prioridade da thread não seja assinalada, esta possuirá o valor padrão 5.
A prioridade de uma thread pode ser alterada mesmo após o início de sua execução.
12
Prioridade da threadThread t1 = new MinhaThread();Thread t2 = new MinhaThread();Thread t3 = new MinhaThread();Thread t4 = new MinhaThread();Thread t5 = new MinhaThread();
t1.setPriority(2);t2.setPriority(8);t3.setPriority(Thread.MAX_PRIORITY); // Prioridade 10t4.setPriority(Thread.MIN_PRIORITY); // Prioridade 1t5.setPriority(Thread.NORM_PRIORITY); // Prioridade 5
t1.start();t2.start();t3.start();t4.start();t5.start();
13
Nome da thread Toda thread possui um nome.
O nome de uma thread é um simples String que pode ser assinalado para identificação da thread.
Útil em aplicações que possuem logs onde deseja-se traçar passo-a-passo as operações realizadas pela aplicação.
Thread t1 = new MinhaThread();t1.setName(“Thread auxiliar”);
14
Thread atual A qualquer momento durante a execução de sua
aplicação, podemos obter os dados da thread atual através do método estático currentThread().
...
...Thread t = Thread.currentThread();System.out.println(“Informações sobre a thread atual:”);System.out.println(“Nome: ” + t.getName());System.out.println(“Prioridade: ” + t.getPriority());......
15
Estados da thread
16
Executando
Pronta paraser executada
Dormindo BloqueadaEsperando
Morta
Nova
Estados da thread Nova (NEW)
Uma thread nova é uma thread que já foi instanciada, mais ainda não foi iniciada pelo método start().
17
Pronta paraser executada
Nova
t.start()
Estados da thread Pronta para ser executada
(RUNNABLE)
Uma thread fica pronta para ser executada tão logo seu método start() seja chamado.
Lá ela ficará aguardando até que o JVM tenha oportunidade de executá-la
18
Executando
Pronta paraser executada
t.start()
Nova
Estados da thread Executando (RUNNING)
Durante a sua execução, uma thread pode ser momentanea-mente pausada cedendo sua vez para outras threads.
Esta pausa pode ser realizada por decisão do JVM ou por solicitação da própria thread que pode “ceder” sua vez através do método estático yeld()
19
Executando
Pronta paraser executada
Thread.yeld()
Estados da thread Morta (TERMINATED)
Uma thread é considerada morta quando o seu processamento já foi executado pelo JVM.
Instâncias de threads mortas não podem ser reexecutadas. Caso seja necessário uma nova execução, crie uma nova instância da thread.
20
Executando
Morta
Estados da thread Dormindo
(TIMED_WAITING)
Uma thread pode ser colocada para “dormir” através do método estático sleep() que faz com que a thread atual fique inativa durante o tempo solicitado.
Após o tempo (especificado em milissegundos), a thread atual volta ao estado “Pronta para ser executada” aguardando sua nova oportunidade de execução.
21
Executando
Pronta paraser executada
Dormindo
Thread.sleep(millis)
Estados da thread Esperando (WAITING)
Podemos colocar a thread atual em modo de espera através do método join().
Este método faz com que a thread atual aguarde até que uma outra thread seja terminada.
22
Executando
Pronta paraser executada
Esperando
outraThread.join()
Estados da thread Bloqueada (BLOCKED)
Uma thread “A” adquire o estado bloqueado quando tenta executar um trecho de código sincronizado cujo lock do objeto proprietário está detido em uma outra thread “B”.
Quando a thread “B” que detém o lock encerra a execução do bloco, libera o bloqueio da thread “A” tornando-a novamente “pronta para execução”
23
Executando
Pronta paraser executada
Bloqueada
Sincronização Um dos perigos da programação
concorrente é o acesso e manipulação simultânea da mesma informação por diferentes threads.
Blocos de código que são processados simultaneamente por duas ou mais threads podem gerar dados inconsistentes ou corrompidos.
24
Sincronização – Classe exemplo
public class ContadorAcessos {......public int contarAcessos() {
int qtd = lerQtdAcessos();qtd++;gravarQtdAcessos(qtd);return qtd;
}......
}
25
Sincronização – Acesso simples
26
t1heap
ContadorAcessos obj = ..... ;int x = obj.contarAcessos();
obj46
int qtd = lerQtdAcessos();qtd++;gravarQtdAcessos(qtd);return qtd;
metodoX()
contarAcessos()
47
Sincronização – Acesso simultâneo
27
t2
ContadorAcessos obj = ... ;int y = obj.contarAcessos();
t1heap
ContadorAcessos obj = ... ;int x = obj.contarAcessos();
obj47
int qtd = lerQtdAcessos();qtd++;gravarQtdAcessos(qtd);return qtd;
int qtd = lerQtdAcessos();qtd++;gravarQtdAcessos(qtd);return qtd;
metodoX()
contarAcessos()
metodoY()
contarAcessos()
48
Contagem corrompida
Sincronização por métodopublic class ContadorAcessos {
...
...public synchronized int contarAcessos() {
int qtd = lerQtdAcessos();qtd++;gravarQtdAcessos(qtd);return qtd;
}......
}
28
Sincronização por método
29
t2
ContadorAcessos obj = ... ;int y = obj.contarAcessos();
t1heap
ContadorAcessos obj = ... ;int x = obj.contarAcessos();
obj47
int qtd = lerQtdAcessos();qtd++;gravarQtdAcessos(qtd);return qtd;
int qtd = lerQtdAcessos();qtd++;gravarQtdAcessos(qtd);return qtd;
metodoX()
contarAcessos()
metodoY()
contarAcessos()
4849
Sincronização por método A sincronização geralmente é utilizada em
diversos métodos da mesma classe:
public class Vector {public synchronized boolean add(Object e) {
...}public synchronized Object remove(int
index) {...
}public synchronized Object get(int index) {
...}...
} 30
Classes que se preocupam com sincronização e acesso simultâneo de seus membros são
chamadas “thread safe”
Sincronização por bloco Podemos também realizar a sincronização de
apenas um trecho do código.
public class ContadorAcessos {...public int contarAcessos() {
...
...synchronized(obj) {
...}...
}...
}31
Sincronização por blocopublic synchronized void algumMetodo() {
...
...}
public void algumMetodo() {synchronized(this) {
...
...}
}
32
... é o mesmo que ...
Interação entre threadspublic class Conta {
...public synchronized void retirar(double valor) {
while (this.saldo < valor) {wait();
}this.saldo -= valor;
}
public synchronized void depositar(double valor) {
this.saldo += valor;notify();
}...
}33
Bloqueia a thread correntepermitindo que outras threads
acessem blocos sincronizados.
Desbloqueia outras threads queexecutaram o método wait() sobre
esta instância (this).
Interação entre threads Sincronização por método
public synchronized ... metodo1(...) {...wait();...
}
public synchronized ... metodo2(...) {...notify();...
}
Sincronização por bloco
synchronized (obj) {...obj.wait();...
}
synchronized (obj) {...obj.notify();...
}
34
mesmo objeto
Interação entre threads wait()
Bloqueia a thread atual até que o objeto de lock seja notificado.
wait(long millis)Bloqueia a thread atual por, no máximo, millis milissegundos até que o objeto de lock seja notificado.
wait(long millis, int nanos)Bloqueia a thread atual por, no máximo, millis milissegundos e nanos nanossegundos até que o objeto de lock seja notificado.
notify()Notifica uma das threads bloqueadas pelo wait() sobre o objeto de lock liberando-a para prosseguir sua execução.
notifyAll()Notifica todas as threads bloqueadas pelo wait() sobre o objeto de lock liberando-as para prosseguir em suas respectivas execuções.
35
Deadlock Chamamos de deadlock a um tipo específico de
bug na aplicação onde duas threads são mutuamente dependentes e ficam uma aguardando a outra.
Esta situação pode ocorrer mediante o uso dos métodos Thread.join() ou Object.wait()
36
DeadlockThread thread1 = new Thread() {
public void run() {System.out.println(“Aguardando thread
2...”);thread2.join();System.out.println(“Thread 1
encerrada.”);}
};
Thread thread2 = new Thread() {public void run() {
System.out.println(“Aguardando thread 1...”);
thread1.join();System.out.println(“Thread 2
encerrada.”);}
};
....thread1.start();thread2.start();
37
Deadlock Situações de deadlock podem ser difíceis de ser
encontradas na aplicação.
Ao utilizar interação entre threads em sua aplicação, é necessária uma análise detalhada para evitar este tipo de problema.
38
Recommended