Concorrência em Java

Threads em Java

Máquina Virtual Java, Processos e Threads

– Cada instância da JVM corresponde a umprocesso do sistema operacional hospedeiro.

– A JVM não possui o conceito de processos –apenas implementa threads internamente.

Máquina Virtual Java, Processos e Threads

– Ao ser iniciada, a JVM executa o método main()do programa na thread principal, e novasthreads podem ser criadas a partir desta.

– Threads de uma mesma JVM compartilhammemória, portas de comunicação, arquivos eoutros recursos.

Prioridade de Threads

• Valor de 1 a 10; 5 é o default.• Threads herdam prioridade da thread que a

criou.• Modificada com setPriority(int) .• Obtida com getPriority() .

Prioridades de Threads

– 10 -> A -> B – 9 C– 8 – 7 D -> E -> F– 6 G– 5 H -> I – 4 – 3 – 2 -> J -> K– 1

Escalonamento de Threads

• Threads com prioridades iguais são escalonadas em round-robin (rodízio), com cada uma ativa durante um quantum.

Escalonamento Pré-Emptivo

• Threads de alta prioridade são executadas por um quantum, no esquema de rodízio até que as threads sejam concluídas.

Threads

• Implementação de Threads no Java– Green Threads• Usadas em sistemas sem suporte a threads.• Threads e escalonamento implementados pela máquina virtual Java.

– Threads Nativas• Usa threads nativas e escalonador do S.O.• Usada nos sistemas suportados oficialmente.

– Linux, Solaris e Windows

• Ideal em máquinas com >1 processador.

Ciclo de Vida de uma Thread

Estados das Threads em Java

• Nascimento• Pronta: poderia ser executada, mas o

processador está ocupado.

• Em execução: quando está rodando.

• Suspensa:– Bloqueada: aguarda operação de I/O.– Em Espera: aguarda alguma condição.– Dormindo: suspensa por um tempo de adormecimento.– Morta, quando é terminada.

Principais métodos de java.lang.Thread

• run() contém o código executado pela thread.

• start() dispara a execução de uma thread, que por sua vez chama o método run().

Outros métodos de java.lang.Thread

• setName: configura o nome de uma thread.• getName devolve o nome de uma thread.• currentThread() devolve uma referência da

thread em execução.• sleep() especifica quanto tempo a thread

deve dormir.• interrupt() interrompe uma thread.

Outros métodos de java.lang.Thread

• isInterrupted determina se a thread foi interrompida.

• isAlive() devolve true se a thread não estiver morta.

• join() espera que a thread para a qual uma msg foi enviada, morra antes que a thread chamadora possa prosseguir.

Outros métodos de java.lang.Thread

• wait a thread entra num estado de espera por um recurso/objeto particular para o qual o wait foi chamado.

• notify a thread em estado de espera torna-se pronta quando uma chamada notify é emitida por outra thread associada com aquele recurso/objeto.

• notifyAll todas as threads em estado de espera por um objeto tornam-se prontas quando notifyAll é feita por outra thread associada com aquele objeto.

Nome da Thread

• Identificador não-único da Thread.• Pode ser definido ao criar a Thread com Thread(String) ou Thread(Runnable, String)• Se não for definido na criação, o nome da Thread será “Thread-n” (com n incremental)• Pode ser redefinido com setName(String)• Pode ser obtido através do método getName()

Threads na Linguagem Java

• O conceito de thread está presente em Java através da classe java.lang.Thread .

• Java também oferece :– Mecanismos para sincronização e controle de concorrência entre threads (monitor,

semáforo e Locks).

Pool de Threads

– Quando um programa possui muitas threads para serem executadas, pode-se agrupar threads para definir o que se chama de um pool de threads.

– Java oferece classes e interfaces que facilitam o gerenciamento de um pool de threads.

– Classes para gerenciamento de um pool de threads, existem e exemplos podem ser vistos em Deitel , Ed.6, Cap. 23, exemplos 25-4 e 23-5.

Gerenciando um Pool de Threads

• java.lang.Object java.util.concurrent.Executors

• A classe Executors estende a classe raiz Object.

• A classe Executors gerencia um grupo de threads.

– Interface Executor– Interface ExecutorService

Interfaces e Classes para Gerenciar Pools de Threads

• interface Runnable, para construir threads. • interface Executor

• classe Executors (com s no final é uma classe).

• interface ExecutorService, para gerenciar threads através de seu método execute.

Interface Executor

• public interface Executor

• Uma interface com operações para criar um objeto que executa tarefas submetidas via interface Runnable.

• Esta interface provê um modo de desacoplar submissão de tarefa, do mecanismo de como cada tarefa será executada, incluindo detalhes do uso de threads, scheduling e outras coisas.

Interface Executor

• Uma interface Executor é normalmente usada, ao invés de explicitamente criar threads.

• java.util.concurrent.Executor

• ExecutorService é sub-interface de Executor.

Classe Executors

• java.lang.Object java.util.concurrent.Executors

• public class Executors extends Object

• Executors contém métodos que criam e retornam um ExecutorService .

Interface ExecutorService

• public interface ExecutorService extends Executor

• Para usar pools de threads, instancie uma implementação da interface ExecutorService e entregue tarefas para execução.

Interface ExecutorService

• As implementações de ExecutorService permitem que você estabeleça: – O número máximo do pool (número de threads).– O tipo de estrutura de dados para armazenar as

tarefas.– Como criar e terminar threads. – Como tratar tarefas rejeitadas, quando o número

de tarefas é maior que o número de threads no Pool de Threads.

Interface ExecutorService

• Especificamos o número de tarefas ("worker threads“) a criar e o tamanho do pool de threads usados para executar as tarefas.

Pool de tamanho fixo

• Um pool pode usar um número fixo de threads.

• newFixedThreadPool(int) Cria um pool com número fixo de threads dado por int e uma fila ilimitada de tarefas.

Fixando número de threads

// cria ExecutorService para gerenciar threads

ExecutorService threadExecutor = Executors.newFixedThreadPool(3);

Threads sob Demanda

newCachedThreadPool()

• Cria um pool de threads sem limite, com recuperação automática de threads (threads que já terminaram as tarefas são reutilizados para novas tarefas e novos threads são criados só se não houver thread "velha" disponível).

• É uma boa opção quando há muitas tarefas pequenas a executar assincronamente.

• Threads não usados por 60 segundos são removidos

Pool de Threads

• Outro caso, por exemplo, pode usar um número fixo de threads, com menos threads do que tarefas.

• Pool de Threads