CURSO JAVA BÁSICO Módulo 9 – slide 1 Módulo 10 Threads

CURSO JAVA BÁSICO Módulo 9 – slide 1

Módulo 10Módulo 10

ThreadsThreads


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.


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.


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.


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.


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.


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


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


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:


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



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.


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.


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}


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




Threads – ciclo de vida básico Threads – ciclo de vida básico


Threads – ciclo de vida básico - Threads – ciclo de vida básico - exemploexemplo


Threads – terminandoThreads – terminando


Threads – terminandoThreads – terminando


Threads – controle básicoThreads – controle básico


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


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.


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.


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.


Threads – o método join( )Threads – o método join( )


Threads – outra forma de criaçãoThreads – outra forma de criação


Threads - Qual o melhor?Threads - Qual o melhor?• Implementar Runnable:

– Melhor design OO;– Mais consistente;

• Herdar de Thread:– Codificação mais simples;


Threads - sincronizandoThreads - sincronizando


Threads – flag de bloqueioThreads – flag de bloqueio






Threads – liberando flag de bloqueioThreads – liberando flag de bloqueio


Threads – sincronismoThreads – sincronismo


Threads – sincronismoThreads – sincronismo


Threads – ciclo de vida c/sincronismoThreads – ciclo de vida c/sincronismo


Threads – deadlockThreads – deadlock


Threads – interaçãoThreads – interação


Threads – interaçãoThreads – interação


Threads – ciclo de vida com interaçãoThreads – ciclo de vida com interação


Threads - Monitorando o sincronismoThreads - Monitorando o sincronismo

Conhecido por modelo Produtor x Produtor x ConsumidorConsumidor


Threads – a classe ProdutorThreads – a classe Produtor


Threads – a classe ProdutorThreads – a classe Produtor


Threads – a classe ConsumidorThreads – a classe Consumidor


Threads – a classe ConsumidorThreads – a classe Consumidor


Threads – a classe SyncStackThreads – a classe SyncStack


Threads – a classe SyncTestThreads – a classe SyncTest


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.

Documents

CURSO JAVA BÁSICO Módulo 9 – slide 1 Módulo 10 Threads