Capítulo 8 Threads

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

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()

Introdução às threads metodoN() ...() metodo2() metodo1() main()

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.

Programação multithreaded z() d() n() k() y() c() m() run() x() b() run() run() a() main()

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: 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 A partir de sua aplicação principal crie uma instância desta classe thread e execute o seu método start()

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>

Criando e executando threads demais instruções da thread principal instruções da thread secundária run() t.start() main()

Criando e executando threads Forma 2 Uma outra forma de criar e executar uma nova thread é através da interface java.lang.Runnable: 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 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

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();

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.

Prioridade da thread Thread 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 10 t4.setPriority(Thread.MIN_PRIORITY); // Prioridade 1 t5.setPriority(Thread.NORM_PRIORITY); // Prioridade 5 t1.start(); t2.start(); t3.start(); t4.start(); t5.start();

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”);

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());

Estados da thread Nova Pronta para ser executada Dormindo Esperando Bloqueada Executando Morta

Estados da thread Nova (NEW) Uma thread nova é uma thread que já foi instanciada, mais ainda não foi iniciada pelo método start(). t.start() Pronta para ser executada

Estados da thread Pronta para ser executada (RUNNABLE) Nova 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 t.start() Pronta para ser executada Executando

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() Pronta para ser executada Thread.yeld() Executando

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. 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. Pronta para ser executada Dormindo Executando 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. Pronta para ser executada Esperando Executando 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” Pronta para ser executada Bloqueada Executando

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.

Sincronização – Classe exemplo public class ContadorAcessos { ... public int contarAcessos() { int qtd = lerQtdAcessos(); qtd++; gravarQtdAcessos(qtd); return qtd; }

Sincronização – Acesso simples contarAcessos() int qtd = lerQtdAcessos(); qtd++; gravarQtdAcessos(qtd); return qtd; metodoX() ContadorAcessos obj = ..... ; int x = obj.contarAcessos(); 47 46 obj t1 heap

Sincronização – Acesso simultâneo contarAcessos() contarAcessos() int qtd = lerQtdAcessos(); qtd++; gravarQtdAcessos(qtd); return qtd; int qtd = lerQtdAcessos(); qtd++; gravarQtdAcessos(qtd); return qtd; metodoX() metodoY() ContadorAcessos obj = ... ; int x = obj.contarAcessos(); ContadorAcessos obj = ... ; int y = obj.contarAcessos(); 48 47 obj t1 Contagem corrompida t2 heap

Sincronização por método public class ContadorAcessos { ... public synchronized int contarAcessos() { int qtd = lerQtdAcessos(); qtd++; gravarQtdAcessos(qtd); return qtd; }

Sincronização por método contarAcessos() contarAcessos() int qtd = lerQtdAcessos(); qtd++; gravarQtdAcessos(qtd); return qtd; int qtd = lerQtdAcessos(); qtd++; gravarQtdAcessos(qtd); return qtd; metodoX() metodoY() ContadorAcessos obj = ... ; int x = obj.contarAcessos(); ContadorAcessos obj = ... ; int y = obj.contarAcessos(); 49 48 47 obj t1 t2 heap

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) { 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) { }

Sincronização por bloco public synchronized void algumMetodo() { ... } ... é o mesmo que ... public void algumMetodo() { synchronized(this) { ... }

Interação entre threads public 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(); Bloqueia a thread corrente permitindo que outras threads acessem blocos sincronizados. Desbloqueia outras threads que executaram 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(); } obj.notify(); 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.

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()

Deadlock Thread thread1 = new Thread() { public void run() { System.out.println(“Aguardando thread 2...”); thread2.join(); System.out.println(“Thread 1 encerrada.”); } }; Thread thread2 = new Thread() { System.out.println(“Aguardando thread 1...”); thread1.join(); System.out.println(“Thread 2 encerrada.”); .... thread1.start(); thread2.start();

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.