Postar eventos user-defined entre Threads

[Duarte]

Uso Delphi, C++ e Clarion. Todas estas linguagens tem mecanismos para postar eventos entre threads de uma mesma aplicação.
Estou interessado em passar para JAVA (porquê é interplataforma e independente da Micro$oft, Borland e Top$peed).

Por isto estou avaliando JAVA e até agora não achei o mecanismo que permite uma thread enviar um evento (ou sinal) “user-defined” para outra.

Não estou falando dos eventos entre componentes, padrão do JAVA (ActionListener). O que preciso é definir eventos meus, por exemplo:

• Crio um equate “EVENT_ExploitFound”
• Rodo uma thread qualquer que, por exemplo, é uma interface com o usuário.
• Rodo uma outra thread que executa um processamento qualquer em background. Esta thread em um dado momento deve enviar à primeira thread um evento “EVENT_ExploitFound” (de novo, este evento não existe - fui eu que o defini - é um valor qualquer).
• A thread de interface com o usuário deve receber o evento “EVENT_ExploitFound” e disparar uma ação qualquer.

Como pode-se ver o que estou perguntando é algo bem diferente dos métodos de eventos que encontrei no JAVA, que permitem que um controle (tipo um botão) emitam eventos pré-determinados que um outro controle “escutará”. O que preciso é poder definir eventos (não os pré-determinados) e emiti-los de dentro do código para serem escutados em uma outra thead.

JAVA tem esta capacidade? Deve ter, eu é que ainda não encontrei. Alguém pode me indicar o caminho?

[Paulo_Silveira]

faca as duas threads sincronizar sobre o mesmo objeto

ai voce pode usar o wait / notify para fazer o signaling

existe tambem uma biblioteca, do Doug lea, que faz esses signaling mais transparentes para voce. no fundo ele usa wait e notify, mas voce nao precisa enxergar

[GuttoSP]

Duarte.

pode partir pro java sem receio algum, voce vai se surpreender, com esta maravilha.

Saia de uma vez por todas do $

Vai nessa.

[]…

[tanjajr]

Fala, Duarte…

Bem, no momento, sei pouco ou nada de Thread’s em JAVA, mas, se entendi bem o que você quis dizer, você pode criar uma biblioteca de classes usando o padrão Observer (sem necessariamente, utilizar a classe Observer e a interface Observable do java.util).

vamos ver se é isso que você quer:

class TangerinaEvento{
//Aqui, você define os métodos e atributos de seu evento, ok?
}

interface TangerinaListener(){
//aqui, você define os métodos que devem ser tratados ao ocorreu um
“MeuEvento”. Por exemplo:

public void descascaTangerina(TangerinaEvento){
}
}

class ThreadBackground extends Thread{
//sua thread que rodará em bkg! Dentro dela, defina os métodos que irão
//adicionar, remover e disparar as chamadas de eventos de
//TangerinaEvento. Seguindo:

public void addTangerinaListener(TangerinaListener tl){

//adiciona uma referência à um objeto TangerinaListener à alguma
//estrutura de dados que você achar mais adequada, ok?

}

public void removeTangerinaListener(TangerinaListener tl){

//Remove o objeto adicionado pelo método acima

}

private void fireTangerinaEvento(){
//dispara o método da interface TangerinaListener a todos objetos
//‘ouvintes’ de sua classe.

TangerinaListener tl = suaEstruturaDeDados.getTangerinaListener();
//Acima, eu subentendi que sua estrutura de dados irá retornar um
//objeto TangerinaListener, mas isso não é via de regra!

tl.descascaTangerina(new TangerinaEvent());
}
}

class ThreadFront extend Thread implements TangerinaListener{

//Essa sua classe irá rodar na frente da outra e ela implementará o que
//fazer quando a classe de bkg notifica-la

public void descascaTangerina(TangerinaEvento te){
//esse é o método que você deve implementar. Ele executará as ações
// que você julgar necessárias quando ThreadBkg avisar
}
}

class Teste{
//Aqui vai a implementação de toda a salada descrita acima

//Define a thread que rodará em back
ThreadBackground tbkg = new ThreadBackground();
//Define a thread que rodará em front
ThreadFront tf = new ThreadFront();
//Diz pra thread bkg qeu, toda vez que ela disparar um TangerinaEvento,
// notificar tf.
tbkg.addTangerinaListener(tf);
…
}

Bem, como você pode ver, a solução que apresentei pode parecer muito mais complexa do que a outra apresentada (wait e notify), porém, caso que você queira que as duas thread’s executem simultaneamente, GUARDADAS AS LIMITAÇÕES IMPOSTAS PELOS SISTEMAS OPERACIONAIS, essa solução parece ser viável e interessante, pois permite separar os diversos serviços que cada classe disponibiliza apenas nela própria, sendo desnecessário recriar alguma funcionalidade já existente.
Também sei que você irá encontrar inúmeros erros na solução apresentada acima, mas ela não foi colocada aqui para ser perfeita, mas sim, apenas para exemplificar melhor uma idéia.
Qualquer coisa, estamos por aí![/quote]

[net_sandro]

Tanja,

Fantástico o seu exemplo.

É a arquitetura “correta” proposta pelo Java para manipulação de eventos.

Não faltou definir que alguém implementa EventListener, ou algo assim ?

t+

[Duarte]

Tanja:
Agradecidíssimo!

Apesar de ainda estar iniciando o estudo de JAVA, já deu para entender o caminho que apontaste.
Meu primeiro problema é ter certeza que o JAVA vai conseguir fazer o que preciso.

Desenvolvo sistemas bastante complexos (Automação de Contatos, Telecomm e CRM) e a questão de postagem de eventos inter-threads é crucial para o meu tipo de aplicação.
Então é absolutamente importante que o JAVA consiga fazer o mesmo que o C++ / Deplhi / Clarion neste aspecto para que eu possa portar (reescrever) meus produtos.

Pelo que mostraste parece que tem um caminho para desenvolver a solução. Poderias ter a gentileza de me apontar alguma fonte de referencia, material de estudo, para que eu me aprofunde um pouco mais na questão??

Um abração, parece que vamos ser colegas de linguagem… E um dia espero estar à altura de retribuir a atenção.

Duarte

[tanjajr]

Fala, pessoal!

Pela ordem… :o)
net_sandro:

Na realidade, o que ocorreu é que eu resolvi mudar os nomes das classes e interfaces e não mudei o nome da interface “EventoListener” no comentário desta. Porém, se você analisar legal o código postado, verás que a classe ThreadFront extende Thread e implementa a TangerinaListener, que na realidade, é o nome que ficou para EventoListener;

Duarte:
na realidade, essa solução foi a que achei mais adequada para implementá-la como solução a um problema que eu estava tendo em um sistema novo que estou construindo (na realidade, será meu primeiro projeto em Java).
A solução adotada (chamada de padrão ou pattern Observer) eu encontrei no livro do Deitel (Java, como programar, 4ª Edição), mas foi algo muito vago. Porém, dada a simplicidade do sistema (embora pareça um tanto complexo devido à ‘aparente’ grande quantidade de classes a serem criadas), entendi de forma bem rápida, clara e simples.
Mas se surgirem mais dúvidas, continue postando por aqui ou então envie e-mail direto pra mim que podemos encontrar diversas soluções para um mesmo problema, ok?

[tanjajr]

Agora, Duarte, só uma dúvida e, por favor, não se ofenda, por ser uma pergunta um tanto que banal:
Você usa UML?