Threads Aracaju

Threads em Java

Universidade Federal da Paraba

Mestrado em Informtica

Fora de Sede

Universidade Tiradentes

Aracaju - Sergipe

Disciplina

Sistemas Operacionais

Professor

Jacques Philippe Sauv

Aluno

Jos Maria Rodrigues Santos Jnior

Monografia

Threads em Java

Aracaju 08 de maro de 2000

3O que Thread ?

3Definio de Processo

3Definio de Thread

4Paralelismo x Concorrncia

4Thread em Java

6Criando Threads em Java

6Implementando o Comportamento de uma Thread

6Criando uma subclasse de Thread

6Exemplo de criao de threads estendendo a classe Thread

7Implementando a Interface Runnable

7Exemplo de thread implementando a interface Runnable

7Escolhendo entre os dois mtodos de criao de threads

8Um exemplo mais interessante de threads em Java

9Resultado da Execuo Corrida de Sapos

10O ciclo de vida de uma Thread

11Criando Threads

11Iniciando Threads

11Fazendo Thread Esperar

11Finalizando Threads

11Verificando se Threads esto Executando/Pronta/Esperando ou Novas/Mortas

12Threads Daemon

12Escalonamento de Threads

13Exemplo de aplicao usando threads com diferentes prioridades

14Sincronizando Threads (Concorrncia)

14Implementando Excluso Mtua de Regies Crticas

14Comunicao Entre Threads

15Evitando Starvation e Deadlock

16Agrupando Threads

16O Grupo Padro de Threads

16Criando Grupos de Threads e Inserindo Threads

16Operaes sobre Grupos de Threads

17O Exemplo Produtor/Consumidor ou Buffer Limitado

23Resultado da Execuo Produtor/Consumidor

24O Exemplo do Jantar dos Filsofos Glutes

29Resultado da Execuo Jantar do Filsofos Glutes

30Bibliografia

30Fontes de Pesquisa

Threads em Java

O que Thread ?

O conceito de thread est intimamente ligado ao conceito de processo, assim fundamental entender o que so processos, como eles so representados e colocados em execuo pelo Sistema Operacional, para em seguida entender as threads. Dessa forma segue uma breve definio de Processo e posteriormente a de Thread.

Definio de Processo

Um processo basicamente um programa em execuo, sendo constitudo do cdigo executvel, dos dados referentes ao cdigo, da pilha de execuo, do valor do contador de programa (registrador PC), do valor do apontador do apontador de pilha (registrador SP), dos valores dos demais registradores do hardware, alm de um conjunto de outras informaes necessrias execuo dos programas. Tanenbaum

Podemos resumir a definio de processo dizendo que o mesmo formado pelo seu espao de endereamento lgico e pela sua entrada na tabela de processos do Sistema Operacional. Assim um processo pode ser visto como uma unidade de processamento passvel de ser executado em um computador e essas informaes sobre processos so necessrias para permitir que vrios processos possam compartilhar o mesmo processador com o objetivo de simular paralelismo na execuo de tais processos atravs da tcnica de escalonamento, ou seja, os processos se revezam (o sistema operacional responsvel por esse revezamento) no uso do processador e para permitir esse revezamento ser necessrio salvar o contexto do processo que vai ser retirado do processador para que futuramente o mesmo possa continuar sua execuo.

Definio de Thread

Thread, ou processo leve, a unidade bsica de utilizao da CPU, consistindo de : contador de programa, conjunto de registradores e uma pilha de execuo. Thread so estruturas de execuo pertencentes a um processo e assim compartilham os segmentos de cdigo e dados e os recursos alocados ao sistema operacional pelo processo. O conjunto de threads de um processo chamado de Task e um processo tradicional possui uma Task com apenas uma thread. SilberschatzO conceito de thread foi criado com dois objetivos principais : Facilidade de comunicao entre unidades de execuo e reduo do esforo para manuteno dessas unidades. Isso foi conseguido atravs da criao dessas unidades dentro de processos, fazendo com que todo o esforo para criao de um processo, manuteno do Espao de endereamento lgico e PCB, fosse aproveitado por vrias unidades processveis, conseguindo tambm facilidade na comunicao entre essas unidades.

Dessa forma o escalonamento de threads de um mesmo processo ser facilitado pois a troca de contexto entre as threads exigir um esforo bem menor. Sendo que ainda assim, ocorrer o escalonamento de processos, pois outros processos podero estar sendo executado paralelamente ao processo que possui as threads. Podemos concluir ento que a real vantagem obtida no escalonamento de threads de um mesmo processo e na facilidade de comunicao entre essas threads.

Paralelismo x Concorrncia

Threads podem executar suas funes de forma paralela ou concorrente, onde quando as threads so paralelas elas desempenham o seus papeis independente uma das outras. J na execuo concorrente, as threads atuam sobre objetos compartilhados de forma simbitica necessitando de sincronismo no acesso a esses objetos, assim deve ser garantido o direito de atomicidade e excluso mtua nas operaes das threads sobre objetos compartilhados.

Thread em Java

Todo programador est familiarizado com a programao sequencial, pois sem dvida at o presente momento esta a forma de programao mais comum. Programas do tipo Hello World, ou que ordenam uma lista de nome, ou que gera e imprime uma lista de nmeros primos, etc so programas tipicamente sequenciais, onde cada um possui : seu incio, sequncia de execuo e fim e em qualquer momento da sua execuo estes programas possuem apenas um ponto de execuo.

Uma thread similar ao programas sequenciais, pois possui um incio, sequncia de execuo e um fim e em qualquer momento uma thread possui um nico ponto de execuo. Contudo, uma thread no um programa, ela no pode ser executada sozinha e sim inserida no contexto de uma aplicao, onde essa aplicao sim, possuir vrios pontos de execues distintos, cada um representado por uma thread. A figura abaixo descreve esse mecanismo de funcionamento da thread dentro de um programa em execuo.

Definio : Uma thread representa um fluxo de controle de execuo dentro de um programa

No h nada de novo nesse conceito de processo com uma nica thread, pois o mesmo idntico ao conceito tradicional de processo. O grande benefcio no uso de thread quando temos vrias thread num mesmo processo sendo executadas simultaneamente e podendo realizar tarefas diferentes. A figura abaixo representa um processo com mltiplas threads (Programao Multi-Thread.)

Definio : Com mltiplas theads um programa possui mltiplos pontos de execuo

Dessa forma podemos perceber facilmente que aplicaes multithreads podem realizar tarefas distintas ao mesmo tempo, dando idia de paralelismo. Veja um exemplo do navegador web HotJava, o qual consegue carregar e executar applets, executar uma animao, tocar um som, exibir diversas figuras, permitir rolagem da tela, carregar uma nova pgina, etc e para o usurio todas essas atividades so simultneas, mesmo possuindo um nico processador. Isso possvel, por que dentro da aplicao do navegador HotJava vrias threads foram executadas, provavelmente, uma para cada tarefa a ser realizada.

Alguns autores tratam threads como processos leves. Uma thread similar a um processo no sentido que ambos representam um nico fluxo de controle de execuo, sendo considerada um processo leve por ser executada dentro do contexto de um processo e usufruir dos recursos alocados pelo processo. Cada thread necessita possuir apenas as informaes (contador de programa e pilha de execuo) necessrias a sua execuo, compartilhando todo o contexto de execuo do processo com todas a demais threads do mesmo processo.

A linguagem Java possui apenas alguns mecanismos e classes desenhadas com a finalidade de permitir a programao Multi-Thread, o que torna extremamente fcil implementar aplicaes Multi-Threads, sendo esses :

A classe java.lang.Thread utilizada para criar, iniciar e controlar Threads;

As palavras reservadas synchronized e volatile usadas para controlar a execuo de cdigo em objetos compartilhados por mltiplas threads, permitindo excluso mtua entre estas;

Os mtodos wait, notify and notifyAll definidos em java.lang.Object usados para coordenar as atividades das threads, permitindo comunicao entre estas.

Criando Threads em Java

A criao de threads em java uma atividade extremamente simples e existem duas formas distintas de faz-lo: uma atravs da herana da classe Thread, outra atravs da implementao da interface Runnable, e em ambos os casos a funcionalidade (programao) das threads feita na implementao do mtodo run.

Implementando o Comportamento de uma Thread

O mtodo run contm o que a thread faz, ele representa o comportamento (implementao) da thread, como um mtodo qualquer podendo fazer qualquer coisa que a linguagem Java permita. A classe Thread implementa uma thread genrica que por padro no faz nada, contendo um mtodo run vazio, definindo assim uma API que permite a um objeto runnable prover uma implementao para o mtodo run de uma thread.

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 mtodo run.

Exemplo de criao de threads estendendo a classe Thread/** Criao de NovaThread atravs da herana da classe Thread */public class NovaThread extends Thread {

/** Construtor de NovaThread*/

public NovaThread (String threadName) {

/* construtor de Thread passando o nome da Thread como parmetro */

super(threadName);

}

/** mtodo run o qual representa o comportamento de NovaThread */

public void run () {

/* Implementao do comportamento da thread */

}

}Implementando a Interface RunnableA outra forma de criar threads em Java implementando a interface Runnable e implementando o mtodo 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 parmetro a instncia da prpria classe que implementa Runnable e o nome da thread. Como o objeto do tipo Thread local a classe que vai implementar thread, e normalmente privado, h a necessidade de criao de um mtodo start para permitir a execuo do objeto thread local. O mesmo deve ser feito para qualquer outro mtodo da classe Thread que dever ser visto ou usado fora da classe que implementa Runnable.

Exemplo de thread implementando a interface Runnable/** Criao de NovaThread atravs da implementao da Interface Runnable */public class NovaThread implements Runnable {

/* Objeto local do tipo Thread*/

private Thread thread = null;

/* Construtor da classe */

public NovaThread (String threadName) {

/* Caso o objeto thread local no tiver sido criado ainda */

if (thread == null) {

/* A mesma deve ser instanciada com o nome recebido no construtor

* Detalhe importante que uma instncia da prpria classe (this)

* tambm passada ao construtor da classe Thread permitindo assim

* a associao do mtodo run com a thread

*/

thread = new Thread(this, threadName);

}

}

/* Mtodo para iniciar o objeto thread local */

public void start() {

thread.start();

}


/* Comportamento da thead */

}

}Escolhendo entre os dois mtodos de criao de threads

O principal fator a ser levado em considerao na escolha entre um dos dois mtodos de criao de thread que a linguagem Java no permite herana mltipla, assim quando uma classe que j for sub-classe de outra precisar implementar thread obrigatrio que isso seja feito atravs da implementao da interface Runnable, caso contrrio pode-se utilizar sub-classes da classe Thread. Um exemplo claro desse fator de escolha na implementao de Applet as quais obrigatoriamente devem ser sub-classes da classe Applet, assim applets s podem implementar threads atravs da implementao da interface Runnable.

Um exemplo mais interessante de threads em Java

Simulao de uma Corridas de Sapos, onde cada sapo na corrida representado por uma thread.

/* Aplicao que simula uma corrida de sapos usando threads */public class CorridaDeSapos {

final static int NUM_SAPOS = 5;// QTE. de sapos na corrida

final static int DISTANCIA = 500; // Distncia da corrida em cm

public static void main (String[] args) {

/* colocando sapos na corrida */

for (int i = 1; i distanciaTotalCorrida) {

distanciaCorrida = distanciaTotalCorrida;

}

}

/** Representando o descanso do sapo */

public void sapoDescansando () {

/* Mtodo que passa vez a outras threads */

yield();

}

/** Imprime a colocao do sapo ao final da corrida */

public void colocacaoSapo () {

colocacao++;

System.out.println(nome + " foi o " + colocacao +

" colocado com " + pulos + " pulos");

}

/** Mtodo run da thread Corrida de Sapos */


while (distanciaCorrida < distanciaTotalCorrida) {

sapoPulando();

sapoImprimindoSituacao();

sapoDescansando();

}

colocacaoSapo();

}

}

Resultado da Execuo Corrida de Sapos

O SAPO_01 pulou 21cm e j percorreu 21cm



































SAPO_03 foi o 1 colocado com 7 pulos










O ciclo de vida de uma Thread

A melhor forma de analisar o ciclo de vida de uma thread atravs das operaes que podem ser feitas sobre as mesmas, tais como : criar, iniciar, esperar, parar e encerrar. O diagrama abaixo ilustra os estados os quais uma thread pode assumir durante o seu ciclo de vida e quais mtodos ou situaes levam a estes estados.

Ciclo de vida de uma thread

(Nova/Executando/Pronta/Esperando/Morta)

Criando Threads

A criao de uma thread feita atravs da chamado ao seu construtor colocando a thread no estado Nova, o qual representa uma thread vazia, ou seja, nenhum recurso do sistema foi alocado para ela ainda. Quando uma thread est nesse estado a nica operao que pode ser realizada a inicializao dessa thread atravs do mtodo start(), se qualquer outro mtodo for chamado com a thread no estado Nova ir acontecer uma exceo (IllegalThreadStateException), assim como, quando qualquer mtodo for chamado e sua ao no for condizente com o estado atual da thread.

Iniciando Threads

A inicializao de uma thread feita atravs do mtodo start() e nesse momento os recursos necessrios para execuo da mesma so alocados, tais como recursos para execuo, escalonamento e chamada do mtodo run da thread. Aps a chamada ao mtodo start a thread est pronta para ser executada e ser assim que for possvel, at l ficar no estado Pronta. Essa mudana de estado (Pronta/Executando) ser feito pelo escalonador do Sistema de Execuo Java. O importante saber que a thread est pronta para executar e a mesma ser executada, mais cedo ou mais tarde de acordo com os critrios, algoritmo, de escalonamento do Sistema de Execuo Java.

Fazendo Thread Esperar

Uma thread ir para o estado Esperando quando :

O mtodo sleep (faz a thread esperar por um determinada tempo) for chamado;

O mtodo wait (faz a thread esperar por uma determinada condio) for chamado;

Quando realizar solicitao de I/O.

Quando um thread for para estado Esperando ela retornar ao estado Pronta quando a condio que a levou ao estado Esperando for atendida, ou seja :

Se a thread solicitou dormir por determinado intervalo de tempo (sleep), assim que este intervalo de tempo for decorrido;

Se a thread solicitou esperar por determinado evento (wait), assim que esse evento ocorrer (outra thread chamar notify ou notifyAll);

Se a thread realizou solicitao de I/O, assim que essa solicitao for atendida.

Finalizando Threads

Uma Thread finalizada quando acabar a execuo do seu mtodo run, e ento ela vai para o estado Morta, onde o Sistema de Execuo Java poder liberar seus recursos e elimin-la .

Verificando se Threads esto Executando/Pronta/Esperando ou Novas/Mortas

A classe Thread possui o mtodo isAlive, o qual permite verificar se uma thread est nos estado Executando/Pronta/Esperando ou nos estados Nova/Morta. Quando o retorno do mtodo for true a thread esta participando do processo de escalonamento e o retorno for false a thread est fora do processo de escalonamento. No possvel diferenciar entre Executando, Pronta ou Esperando, assim tambm como no possvel diferenciar entre Nova ou Morta.

Threads Daemon

So threads que rodam em background e realizam tarefas de limpeza ou manuteno, as quais devem rodar enquanto a aplicao estiver em execuo, as threads daemons somente morrerem quando a aplicao for encerrada. Sendo que o Sistema de Execuo Java identifica que uma aplicao acabou quando todas as suas threads esto morta, assim para que seja possvel que uma aplicao seja encerrada ainda possuindo threads, tais threads devem ser daemon. Em outras palavras, o Sistema de Execuo Java ir terminar uma aplicao quando todas as suas threads no daemon morrerem. Threads daemons so denominadas de Threads de Servio e as no daemon so denominadas de Threads de Usurio.

Os mtodos para manipulao de threads daemon so:

public final void setDaemon(boolean)Torna ou no uma thread daemon

public final boolean isDaemon()Verifica se uma thread daemon

Escalonamento de Threads

O escalonamento fundamental quando possvel a execuo paralela de threads, pois, certamente existiro mais threads a serem executadas que processadores, assim a execuo paralela de threads simulada atravs de mecanismos do escalonamento dessas threads, onde os processadores disponveis so alternados pelas diversas threads em execuo. O mecanismo de escalonamento utilizado pelo Sistema de Execuo Java bastante simples e determinstico, e utiliza um algoritmo conhecido como Escalonamento com Prioridades Fixas, o qual escalona threads baseado na sua prioridade. As threads escalonveis so aquelas que esto nos estados Executando ou Pronta, para isso toda thread possui uma prioridade, a qual pode ser um valor inteiro no intervalo [MIN_PRIORITY ... MAX_PRIORITY], (estas so 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 atravs do mtodo setPriority(int priority).

O algoritmo de escalonamento com Prioridades Fixas utilizado pela Sistema de Execuo Java funcionada da seguinte forma :

1. Quando vrias threads estiverem Prontas, aquela que tiver a maior prioridade ser executada.

2. Quando existir vrias threads com prioridades iguais, as mesmas sero escalonadas segundo o algoritmo Round-Robin de escalonamento.

3. Uma thread ser executada at que : uma outra thread de maior prioridade fique Pronta; acontecer um dos eventos que a faa ir para o estado Esperando; o mtodo run acabar; ou em sistema que possuam fatias de tempo a sua fatia de tempo se esgotar.

4. Threads com prioridades mais baixas tero direito garantido de serem executadas para que situaes de starvation no ocorram.

Exemplo de aplicao usando threads com diferentes prioridades

Observe que essa corrida no justa pois os sapos 4 e 5 possuem prioridades mximas e com certeza ganharo a corrida.

/* Aplicao que simula uma corrida de sapos usando threads */public class CorridaDeSapos {

final static int NUM_SAPOS = 5;

// QTE. de sapos na corrida

final static int DISTANCIA = 500; // Distncia da corrida em cm


/* Criando as threads para representar os sapos correndo */

SapoCorrendoThread sapo_1 = new SapoCorrendoThread("SAPO_01", DISTANCIA);





/* Estabelecendo prioridades para as threads */

sapo_1.setPriority(Thread.MIN_PRIORITY);

sapo_2.setPriority(Thread.MIN_PRIORITY);

sapo_3.setPriority(Thread.NORM_PRIORITY);

sapo_4.setPriority(Thread.MAX_PRIORITY);

sapo_5.setPriority(Thread.MAX_PRIORITY);

/* Iniciando as threads */

sapo_1.start();

sapo_2.start();

sapo_3.start();

sapo_4.start();

sapo_5.start();

}

}

Sincronizando Threads (Concorrncia)

At o momento temos abordado threads como unidades de processamento independentes, onde cada uma realiza a sua tarefa sem se preocupar com o que as outras threads esto fazendo (paralelimos), ou seja, abordamos threads trabalhando de forma assncrona e embora a utilizao de threads dessa maneira j seja de grande utilidade, muitas vezes precisamos que um grupo de threads trabalhem em conjunto e agindo sobre objetos compartilhados, onde vrias threads desse conjunto podem acessar e realizar operaes distintas sobre esses objetos, sendo que, muitas vezes a tarefa de uma thread vai depender da tarefa de outra thread, dessa forma as threads tero que trabalhar de forma coordenada e simbitica, ou seja, dever haver uma sincronizao entre as threads para que problemas potenciais advindos do acesso simultneo a esses objetos compartilhado no ocorram.

Esses problemas so conhecidos como condies de corrida (Race Conditions) e os trechos de cdigos, das threads, que podem gerar condies de corrida so chamados de regies crticas (critical sections), assim as condies de corridas podem ser evitadas atravs da excluso mtua das regies crticas das threads e sincronizao entre as threads envolvidas.

O mecanismo para prover excluso mtua entre threads em Java bastante simples, necessitando apenas da declarao dos mtodos que contm regies crticas como synchronized. Isso garante que quando uma das threads estiver executando uma regio crtica em um objeto compartilhado nenhuma outra poder faz-lo. Ou seja, quando uma classe possuir mtodos sincronizados, apenas um deles poder estar sendo executado por uma thread.

Implementando Excluso Mtua de Regies Crticas

A sincronizao entre threads, que acessam concorrentemente um mesmo objeto compartilhado, feita da seguinte forma : a classe do objeto compartilhado deve possuir mtodos que realizem as operaes de interesse das threads que o acessam e esses mtodos devem ser declarados como synchronized, garantido que somente uma thread por vez poder executar um desses mtodos. Assim fcil perceber que o mecanismo descrito acima fornece, de forma simples, a excluso mtua de regies crticas a qual garantida pelo Sistema de Execuo Java. Fazendo uma relao com a teoria de Sistemas Operacionais a linguagem de programao Java fornece um MONITOR, onde o Compilador e o Sistema de Execuo garantem a excluso mtua e sincronia, provendo assim um mecanismo de alto nvel para facilitar a criao de aplicaes Multi-Threads.

Comunicao Entre Threads

Um outro aspecto muito importante na implementao de threads que trabalham concorrentemente sobre um objeto compartilhado que muitas vezes a atividade de uma thread depende da atividade de outra thread, assim necessrio que as threads troquem mensagem afim de avisarem umas as outras quando suas tarefas forem concludas ou quando precisam esperar por tarefas de outras. Em Java isso feito atravs dos mtodos wait, notify, notifyAll, onde :

waitFaz a thread esperar (coloca no estado Esperando) em um objeto compartilhado, at que outra thread a notifique ou determinado intervalo de tempo seja decorrido.

notifyNotifica (retira do estado Esperando) uma thread que esta esperando em um objeto compartilhado.

notifyAllNotifica todas as threads que esto esperando em um objeto compartilhado, onde uma delas ser escalonada para usar o objeto e as outras voltaro ao estado Esperando.

Observao : Esses mtodos devem ser usados na implementao das operaes dos objetos sincronizados, ou seja, nos mtodos synchronized dos objetos sincronizados. Pois s faz sentido uma thread notificar ou esperar por outra em objetos sincronizados e o Sistema de Execuo Java tem mecanismos para saber qual thread ir esperar ou receber a notificao, pois somente uma thread por vez pode estar executando um mtodo sincronizado de um objeto compartilhado.

Evitando Starvation e Deadlock

Com a programao concorrente de diversas threads que trabalham em conjunto e acessam objetos compartilhados surge o risco potencial de Starvation e Deadlock, onde Starvation acontece quando uma thread fica esperando por um objeto que nunca lhe ser concedido e o Deadlock quando duas ou mais threads esperam, de forma circular, por objetos compartilhados e nenhuma delas ser atendida pelo fato de esperar umas pelas outras.

Na programao Java Starvation e Deadlock devem ser evitados pelo controle lgico de acesso aos objetos compartilhados, fazendo com que o programador deva identificar situao que possam gerar Starvation e Deadlock e evit-las de alguma forma e com certeza essa a tarefa mais desafiadora e trabalhosa na programao concorrente.

Agrupando Threads

Toda thread Java membro de um grupo . Grupo de threads um mecanismo para agrupar vrias threads em um nico objeto e permitir realizar operaes sobre todas elas mais facilmente. O Sistema de Execuo Java coloca threads em grupos no momento da sua criao. Quando uma thread criada a mesma colocada num grupo padro pelo Sistema de Execuo Java ou o grupo pode ser especificado pelo programador. Uma vez criada, a thread membro permanente do seu grupo e a mesma no pode ser movida para outro grupo.

O Grupo Padro de Threads

Quando uma thread criada sem a especificao de um grupo no seu construtor, o Sistema de Execuo Java a coloca no mesmo grupo da thread que a criou. Quando uma thread for criada em uma aplicao sem a especificao de um grupo a mesma ser colocada no grupo padro main o qual criado na inicializao da aplicao pelo Sistema de Execuo Java.

muito comum que o programa no se preocupe com grupos no uso de threads em Java deixando que o Sistema de Execuo Java faa a tarefa de agrupar as threads. Mas, quando uma aplicao for trabalhar com diversas threads mais conveniente agrup-las, pois algumas operaes devero ser feitas sobre todas as threads e a criao de grupos de threads ir facilitar tais operaes.

Criando Grupos de Threads e Inserindo Threads

A criao de um grupo de threads feita atravs do construtor da classe ThreadGroup, onde basta informar o nome do grupo :

GroupThread grupoDeThreads = new GroupThread(Nome Grupo de Threads)

A colocao de threads em grupos realizada no momento da sua criao para isso, existem trs construtores onde possvel informar o grupo ao qual a thread deve ser inserida.

public Thread(ThreadGroup group, Runnable runnable)

public Thread(ThreadGroup group, String name)

public Thread(ThreadGroup group, Runnable runnable, String name)

Operaes sobre Grupos de Threads

As principais operaes que podem ser realizadas sobre grupos de threads so :

MtodoDescrio

getName()Retorna o nome do grupo

toString()Retorna uma representao do grupo em string

list()Imprime informaes sobre o grupo no dispositivo padro de sada

O Exemplo Produtor/Consumidor ou Buffer Limitado

/**

* @author Jos Maria Rodrigues Santos Junior

* [email protected] / http://www.unit.br/zemaria

*

* Aplicao para simular o problema clssico Produtor/Consumidor

* de comunicao entre processos usando threads em Java

*/class ProdutorConsumidor {


/* Criando o Buffer Limitado */

BufferLimitado buffer = new BufferLimitado();

/* Quantidade de itens a serem produzidos/consumidos pelas threads */

final int QUANT_ITENS = 10;

/* Quantidade de threads */

final int QUANT_THREADS = 5;

/* Criando os grupos de threads Produtoras/Consumidoras */

ThreadGroup threadsProdutoras = new ThreadGroup("Produtores");

ThreadGroup threadsConsumidoras = new ThreadGroup("Consumidores");

/* Criando e iniciando e inserindo nos grupos as threads Produtoras */

for (int i = 1; i

Documents

Threads Aracaju