Ajuda em sincronização

um método syncronized ?

Você colocou um método synchronized que envia dados para a outra classe, e você tem duas threads… (pelo que entendi)

Como assim checar a classe synchronized??

tipo assim , nao tem como eu fazer uma especie de listener nao , eu sei q ficou meio confuso mas deixa eu explicar oq eu tava tentando …
a thread 1 eh um JFrame , a 2 um socket e a syncronized leva do socket pra jframe , eu preciso atualizar um campo da thread 1 toda vez q chega uma msg na thread 2 ,
eu ja consigo pegar a msg e enviar para a synchronized , mas a thread 1 nao pode ficar esperando para receber o dado pois eu usei D&D e se eu espero alguma ação o recurso para de funcionar. qual seria a solução desse problema??
me falaram pra usar um actionperformed , mas eu usaria ele em que ???
nao tem como eu usar um listener dentro da thread 1 pra checar a variavel do synchronized nao?
obrigado .

D&D seria Drag and Drop?
Ou você está implementando um jogo de Dungeons&Dragons? :lol:

Vamos ver se eu entendi, você tem duas threads:

1. A thread normal do programa, da AWT, onde roda o seu JFrame;
2. Uma segunda thread que você disparou para monitorar um socket.

Quando chega um evento do socket e esse evento é interpretado e a thread do socket deveria atualizar o JFrame (ou notificar a thread do JFrame para que ela se atualize).

Bom, a implementação disso é simples e certamente não envolve listeners.

A classe que monitora o socket terá que ter uma referência ao JFrame. Quando uma mensagem chegar na thread do socket, simplesmente atualize o campo que você deseja, usando o comando EventQueue.invokeLater(), conforme mostrado aqui:

EventQueue.invokeLater(new Runnable() {
   public void run() {
       txtStatus.setText(mensagemInterpretadaDoSocket);
       //Aqui você pode colocar outras atualizações, se quiser.
    }
});

Esse evento vai fazer com que a thread do socket envie um “pedido” para que a thread da AWT atualize o JFrame. Note que a thread do socket não atualizará o JFrame diretamente. Na verdade, essa é a maneira correta de fazer atualização de interfaces gráficas em ambientes multi-thread.

Como você não atualizará o JFrame diretamente, e usará apenas a EventQueue da AWT, você ganha as seguintes vantagens:

1. O método de atulização não precisa necessariamente ser sincronizado. Uma vez que o objeto compartilhado entre as duas thread (o JFrame), não será acessado pela thread do Socket.
2. Não deve atrapalhar o seu Drag and Drop, uma vez que os objetos da AWT saberão lidar com o evento.
3. Evita comportamentos estranhos da interface gráfica.

vini , muito obrigado cara , eu tava quebrando a cabeça aqui , brigadao mesmo !!!

eu estava lendo mais um pouco sobre threads e me veio uma duvida no caso q eu citei.
e se eu precisasse enviar alguma informação da JFrame para o socket tb , como eu implementaria isso?
ai sim eu usaria uma classe de sincronização ou a JFrame teria que ter uma referencia ao socket e implementaria o invokelater tb??
obrigado.

Você tem que entender o seguinte.

O Socket não é uma thread.
O JFrame não é uma thread.

As threads existem no seu programa e usam esses dois objetos. Os objetos possuem códigos para sincroniza-las, mas não são threads em si.

Para enviar uma mensagem para o Socket, você simplesmente coloca uma referência do Socket no frame e chama o método write do InputStream do socket diretamente.

Note, a Thread do JFrame irá usar o OutputStrem do Socket. A thread do socket irá ler as informações que vem da rede e chamar o setText do Frame.

Notou como os objetos são diferentes das threads?

a sim, agora eu entendi , tava axando algo completamente diferente , mto obrigado cara