Threads e Swing

1. Você não está criando nenhuma thread. O InvokeLater dispara apenas eventos para a thread do Swing. No caso, tudo o que estiver no método run().
2. Use o invokeLater apenas para atualizar componentes, dentro do método run() de sua thread.
3. É o método start() que dispara uma thread.

e o t1 até q é uma thread realmente.

mas vc após chamar o start dela vc chama o join.
q faz a thread principal parar até q t1 finalize.

no final funcionou td como se fosse apenas na "thread main" mesmo.

creio q vc poderia tentar assim:

public abstract class Tread1 extends Thread {  
    private int resultadoT1;  
      
    public Tread1 (int b) {  
        resultadoT1 = b;  
    }  
  
    public abstract void Concluido();
    
    @Override  
    public void run() {  
        this.resultadoT1 = -resultadoT1;  
        try {  
            Thread.sleep(3000);
        } catch (InterruptedException ex) {  
            //Logger.getLogger(T1.class.getName()).log(Level.SEVERE, null, ex);  
        }  
        Concluido();
    }  
    public int getResultadoT1() {  
        return resultadoT1;  
    }  
}

note q adicionei um metodo abstrato "Concluido";//será executado qdo concluido

e use assim:
ps. note o override

SwingUtilities.invokeLater(new Thread() {  
            @Override  
            public void run() {  
                btT1.setBackground(Color.white); //não atualiza  
                repaint();  

                Tread1 t1 = new Tread1(b){			
        			@Override
        			public void Concluido() {
        				synchronized (btT1) {
                            btT1.setBackground(Color.green); // é a ultima cor setada.. que permanece  
        				}
        			}			
        		};  
                
                t1.start();  
                btT1.setBackground(Color.yellow); //não atualiza

Ambas dicas estão dando certo, pelas quais agradeço.
No entanto, notei que o problema surge quando uso o join().
Se usar o comando join() a tela principal (um jpanel, que está em uma jframe) não atualiza as cores até que tdas as treads finalizem.
Vou continuar tentando descobrir o que está errado.

josachu:

Ambas dicas estão dando certo, pelas quais agradeço.
No entanto, notei que o problema surge quando uso o join().
Se usar o comando join() a tela principal (um jpanel, que está em uma jframe) não atualiza as cores até que tdas as treads finalizem.
Vou continuar tentando descobrir o que está errado.

e o t1 até q é uma thread realmente.

mas vc após chamar o start dela vc chama o join.
q faz a thread principal parar até q t1 finalize.

no final funcionou td como se fosse apenas na “thread main” mesmo.

só repetindo!!!

se fizer do jeito q sujeri não precisaria do join

É verdade Gilson,

Mas um amigo sugeriu outra solução que funcionou. É a criação de uma nova thread, na qual incluo todo o código do botão.

É este código:

new Thread (new Runnable() {
            @Override
            public void run() {

            // todo o código do botão aqui dentro

           }
        }).start();

Pelo que entendi, o comando join() segura as thread anteriores, até que a thread corrente (a que dei o join) termine.
O que acontecia, é que eu segurava a thread do swing e portanto, ela só atualizava quando a thread que realizava a conta estava concluida.
Como eu queria atualizar o status mudando a cor do botão conforme o ‘status’ da thread, isso não acontecia, ou seja, travava e o botão ficava somente com a última alteração da cor (neste caso a verde).

Opa, tirou uma duvida minha tambem.
Fiz aqui e funcionou tudo certo.
VALEU

josachu:

É verdade Gilson,

Mas um amigo sugeriu outra solução que funcionou. É a criação de uma nova thread, na qual incluo todo o código do botão.

É este código:

new Thread (new Runnable() {
            @Override
            public void run() {

            // todo o código do botão aqui dentro

           }
        }).start();

Pelo que entendi, o comando join() segura as thread anteriores, até que a thread corrente (a que dei o join) termine.
O que acontecia, é que eu segurava a thread do swing e portanto, ela só atualizava quando a thread que realizava a conta estava concluida.
Como eu queria atualizar o status mudando a cor do botão conforme o ‘status’ da thread, isso não acontecia, ou seja, travava e o botão ficava somente com a última alteração da cor (neste caso a verde).

na realidade ele não seguras “as” threads anteriores e sim a thread q chamou o join.

no seu caso deu errado pq vc imaginou q a “thread” q chamava o join era uma distinta do thread main e não era, como bem explicou o ViniGodoy.
“InvokeLater dispara apenas eventos para a thread do Swing.” ou seja, faz com q o run seja executado posteriormente, porem pela thread principal.

é como um “enfileiramento” de trabalhos a serem feitos assim q o sistema estiver em idle.

pelo menos foi a leitura q consegui fazer. como não sou desenvolvedor java, posso estar enganado.

me corrijam se eu estiver errado, por gentileza.

GilsonNunes:

josachu:

É verdade Gilson,

Mas um amigo sugeriu outra solução que funcionou. É a criação de uma nova thread, na qual incluo todo o código do botão.

É este código:

new Thread (new Runnable() {
            @Override
            public void run() {

            // todo o código do botão aqui dentro

           }
        }).start();

Pelo que entendi, o comando join() segura as thread anteriores, até que a thread corrente (a que dei o join) termine.
O que acontecia, é que eu segurava a thread do swing e portanto, ela só atualizava quando a thread que realizava a conta estava concluida.
Como eu queria atualizar o status mudando a cor do botão conforme o ‘status’ da thread, isso não acontecia, ou seja, travava e o botão ficava somente com a última alteração da cor (neste caso a verde).

na realidade ele não seguras “as” threads anteriores e sim a thread q chamou o join.

no seu caso deu errado pq vc imaginou q a “thread” q chamava o join era uma distinta do thread main e não era, como bem explicou o ViniGodoy.
“InvokeLater dispara apenas eventos para a thread do Swing.” ou seja, faz com q o run seja executado posteriormente, porem pela thread principal.

é como um “enfileiramento” de trabalhos a serem feitos assim q o sistema estiver em idle.

pelo menos foi a leitura q consegui fazer. como não sou desenvolvedor java, posso estar enganado.

me corrijam se eu estiver errado, por gentileza.

Exatamente Gilson.
Quando executo a main, uso o método:

new TelaPrincipal().setVisible(true);

A main cria uma única thread chamada EventDispatchThread, que é thread é a principal (a thread do Swing).

Ela tem uma fila de processamento. Ao enviar o comando ela enfileira o comandos.

Se eu usar o “invokeLater” eu jogo o processo pra mesma fila (da thread principal).

Então uso um recurso da linguagem, que é a criação de uma classe anônima, e crio uma nova Thread.
Com isso, consigo ‘liberar’ o processamento da thread principal para a anônima.