Sistemas Operacionais
Threads em Java
Prof. Dr. Paulo Ricardo Muniz Barros
paulobarros@feevale.br
Threads em Java
❑ Threads, também chamados de processos leves, permitem
múltiplas atividades dentro de um único processo;
❑ Um mesmo processo pode conter múltiplas threads que parecem
executar ao mesmo tempo;
❑ Java é a primeira linguagem de programação a incluir o conceito de
threads na própria linguagem.
Threads em Java
Razões para utilizarmos threads :
❑ Maior desempenho em ambientes multiprocessados;
❑ Responsividade em interfaces gráficas;
❑ Simplificação na modelagem de algumas aplicações.
Criando Threads
Há duas formas de criarmos uma thread em Java:
❑ Através da herança da classe Thread
❑ Através da implementação da interface Runnable
Criando uma subclasse de
Thread
A maneira mais simples de criar uma thread em Java é criando uma
subclasse de Thread e implementando o que a thread vai fazer
sobrecarregando o método run.
Implementando a Interface
Runnable
• A outra forma de criar threads em Java é implementando a
interface Runnable e implementando o método run definido
nessa interface.
• Sendo que a classe que implementa a thread deve declarar um
objeto do tipo Thread e para instanciá-lo deve chamar o
construtor da classe Thread passando como parâmetro a
instância da própria classe que implementa Runnable e o nome
da thread.
Implementando a Interface
Runnable
• Como o objeto do tipo Thread é local a classe que vai
implementar thread, e normalmente privado, há a necessidade
de criação de um método start para permitir a execução do
objeto thread local.
• O mesmo deve ser feito para qualquer outro método da classe
Thread que dever ser visto ou usado fora da classe que
implementa Runnable.
Implementando a Interface
Runnable
Escolhendo...
• O principal fator para escolha entre um dos dois
métodos, é que Java não permite herança múltipla,
quando uma classe que já for sub-classe de outra, e
precisar implementar thread é obrigatório que isso
seja feito através da implementação da interface
Runnable, caso contrário pode-se utilizar sub-classes
da classe Thread.
Ciclo de vida
Criando Threads
Através da chamado ao seu construtor colocando a
thread no estado Nova (thread vazia). Neste estado a única
operação que pode ser realizada é a inicialização dessa thread
através do método start().
Fazendo Thread Esperar
Uma thread irá para o estado Esperando quando :
• O método sleep (faz a thread esperar por um determinada tempo) for chamado;
• O método wait (faz a thread esperar por uma determinada condição) for chamado;
• Quando realizar solicitação de I/O.
Quando um thread for para estado Esperando ela retornará ao estado Pronta
quando a condição que a levou ao estado Esperando for atendida :
• Se a thread solicitou dormir por determinado intervalo de tempo (sleep);
• Se a thread solicitou esperar por determinado evento (wait), assim que esse evento ocorrer
(outra thread chamar notify ou notifyAll);
• Se a thread realizou solicitação de I/O, assim que essa solicitação for atendida.
Finalizando Threads
Uma Thread é finalizada quando acabar a execução do seu
método run, e então ela vai para o estado Morta, onde o Sistema
de Execução Java poderá liberar seus recursos e eliminá-la .
Verificando Estados
A classe Thread possui o método isAlive, o qual permite verificar se
está nos estado Executando/Pronta/Esperando ou nos estados Nova/Morta.
Quando o retorno do método for true a thread esta participando do
processo de escalonamento e o retorno for false a thread está fora do
processo de escalonamento. Não é possível diferenciar entre Executando,
Pronta ou Esperando, assim também como não é possível diferenciar entre
Nova ou Morta.
Escalonamento de Threads
O escalonamento é fundamental para execução paralela de threads,
onde os processadores disponíveis são alternados pelas diversas threads em
execução. O mecanismo de escalonamento utilizado pelo Sistema de
Execução Java é bastante simples e determinístico, e utiliza um algoritmo
conhecido como Escalonamento com Prioridades Fixas, o qual escalona
threads baseado na sua prioridade.
.
Escalonamento de Threads
As threads escalonáveis são aquelas que estão nos estados Executando
ou Pronta, para isso toda thread possui uma prioridade, a qual pode ser um
valor inteiro no intervalo [MIN_PRIORITY a MAX_PRIORITY], (estas são
constantes definidas na classe Thread), e quanto maior o valor do inteiro maior a
prioridade da thread. Cada thread Nova recebe a mesma prioridade da thread
que a criou e a prioridade de uma thread pode ser alterada através do método
setPriority(int priority).
Escalonamento de Threads
O algoritmo de escalonamento com Prioridades Fixas :
• Quando várias threads estiverem Prontas, a com maior prioridade será
executada.
• Várias threads com prioridades iguais, as mesmas serão escalonadas
segundo o algoritmo Round-Robin de escalonamento.
Escalonamento de Threads
O algoritmo de escalonamento com Prioridades Fixas (Cont):
• Uma thread será executada até que : uma outra thread de maior
prioridade fique Pronta; acontecer um dos eventos que a faça ir para o
estado Esperando; o método run acabar; ou em sistema que possuam
fatias de tempo a sua fatia de tempo se esgotar.
• Threads com prioridades mais baixas terão direito garantido de serem
executadas para que situações de starvation não ocorram.
Tutorial Threads
https://docs.oracle.com/javase/tutorial/essential/concurrency/threads.html
