Post on 07-Apr-2016
CURSO JAVA BÁSICO Módulo 9 – slide 1
Módulo 10Módulo 10
ThreadsThreads
CURSO JAVA BÁSICO Módulo 9 – slide 2
ObjetivosObjetivos• Definir thread;• Criar threads;• Controlar a execução da thread; • Conhecer o ciclo de vida de um thread;• Descrever as dificuldades que podem
ocorrer quando múltiplas threads compartilham dados;
• Usar wait and notify para comunicação entre threads;
• Usar synchronized para proteger dados contra corrupção.
CURSO JAVA BÁSICO Módulo 9 – slide 3
RelevânciaRelevância• Threads têm várias utilidades, especialmente
quando o uso de um recurso do programa pode demandar muito tempo e travar outras tarefas que estão aguardando, ou quando se precisa verificar a ocorrência de algum evento para efetuar alguma ação. (uma thread pode ficar dedicada a verificar periodicamente a ocorrência do evento).
• A aplicação mais usual é a interação com as interfaces gráficas (menus, botões) quando se quer obter resposta quase que imediata a uma ação.
CURSO JAVA BÁSICO Módulo 9 – slide 4
Processos X ThreadsProcessos X Threads• Processo programa em execução que
possui o seu próprio espaço de endereçamento.
– Um sistema operacional multitarefa é capaz de controlar a execução de mais de um processo ao mesmo tempo, de forma concorrente, fazendo a CPU alternar a execução das instruções de cada processo.
CURSO JAVA BÁSICO Módulo 9 – slide 5
Processos X ThreadsProcessos X Threads• Thread fluxo seqüencial de controle, ou
linha de execução, dentro de um processo ou programa.
– Um processo pode assim ter diversas threads executando concorrentemente, mas todas partilhando o mesmo espaço de endereçamento.
– Como não há necessidade de trocar de contexto, as threads representam uma forma mais leve de processamento concorrente.
CURSO JAVA BÁSICO Módulo 9 – slide 6
A classe ThreadA classe Thread• A Máquina Virtual Java permite que uma
aplicação tenha diversas linhas de execução rodando concorrentemente.
• Há sempre pelo menos uma thread, que roda o método main().
• Essa thread é criada automaticamente e outras podem ser criadas pelo programador.
CURSO JAVA BÁSICO Módulo 9 – slide 7
A classe ThreadA classe Thread• Em Java, cada thread é implementada como
um objeto, que deve ser uma instância de uma subclasse de java.lang.Thread criada para esse fim.
• Os comandos a serem executados em cada linha de execução serão sempre os comandos de um método de nome public void run().
• A classe Thread implementa a interface Runnable, que obriga a ter o método run().
CURSO JAVA BÁSICO Módulo 9 – slide 8
Threads – criandoThreads – criando• Há duas formas básicas para se criar uma
thread: A) Criar uma subclasse explícita de
java.lang.Thread e redefinir (sobrescrever) o método run(), contendo os comandos que a thread deverá executar. • Na própria classe Thread já existe um
método run() que não faz nada (não é abstrato, apenas não faz nada).
CURSO JAVA BÁSICO Módulo 9 – slide 9
Threads – criandoThreads – criando• Ex:
class MinhaThread extends Thread{ public void run(){ <instruções da thread>
}}
• A partir daí é possível criar quantas instâncias se desejar dessa classe.
• Cada vez que enviar a mensagem start() para uma instância, uma nova linha de execução será iniciada com os comandos do método run(), que rodará em paralelo com as outras threads:
CURSO JAVA BÁSICO Módulo 9 – slide 10
Threads – criandoThreads – criando
MinhaThread t = new MinhaThread();t.start();
• Não se pode enviar a mensagem run() diretamente para um objeto Thread.
• Envia-se a mensagem start(), que criará a thread onde rodarão os comandos do método run().
CURSO JAVA BÁSICO Módulo 9 – slide 11
Threads – criandoThreads – criando
ou, simplesmente:
new MinhaThread().start();
Obs: Threads podem ser criadas sem referência explícita, como na forma mais simples acima, sem risco de serem removidas pelo Garbage Collector (coletor de lixo da memória), pois possuem uma referência interna quepermanece até o método run() associado terminar.
CURSO JAVA BÁSICO Módulo 9 – slide 12
Threads – criandoThreads – criandoB) A segunda forma de se criar thread é
recomendada em situações onde queremos executar um método de uma classe qualquer em uma thread separada, sem que essa classe herde de Thread. • Se a classe já for uma subclasse de outra,
não poderia herdar também de Thread. • Nesse caso, fazemos a classe em questão
implementar a interface Runnable e colocamos no método public void run() os comandos que serão executados na thread.
CURSO JAVA BÁSICO Módulo 9 – slide 13
Threads – criandoThreads – criando• No exemplo abaixo, um método run() da
classe X será colocado em uma thread:
class MinhaClasse implements Runnable{ public void run(){ <instruções da thread> }..... outros métodos, construtores, atributos, etc}
CURSO JAVA BÁSICO Módulo 9 – slide 14
Threads – criandoThreads – criando• A seguir, em outro método, criamos uma
instância de MinhaClasse e passamos a instância como argumento do construtor da classe Thread:
MinhaClasse minhaClasse = new MinhaClasse();Thread t = new Thread(minhaClasse);
CURSO JAVA BÁSICO Módulo 9 – slide 15
Threads – criandoThreads – criando
CURSO JAVA BÁSICO Módulo 9 – slide 16
Threads – ciclo de vida básico Threads – ciclo de vida básico
CURSO JAVA BÁSICO Módulo 9 – slide 17
Threads – ciclo de vida básico - Threads – ciclo de vida básico - exemploexemplo
CURSO JAVA BÁSICO Módulo 9 – slide 18
Threads – terminandoThreads – terminando
CURSO JAVA BÁSICO Módulo 9 – slide 19
Threads – terminandoThreads – terminando
CURSO JAVA BÁSICO Módulo 9 – slide 20
Threads – controle básicoThreads – controle básico
CURSO JAVA BÁSICO Módulo 9 – slide 21
Threads – controle básicoThreads – controle básico• Nome da thread:
– Toda thread tem um nome (uma string) para poder ser identificada. O nome pode ser passado como um parâmetro do construtor, e pode ser recuperado enviando para a thread a mensagem getName().
– Se um nome não for especificado no construtor, um novo nome será gerado automaticamente para a thread.
• Como incluir o nome na chamada do construtor://subclasse explicita de Thread:Thread t1 = new MinhaThread("Thread 1");
CURSO JAVA BÁSICO Módulo 9 – slide 22
Threads – controle básicoThreads – controle básico• Prioridade:
– Cada thread possui uma prioridade. Threads com prioridades mais elevadas são executadas preferencialmente antes de threads com menor prioridade.
– A prioridade default é 5 (em uma escala de 1 a 10), mas pode ser alterada enviando a mensagem setPriority(int) para a thread.
CURSO JAVA BÁSICO Módulo 9 – slide 23
Threads – controle básicoThreads – controle básico• Prioridade:
– Na classe Thread existem as constantes static MAX_PRIORITY, MIN_PRIORITY e NORM_PRIORITY, com valores 10, 0 e 5, mas que podem variar dependendo da implementação.
– Quando existem diversas threads de mesma prioridade sendo executadas, a JVM aloca um tempo máximo para processar os comandos de cada uma, após o que interrompe a thread em execução e passa a processar os comandos da seguinte.
CURSO JAVA BÁSICO Módulo 9 – slide 24
Threads – o método yield()Threads – o método yield()• Cedendo o tempo de processamento para
outras threads:– Uma thread pode ceder o restante do
tempo de processamento alocado a ela, executando o comando yield().
– O controle passa para os comandos da próxima thread que estiver aguardando.
– Evita desperdiçar tempo de processamento.
CURSO JAVA BÁSICO Módulo 9 – slide 25
Threads – o método join( )Threads – o método join( )
CURSO JAVA BÁSICO Módulo 9 – slide 26
Threads – outra forma de criaçãoThreads – outra forma de criação
CURSO JAVA BÁSICO Módulo 9 – slide 27
Threads - Qual o melhor?Threads - Qual o melhor?• Implementar Runnable:
– Melhor design OO;– Mais consistente;
• Herdar de Thread:– Codificação mais simples;
CURSO JAVA BÁSICO Módulo 9 – slide 28
Threads - sincronizandoThreads - sincronizando
CURSO JAVA BÁSICO Módulo 9 – slide 29
Threads – flag de bloqueioThreads – flag de bloqueio
CURSO JAVA BÁSICO Módulo 9 – slide 30
Threads – flag de bloqueioThreads – flag de bloqueio
CURSO JAVA BÁSICO Módulo 9 – slide 31
Threads – flag de bloqueioThreads – flag de bloqueio
CURSO JAVA BÁSICO Módulo 9 – slide 32
Threads – liberando flag de bloqueioThreads – liberando flag de bloqueio
CURSO JAVA BÁSICO Módulo 9 – slide 33
Threads – sincronismoThreads – sincronismo
CURSO JAVA BÁSICO Módulo 9 – slide 34
Threads – sincronismoThreads – sincronismo
CURSO JAVA BÁSICO Módulo 9 – slide 35
Threads – ciclo de vida c/sincronismoThreads – ciclo de vida c/sincronismo
CURSO JAVA BÁSICO Módulo 9 – slide 36
Threads – deadlockThreads – deadlock
CURSO JAVA BÁSICO Módulo 9 – slide 37
Threads – interaçãoThreads – interação
CURSO JAVA BÁSICO Módulo 9 – slide 38
Threads – interaçãoThreads – interação
CURSO JAVA BÁSICO Módulo 9 – slide 39
Threads – ciclo de vida com interaçãoThreads – ciclo de vida com interação
CURSO JAVA BÁSICO Módulo 9 – slide 40
Threads - Monitorando o sincronismoThreads - Monitorando o sincronismo
Conhecido por modelo Produtor x Produtor x ConsumidorConsumidor
CURSO JAVA BÁSICO Módulo 9 – slide 41
Threads – a classe ProdutorThreads – a classe Produtor
CURSO JAVA BÁSICO Módulo 9 – slide 42
Threads – a classe ProdutorThreads – a classe Produtor
CURSO JAVA BÁSICO Módulo 9 – slide 43
Threads – a classe ConsumidorThreads – a classe Consumidor
CURSO JAVA BÁSICO Módulo 9 – slide 44
Threads – a classe ConsumidorThreads – a classe Consumidor
CURSO JAVA BÁSICO Módulo 9 – slide 45
Threads – a classe SyncStackThreads – a classe SyncStack
CURSO JAVA BÁSICO Módulo 9 – slide 46
Threads – a classe SyncTestThreads – a classe SyncTest
CURSO JAVA BÁSICO Módulo 9 – slide 47
Threads – a classe SyncTest - saídaThreads – a classe SyncTest - saída
A saída vai A saída vai depender depender da implementação da implementação da JVM.da JVM.