ThreadGroup

Não use o ThreadGroup. Péssima idéia. A classe ThreadGroup é famosa por dar problemas. Se for no Java 5, use um ExecutorService.

É muito fácil, primeiro você cria um executor service:

ExecutorServices threadPool = Executors.newCachedThreadPool();

Além do CachedThreadPool a classe Executors também te dá a possibilidade de criar Pools de tamanho fixo, tamanho único ou "agendáveis". Escolha o mais adequado para você.

Depois, você usa o seu ExecutorService para disparar os seus Runnables:

Future&lt?&gt result = threadPool.submit(seuRunnable);

Se suas Threads retornam algum valor, considere usar um Callable ao invés de um Runnable. Basicamente, um Callable é um Runnable que retorna valor.

O que é aquele objeto Future retornado? Ele vai guardar o resultado da sua operação futura. A grande vantagem é que ele possui o método get() que espera até que a Thread obtenha o resultado do Callable (ou finalize o método run()).

Portanto, para esperar sua Thread terminar, basta fazer:
result.get();

Quando você terminar (ou quiser terminar) um ExecutorService usa o método shutdown(). Ele proibirá novas Threads de entrarem no Pool e aguardará pacificamente que as demais Threads sejam finalizadas.

Se sua intenção é chamar o interrupt() de todas as Threads, além de finalizar o Pool, use shutdownNow() ao invés de shutDown().

Fiz esse exemplinho com o uso do ExecutorService, Callable e Future.

Experimente depois alterar o código para calcular 10 primos (pode ser primos pequenos, anteriores ao milésimo), mas troque o ThreadPool para um FixedThreadPool de apenas 3 threads. Veja como o programa se comporta, é bastante interessante!

Tomara que ajude!

OU valeu pela ajuda ou dar uma estuda nisso que eu preciso disso o mais rápido possível, agora me responde uma coisa, tipo eu queria fazer uma esquema que cada nova thread criada fosse agenda numa fila de espera, tipo igual fila de supermercado, que chega primeiro sai primeiro, dessa maneira que você me falou tem como fazer isso???/

Valeu e obrigado pela atenção.

Não entendi. O que você quer dizer com Threads numa fila de espera?

As Threads rodam juntas, em paralelo. Você pode não disparar as Threads, ou usar um ThreadGroup de tamanho fíxo (de 1 ou 2), por exemplo. Aí vc vai rodar uma Thread de cada vez.

Agora, uma vez que estão todas rodando juntas, não tem como dizer quem vai executar. Use como regra que elas sempre estão rodando ao mesmo tempo.

Cara eu até concordo com você sobre isso mas é que meu caso é um seguinte, tipo para cada produto que eu vendo no caixa eu mando pra impressora, então daí eu tenho que esperar imprimir para poder passar o próximo produto, tá até aí beleza só que a gente vai mudar isso, tipo eu vou passar o produto e vou mandar imprimir,e não preciso ficar esperando imprimir pra poder passar o próximo, daí cada pedido de impressão será um thread tá até aí beleza também, mas tipo na ordem que eu passar o produto é a ordem que eu tenho que imprimir por isso eu dei o exemplo da fila, quem chega primeiro sai primeiro.

Nesse caso, a classe que controla a impressora é que rodará numa Thread, com uma fila de mensagens.

A sua Thread simplesmente submete vários trabalhos de impressão para essa classe, que vai processar quando puder.

É um caso típico do Algoritmo do Produtor/Consumidor. A impressora é a consumidora e sua classe, a produtora.

Cara entendi a sua idéia e achei muito melhor que a idéia que eu tive…

Me desculpem a minha ignorancia, mas pelos testes que eu fiz eu não encontrei vantagem em utilizar o callable.
eu criei um metodo q calculasse um numero e tds os seus antecessores. criei esse metodo como parte da classe principal e criei o msm metodo dentro de um callable, exatamente igual.
esta assim

cria o threadpool
da um submit chamando o callable
chama o metodo local
chama o metodo get

acontece q eu pego o tempo antes e dps de chamar o metodo local, e o tempo antes e dps de chamar o metodo get.
o tempo do metodo get, demora ± 3 vezes o tempo do metodo local…

ismael.j.lima:

Me desculpem a minha ignorancia, mas pelos testes que eu fiz eu não encontrei vantagem em utilizar o callable.
eu criei um metodo q calculasse um numero e tds os seus antecessores. criei esse metodo como parte da classe principal e criei o msm metodo dentro de um callable, exatamente igual.
esta assim

cria o threadpool
da um submit chamando o callable
chama o metodo local
chama o metodo get

acontece q eu pego o tempo antes e dps de chamar o metodo local, e o tempo antes e dps de chamar o metodo get.
o tempo do metodo get, demora ± 3 vezes o tempo do metodo local…

É claro que não tem vantagem se você não der uma quantidade de trabalho suficiente para trabalhar. Toda a burocracia necessária para criar threads é pesada, e isso é que deve ter deixado o seu programa mais lento. É mais ou menos como você mandar um boy ao banco - você pode dar um monte de contas para ele pagar, ou você pode mandá-lo com uma conta de cada vez para ele pagar. Demora muito mais se você der um pouquinho só de trabalho de cada vez - mesmo que você tenha 4 ou 8 boys (threads ou CPUs) tentando fazer o mesmo trabalho simultaneamente.

Entendi…a minha principal duvida era se o callable executava o metodo call() na hora que o future chama o get(), mas fiz uns testes e verifiquei que o call era chamado exatamente no momento do instanciamento…

v lw pessoal…

Galera,

No caso eu preciso ler uma Lista e cada item desta lista entrar em um Thread.
Como que eu voi pegar o resultado de cada item?

Att

Eu sei que o tópico é antigo mas se adequa à minha dúvida, implementando threads no meu sistema elas irão concorrer mesmo executando em Sessões Web diferentes?

Ex: Usuario A logado no sistema, Usuário B também, ai por coincidência estão fazendo o mesmo processo e irão cadastrar algo novo na base, e ao mesmo tempo chamam o método que faz a inserção no banco! Se houver threads implementada para controlar esta inserção as Threads do Usuário A e Usuário B entraram na mesma fila para executar o metodo uma de cada vez assim resolvendo o problema de dead lock que estou recebendo.

Obrigado

???