A apresentação está carregando. Por favor, espere

A apresentação está carregando. Por favor, espere

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

Apresentações semelhantes


Apresentação em tema: "CURSO JAVA BÁSICO Módulo 9 – slide 1 Módulo 10 Threads."— Transcrição da apresentação:

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

2 CURSO JAVA BÁSICO Módulo 9 – slide 2 Objetivos 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.

3 CURSO JAVA BÁSICO Módulo 9 – slide 3 Relevâ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.

4 CURSO JAVA BÁSICO Módulo 9 – slide 4 Processos 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.

5 CURSO JAVA BÁSICO Módulo 9 – slide 5 Processos 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.

6 CURSO JAVA BÁSICO Módulo 9 – slide 6 A 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.

7 CURSO JAVA BÁSICO Módulo 9 – slide 7 A 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().

8 CURSO JAVA BÁSICO Módulo 9 – slide 8 Threads – 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).

9 CURSO JAVA BÁSICO Módulo 9 – slide 9 Threads – criando Ex: class MinhaThread extends Thread{ public void run(){ } 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:

10 CURSO JAVA BÁSICO Módulo 9 – slide 10 Threads – 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().

11 CURSO JAVA BÁSICO Módulo 9 – slide 11 Threads – 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 que permanece até o método run() associado terminar.

12 CURSO JAVA BÁSICO Módulo 9 – slide 12 Threads – criando B) 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.

13 CURSO JAVA BÁSICO Módulo 9 – slide 13 Threads – criando No exemplo abaixo, um método run() da classe X será colocado em uma thread: class MinhaClasse implements Runnable{ public void run(){ }..... outros métodos, construtores, atributos, etc }

14 CURSO JAVA BÁSICO Módulo 9 – slide 14 Threads – 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);

15 CURSO JAVA BÁSICO Módulo 9 – slide 15 Threads – criando

16 CURSO JAVA BÁSICO Módulo 9 – slide 16 Threads – ciclo de vida básico

17 CURSO JAVA BÁSICO Módulo 9 – slide 17 Threads – ciclo de vida básico - exemplo

18 CURSO JAVA BÁSICO Módulo 9 – slide 18 Threads – terminando

19 CURSO JAVA BÁSICO Módulo 9 – slide 19 Threads – terminando

20 CURSO JAVA BÁSICO Módulo 9 – slide 20 Threads – controle básico

21 CURSO JAVA BÁSICO Módulo 9 – slide 21 Threads – 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");

22 CURSO JAVA BÁSICO Módulo 9 – slide 22 Threads – 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.

23 CURSO JAVA BÁSICO Módulo 9 – slide 23 Threads – 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.

24 CURSO JAVA BÁSICO Módulo 9 – slide 24 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.

25 CURSO JAVA BÁSICO Módulo 9 – slide 25 Threads – o método join( )

26 CURSO JAVA BÁSICO Módulo 9 – slide 26 Threads – outra forma de criação

27 CURSO JAVA BÁSICO Módulo 9 – slide 27 Threads - Qual o melhor? Implementar Runnable: – Melhor design OO; – Mais consistente; Herdar de Thread: – Codificação mais simples;

28 CURSO JAVA BÁSICO Módulo 9 – slide 28 Threads - sincronizando

29 CURSO JAVA BÁSICO Módulo 9 – slide 29 Threads – flag de bloqueio

30 CURSO JAVA BÁSICO Módulo 9 – slide 30 Threads – flag de bloqueio

31 CURSO JAVA BÁSICO Módulo 9 – slide 31 Threads – flag de bloqueio

32 CURSO JAVA BÁSICO Módulo 9 – slide 32 Threads – liberando flag de bloqueio

33 CURSO JAVA BÁSICO Módulo 9 – slide 33 Threads – sincronismo

34 CURSO JAVA BÁSICO Módulo 9 – slide 34 Threads – sincronismo

35 CURSO JAVA BÁSICO Módulo 9 – slide 35 Threads – ciclo de vida c/sincronismo

36 CURSO JAVA BÁSICO Módulo 9 – slide 36 Threads – deadlock

37 CURSO JAVA BÁSICO Módulo 9 – slide 37 Threads – interação

38 CURSO JAVA BÁSICO Módulo 9 – slide 38 Threads – interação

39 CURSO JAVA BÁSICO Módulo 9 – slide 39 Threads – ciclo de vida com interação

40 CURSO JAVA BÁSICO Módulo 9 – slide 40 Threads - Monitorando o sincronismo Produtor x Consumidor Conhecido por modelo Produtor x Consumidor

41 CURSO JAVA BÁSICO Módulo 9 – slide 41 Threads – a classe Produtor

42 CURSO JAVA BÁSICO Módulo 9 – slide 42 Threads – a classe Produtor

43 CURSO JAVA BÁSICO Módulo 9 – slide 43 Threads – a classe Consumidor

44 CURSO JAVA BÁSICO Módulo 9 – slide 44 Threads – a classe Consumidor

45 CURSO JAVA BÁSICO Módulo 9 – slide 45 Threads – a classe SyncStack

46 CURSO JAVA BÁSICO Módulo 9 – slide 46 Threads – a classe SyncTest

47 CURSO JAVA BÁSICO Módulo 9 – slide 47 Threads – a classe SyncTest - saída A saída vai depender da implementação da JVM.


Carregar ppt "CURSO JAVA BÁSICO Módulo 9 – slide 1 Módulo 10 Threads."

Apresentações semelhantes


Anúncios Google