1. Novo: Um t h r e a d está neste estado q u a n d o um o b j e t o para o t h r e a d é c r i a d o (ou seja, a i n s t r u ç ã o new( ) ) .
2. Executável: C h a m a r o m é t o d o s t a r t ( ) aloca m e m ó r i a para o n o v o t h r e a d n a J V M e c h a m a o m é t o d o r u n ( ) para o o b j e t o t h r e a d . Q u a n d o o m é t o d o r u n ( ) de um t h r e a d é c h a m a d o , o t h r e a d passa do es- t a d o N o v o para o estado Executável. U m t h r e a d n o estado Executável p o d e ser e x e c u t a d o pela J V M . Observe que Java não faz distinção e n t r e um t h r e a d que é passível de execução e um t h r e a d que está sendo e x e c u t a d o n o m o m e n t o pela J V M . U m t h r e a d e m execução a i n d a está n o estado Executável.
Thrcads • 91 3. Bloqueado: Um thrcad torna-sc Bloqueado se executar uma instrução bloqueante, como ao realizar
uma operação de I/O ou se chamar certos métodos Thread Java, como sleepí ) ou suspend( ). 4. Terminado: Um thread passa para o estado terminado quando seu método run( ) termina ou quando
o método stop( ) é chamado.
Não é possível definir o estado exato de um thread, embora o método isAlive( ) retorne um valor hoo- leano que um programa pode usar para determinar se um thread está ou não no estado terminado. A Figura 5.10 ilustra os diferentes estados de um thread c identifica várias transições possíveis.
novo
Figura 5.10 Estados de um thread Java.
5.6.4ThreadseaJVM
Além de um programa Java que contém vários thrcads de controle distintos, existem muitos threads execu- tando assincronamente para a JVM que tratam de tarefas ao nível de sistema, tais como gerência de memória e controles gráficos. Esses threads incluem um thread de coleta de lixo, que avalia os objetos na JVM para ve- rificar se ainda estão em uso. Se não estiverem, ele devolve a memória para o sistema. Dentre os outros thre- ads está um que trata eventos de temporização, tais como chamadas ao método sleepí )> um que trata even- tos dos controles gráficos, tais como pressionar um botão, e um que atualiza a tela. Assim, uma aplicação Java típica contém vários threads de controle diferentes na JVM. Certos threads são criados explicitamente pelo programa; outros threads são tarefas de nível de sistema executando em nome da JVM.
5.6.5 A J V M c o s i s t e m a o p e r a c i o n a l host
A implementação típica da JVM normalmente é feita sobre um sistema operacional host. Essa configuração permite que a JVM oculte os detalhes da implementação do sistema operacional subjacente e forneça um am- biente consistente e abstraio que permite aos programas Java operar em qualquer plataforma que suporte uma JVM. A especificação da JVM não indica como os threads Java serão mapeados no sistema operacional subjacente, deixando essa decisão para cada implementação particular da JVM. Em geral, um thread Java é considerado um thread de usuário, e a JVM é responsável pela gerência de threads. O Windows NT utiliza o modelo um-para-unv, portanto, cada thread Java para uma JVM executando no NT émapeado em um thread de kcrnel. O Solaris 2 inicialmente implementou a JVM usando o modelo muitos-para-um (chamado threads
verdes pela Sun). No entanto, já na Versão 1.1 da JVM com o Solaris 2.6, a JVM foi implementada usando o
modelo muitos-para-muitos.
5.6.6 E x e m p l o d e s o l u ç ã o c o m multithread
Nesta seção, apresentamos uma solução completa com multithread para o problema do produ- tor^consumidor que utiliza troca de mensagens. A classe Server na Figura 5.11 primeiro cria uma caixa de torreio para servir de buffer de mensagens, usando a classe MessageQueue desenvolvida no Capítulo 4. Em seguida, ela cria threads separados de produtor e consumidor (Figuras 5.12 e 5.13, respectivamente) e passa a cada thread uma referência à caixa de correio compartilhada. O thread produtor alterna entre o estado suspenso, a produção de um item e a inserção desse item na caixa de correio. O consumidor alter-
na vntre o estado suspenso c a busca de um item da caixa de correio, consumindo-o. Como o método r e - ceive( ) da classe MessageQueueé não-bloqueante, o consumidor deve verificar se a mensagem recupera- da é nula.
92 • Sistemas Operacionais
public class Server
I
public Server( ) {
/ / p r i m e i r o c r i a o buffer de mensagens HessageQueue mailBox • new MessageQueue{ ); //agora c r i a os threads de produtor e consumidor Producer producerThread • new Producer(mailBox); Consumer consumerlhread • new Consumer(mailBox); producerThread.start( );
consumerThread.starl( );
»
public s t a t i c void main(StrÍng args[ J) (
Server server - new Server( J;
I
public s t a t i c f i n a l i n t NAP_T1HE • 5; )
F i g u r a 5 . 1 1 A classe Server. imoort j a v a . u t i l . " ;
c l í s s Producer extends Thread <
public Producer(HessageQueue m) ( mbox - m;
I
public void run( ) { Date message; while (true) { i n t sleeptime » ( i n t ) (Server.NAP_TIME * Hath.random( ) ); System.out.printlnfProducer sleeping f o r * + sleeptime + • seconds"); t r y { Thread.sleep(sleeptime-lOOO); ) catch{InterruptedException e) { ) //produz um item e o insere //no buffer
message • new Date( );
System.out.println{"Producer produced • + message);
mbox.send(message);
I
í
private MessageQueue mbox; )
F i g u r a 5.12 T h r e a d d o p r o d u t o r .
5.7 • Resumo
Um thread é um fluxo de controle cm um processo. Um processo multilliread contém vários fluxos de con- trole distintos no mesmo espaço de endereçamento. Os benefícios do multithreading incluem maior capaci- dade de resposta ao usuário, compartilhamento de recursos no processo, economia c capacidade de aprovei-
Threads • 93 lar as arquiteturas com múltiplos processadores. Os rhrcads de usuário são threads visíveis ao programador e desconhecidos do kernel. Alem disso, geralmente são gerenciados por uma biblioteca de threads no espaço de usuário. Os threads de kernel são suportados e gerenciados por uma kernel do sistema operacional. Em geral, os threads de usuário são mais rápidos de criar e gerenciar do que os threads de kernel. Existem três ti- pos diferentes de modelos relacionados os threads de usuário aos de kernel: o modelo muitos-para-um ma- peia muitos threads de usuário em uni único thread de kernel. O modelo um-para-um mapeia cada thread de usuário em um thread de kernel correspondente. O modelo muitos-para-muitos multiplexa muitos threads de usuário em um número menor ou igual de threads de kernel.
Java é notável por fornecer suporte para threads DO nível da linguagem. Todos os programas Java consis- tem em pelo menos um thread de controle, sendo fácil criar vários threads de controle no mesmo programa. Java tamhcm fornece um conjunto de APIs para gerenciar threads, incluindo métodos para suspender e reto-
mar threads, suspender um thread por determinado período de tempo e interromper um thread cm execu- ção. Um thread Java também pode estar em um de quatro estados possíveis: Novo, Executável, Bloqueado c Terminado. As diferentes APIs para gerenciar threads geralmente mudam o estado do thread. Apresentamos como exemplo uma solução Java com multithread ao problema do produtor-consumidor.
import java.util.-;
class Consumer extends Thread (
public Consumer(MessageQueue m) | mbox = m;
)
public void run( ) ( Date message; whilç (true) (
int sleeptime • (int) (Server.NAPJIHE * Math.random( ) ) ; System.out.println("Consumer sleeping for • +
sleeptime * " seconds"); try (
Thread.sleep(sleeptime*1000); í
catch(InterruptetlException e) { ) //consome um item do buffer message • (Date)mbox.receive( );
í
if (message !• null)
System.out.println("Consumer consumed " * message);
I
private MessageQueue mbox;
í
Figura 5.13 Thread do consumidor.