[JAVA] Problema con Thread.sleep(int millisecond)

[-Leo-]

Ciao a tutti, giochicchiando con java mi sono imbattuto in un problemino:
se richiamo un metodo da un action listener di un pulsante, il contenuto del metodo viene sì eseguito ma nel seguente modo: prima vengono eseguiti tutti i Thread.sleep presenti in esso (anche se prima magari ci sono altre istruzioni) e, arrivati all'ultimo, viene eseguito tutto il contenuto senza curarsi dell'ordine dei Thread.sleep fra un'istruzione e l'altra.

ESEMPIO:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.text.*;

public class Prova {

    JFrame finestra;
    StyledDocument stile;
    JTextPane riquadroDiTesto;
    JToolBar barraStrumentiBottom;
    JToggleButton interruttore;
    JScrollPane barraDiScorrimento;
    Container contenitore;

    public static void main(String[] arg) {
        new Prova();
    }		

    public Prova() {
        try {

            finestra = new JFrame("Prova");
            finestra.setSize(200,200);
            finestra.setResizable(false);

            stile = new DefaultStyledDocument();
            riquadroDiTesto = new JTextPane(stile);
            riquadroDiTesto.setEditable(false);

            barraStrumentiBottom = new JToolBar();
            barraStrumentiBottom.setFloatable(false);

//PULSANTE
            interruttore = new JToggleButton("PROVA");
            barraStrumentiBottom.add(interruttore);
            interruttore.addActionListener(new ActionListener() {
                    public void actionPerformed(ActionEvent actionEvent) {
                        AbstractButton abstractButton = (AbstractButton) actionEvent.getSource();
                        boolean selected = abstractButton.getModel().isSelected();
                        Inizio();
                    }
                });

            barraDiScorrimento = new JScrollPane(riquadroDiTesto);;
            barraDiScorrimento.getVerticalScrollBar().addAdjustmentListener(new AdjustmentListener() {  
                    public void adjustmentValueChanged(AdjustmentEvent e) {  
                        e.getAdjustable().setValue(e.getAdjustable().getMaximum());  
                    }
                });

            contenitore = finestra.getContentPane();
            contenitore.add(barraDiScorrimento, BorderLayout.CENTER);
            contenitore.add(barraStrumentiBottom, BorderLayout.SOUTH);

            finestra.setVisible(true);
        } catch (Exception errore) {
            JOptionPane.showMessageDialog(null, "Errore di esecuzione");
        }
    }

//METODO
    public void Inizio() {
        try {
            riquadroDiTesto.setText("Prova"); //Dovrebbe prima di tutto visualizzare il testo
            Thread.sleep(2000); //Dovrebbe attendere i 2 secondi
            riquadroDiTesto.setText("2 secondi trascorsi"); //Dovrebbe visualizzare quest'altro testo sostituendo il primo
        }  catch(Exception errore) {
            JOptionPane.showMessageDialog(null, "Errore di esecuzione");
        }
    }
}

il programma crea una finestrella con un pulsante "PROVA" che, se premuto, secondo i miei calcoli dovrebbe visualizzare:

Prova

*attesa di due secondi*

2 secondi trascorsi

invece visualizza:

*attesa di due secondi*

Prova

2 secondi trascorsi

NOTA: se eseguito si vede solo "2 secondi trascorsi" poiché "Prova" viene subito cancellato e sostituito.

(ciò accade solo se il metodo viene richiamato dal pulsante tramite l'action listener altrimenti funziona come nel primo caso).
Qualcuno saprebbe spiegarmi come mai accade tutto ciò?

[sottovento]

Originariamente inviato da -Leo-

se richiamo un metodo da un action listener di un pulsante, il contenuto del metodo viene sì eseguito ma nel seguente modo: prima vengono eseguiti tutti i Thread.sleep presenti in esso (anche se prima magari ci sono altre istruzioni) e, arrivati all'ultimo, viene eseguito tutto il contenuto senza curarsi dell'ordine dei Thread.sleep fra un'istruzione e l'altra.

No, dai! Viene eseguito tutto nel modo corretto e sacrosanto!
Ti sei fatto ingannare: quando crei un'interfaccia grafica, Java crea un nuovo thread. Questo thread e' preposto alla gestione dell'interfaccia grafica e dei suoi eventi. SOLO LUI LO PUO' FARE.

Quando esegui la actionPerformed(), essa e' eseguita da questo thread. Ti sarai infatti accorto che l'interfaccia, durante l'esecuzione della actionPerformed() non ti risponde, visto che e' impegnata a fare altre cose. Tutto qui!
Quindi, nella actionPerformed() potrai mettere tutti gli aggiornamenti/scritte che vuoi, le quali NON COMPARIRANNO NELLA TUA FINESTRA fino a quando tale metodo non ha finito di fare il suo lavoro. Tutto qui.

Prova a sostituire le tue scritte nella JFrame con qualche System.out.println(), e vedrai che il flusso di esecuzione e' corretto (e ci mancherebbe altro)

[-Leo-]

Originariamente inviato da sottovento

No, dai! Viene eseguito tutto nel modo corretto e sacrosanto!
Ti sei fatto ingannare: quando crei un'interfaccia grafica, Java crea un nuovo thread. Questo thread e' preposto alla gestione dell'interfaccia grafica e dei suoi eventi. SOLO LUI LO PUO' FARE.

Quando esegui la actionPerformed(), essa e' eseguita da questo thread. Ti sarai infatti accorto che l'interfaccia, durante l'esecuzione della actionPerformed() non ti risponde, visto che e' impegnata a fare altre cose. Tutto qui!
Quindi, nella actionPerformed() potrai mettere tutti gli aggiornamenti/scritte che vuoi, le quali NON COMPARIRANNO NELLA TUA FINESTRA fino a quando tale metodo non ha finito di fare il suo lavoro. Tutto qui.

Prova a sostituire le tue scritte nella JFrame con qualche System.out.println(), e vedrai che il flusso di esecuzione e' corretto (e ci mancherebbe altro)

Ciao sottovento
grazie della spiegazione ora ho capito. Purtroppo però resta il fatto che se io nel metodo azionato dalla action performed ho un codice che vorrei stampasse scritte ogni tot secondi quest'effetto viene meno.
Non esiste un modo per far terminare la action performed subito dopo che ha richiamato il mio metodo senza attendere l'esecuzione completa delle istruzioni che contiene?

[sottovento]

Originariamente inviato da -Leo-

Ciao sottovento
grazie della spiegazione ora ho capito. Purtroppo però resta il fatto che se io nel metodo azionato dalla action performed ho un codice che vorrei stampasse scritte ogni tot secondi quest'effetto viene meno.
Non esiste un modo per far terminare la action performed subito dopo che ha richiamato il mio metodo senza attendere l'esecuzione completa delle istruzioni che contiene?

Diciamo che in tutte le chiamate a callback, come la actionPerformed(), devi fare un lavoro di breve durata per non bloccare il thread di cui parlavamo, e di conseguenza rendere l'interfaccia utente bloccata. Gli utenti non amano queste cose. Se hai bisogno di fare lavori lunghi, puoi sempre delegarli ad un altro thread.

Il lavoro che vuoi fare tu, lo puoi ottenere semplicemente con un timer. Siccome gia' sai utilizzare la actionPerformed(), puoi usare il timer di swing: javax.swing.Timer, il quale alla scadenza dell'intervallo indicato ti richiamera' appunto la tua azione.

Volendo fare un piccolo esempio utilizzando il tuo codice e le modifiche minime, potresti fare una cosa cosi':

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.text.*;

public class Prova
{
    JFrame finestra;
    StyledDocument stile;
    JTextPane riquadroDiTesto;
    JToolBar barraStrumentiBottom;
    JToggleButton interruttore;
    JScrollPane barraDiScorrimento;
    Container contenitore;
    Timer timer;
    int count = 1;

    public static void main(String[] arg)
    {
        new Prova();
    }		

    public Prova()
    {
        try
        {
            finestra = new JFrame("Prova");
            finestra.setSize(200,200);
            finestra.setResizable(false);

            stile = new DefaultStyledDocument();
            riquadroDiTesto = new JTextPane(stile);
            riquadroDiTesto.setEditable(false);

            barraStrumentiBottom = new JToolBar();
            barraStrumentiBottom.setFloatable(false);

            //PULSANTE
            interruttore = new JToggleButton("PROVA");
            barraStrumentiBottom.add(interruttore);
            interruttore.addActionListener(new ActionListener()
            {
                public void actionPerformed(ActionEvent actionEvent)
                {
                    AbstractButton abstractButton = (AbstractButton) actionEvent.getSource();
                    boolean selected = abstractButton.getModel().isSelected();
                    Inizio();
                }
            });
            timer = new Timer(1000, new ActionListener()
                {
                    @Override
                    public void actionPerformed(ActionEvent evt)
                    {
                        riquadroDiTesto.setText("Chiamata #" + count++);
                    }
                });
            timer.start();

            barraDiScorrimento = new JScrollPane(riquadroDiTesto);;
            barraDiScorrimento.getVerticalScrollBar().addAdjustmentListener(new AdjustmentListener()
            {  
                public void adjustmentValueChanged(AdjustmentEvent e)
                {  
                    e.getAdjustable().setValue(e.getAdjustable().getMaximum());  
                }
            });

            contenitore = finestra.getContentPane();
            contenitore.add(barraDiScorrimento, BorderLayout.CENTER);
            contenitore.add(barraStrumentiBottom, BorderLayout.SOUTH);

            finestra.setVisible(true);
        }
        catch (Exception errore)
        {
            JOptionPane.showMessageDialog(null, "Errore di esecuzione");
        }
    }

    //METODO
    public void Inizio()
    {
        try
        {
            riquadroDiTesto.setText("Prova"); //Dovrebbe prima di tutto visualizzare il testo
            Thread.sleep(2000); //Dovrebbe attendere i 2 secondi
            riquadroDiTesto.setText("2 secondi trascorsi"); //Dovrebbe visualizzare quest'altro testo sostituendo il primo
        }
        catch(Exception errore)
        {
            JOptionPane.showMessageDialog(null, "Errore di esecuzione");
        }
    }
}

[-Leo-]

Altrimenti mi è venuto in mente che potrei applicare al pulsante questo tipo di action performed

            interruttore.addActionListener(new ActionListener() {
                    public void actionPerformed(ActionEvent e) {
                        Thread nuovoThread= new Thread() {
                                public void run() {
                                    Inizio();
                                }
                            };
                        nuovoThread.start();
                    }
                });

In questa maniera sembra fuzionare, solamente che se provo ad aggiungere all'interfaccia altri pulsanti uguali a questo (ma che portano ad altri metodi) accade che: se si passa dal metodo avviato da un pulsante a quello avviato da un altro, talvolta, sembra che i relativi contenuti si "miscelino"... credo che sia dovuto al fatto che ogni pulsante di questo tipo crea un Thread senza poi chiuderlo così che si sovrapponga a quello creato precentemente da un altro pulsante, creando l'effetto sovrapposizione delle istruzioni dei dui metodi (o almeno suppongo)... esiste un modo per gestire questo tipo di situazione?

EDIT: facendo ulteriori prove pare proprio che il problema sia l'esecuzione contemporanea di più tread: se premo il bottone 1 che crea un Thread ed esegue un metodo, poi attivo il bottone 2 che crea un altro Thread ed attiva un altro metodo accade che: se entrambi i codici sono programmati per fare qualcosa alla pressione, ad esempio, del tasto "enter" questi la svolgeranno contemporaneamente.

[sottovento]

Originariamente inviato da -Leo-

EDIT: facendo ulteriori prove pare proprio che il problema sia l'esecuzione contemporanea di più tread: se premo il bottone 1 che crea un Thread ed esegue un metodo, poi attivo il bottone 2 che crea un altro Thread ed attiva un altro metodo accade che: se entrambi i codici sono programmati per fare qualcosa alla pressione, ad esempio, del tasto "enter" questi la svolgeranno contemporaneamente.

Esatto. I thread possono fare azioni diverse "contemporaneamente".
Normalmente questo e' un effetto voluto. Se hai bisogno che le operazioni vengano fatte in maniera sequenziale, devi pensare ad un'architettura diversa, oppure a sincronizzare i thread fra loro. Dipende ovviamente dal problema che vuoi risolvere

[-Leo-]

vorrei che ogni pulsante quando premuto crei un thread ed esegua un metodo, poi alla pressione di un altro pulsante, il vecchio thread sia terminato e ne venga creato un altro dove eseguire un altro metodo.

[sottovento]

Originariamente inviato da -Leo-

vorrei che ogni pulsante quando premuto crei un thread ed esegua un metodo, poi alla pressione di un altro pulsante, il vecchio thread sia terminato e ne venga creato un altro dove eseguire un altro metodo.

Ci sono molti modi per realizzare quello che vuoi, piu' o meno eleganti.
Siccome i tuoi thread contengono delle pause lunghe, puoi utilizzare il metodo
interrupt()
il quale fa terminare le wait(), join() o sleep(), le quali ritorneranno (all'interno del thread da cui sono chiamate) l'eccezione
InterruptedException
che dovrai gestire per terminare il thread.

Tuttavia,se il tuo programma e' CPU-consuming (fai tanti calcoli) ovviamente questo metodo non funzionera', e dovrai inventarti un modo ad-hoc per terminare il thread, e terminarlo in breve tempo.

Spesso si usa una variabile condivisa che viene testata dal thread ripetutamente. Per esempio, potresti chiamarla finito e farla valere sempre "true" fino a quando vuoi terminare.

Ovviamente devi stare attento a testarla frequentemente: non puoi lanciare operazioni di minuti senza controllare questa variabile, ok?

[mone.java]

Prova a dare un occhiata alla classe SwingWorker... Se hai mai programmato con Android è più o meno l'equivalente dell'AsyncTask...

[-Leo-]

Originariamente inviato da sottovento

Ci sono molti modi per realizzare quello che vuoi, piu' o meno eleganti.
Siccome i tuoi thread contengono delle pause lunghe, puoi utilizzare il metodo
interrupt()
il quale fa terminare le wait(), join() o sleep(), le quali ritorneranno (all'interno del thread da cui sono chiamate) l'eccezione
InterruptedException
che dovrai gestire per terminare il thread.

Tuttavia,se il tuo programma e' CPU-consuming (fai tanti calcoli) ovviamente questo metodo non funzionera', e dovrai inventarti un modo ad-hoc per terminare il thread, e terminarlo in breve tempo.

Spesso si usa una variabile condivisa che viene testata dal thread ripetutamente. Per esempio, potresti chiamarla finito e farla valere sempre "true" fino a quando vuoi terminare.

Ovviamente devi stare attento a testarla frequentemente: non puoi lanciare operazioni di minuti senza controllare questa variabile, ok?

Buongiorno, ho seguito il tuo consiglio e devo dire che in effetti pare funzionare! Grazie mille
Modifico il mio esempio per mostrarti come ho allestito il tutto tramite l'utilizzo della variabile (il codice è un po' arrangiato... purtroppo, per adesso, più di questo non sono riuscito ad inventarmi... comunque pare funzionare a dovere)

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.text.*;
import javax.swing.plaf.metal.*;

public class Prova {

    JFrame finestra;
    StyledDocument stile;
    JTextPane riquadroDiTesto;
    JToolBar barraStrumentiBottom;
    JToggleButton interruttoreHome, interruttoreA, interruttoreB;
    JScrollPane barraDiScorrimento;
    Container contenitore;
    Icon iconaInterruttore;
    AbstractButton abstractButton;
    private volatile boolean stop = false;
    
    public static void main(String[] arg) {
        new Prova();
    }		

    public Prova() {
        try {

            finestra = new JFrame("Prova");
            finestra.setSize(200,200);
            finestra.setResizable(false);

            stile = new DefaultStyledDocument();
            riquadroDiTesto = new JTextPane(stile);
            riquadroDiTesto.setEditable(false);

            barraStrumentiBottom = new JToolBar();
            barraStrumentiBottom.setFloatable(false);

            //PULSANTE HOME
            iconaInterruttore = MetalIconFactory.getFileChooserHomeFolderIcon();
            interruttoreHome = new JToggleButton(iconaInterruttore);
            barraStrumentiBottom.add(interruttoreHome);
            interruttoreHome.addActionListener(new ActionListener() {
                    public void actionPerformed(ActionEvent vaiHome) {
                        abstractButton = (AbstractButton) vaiHome.getSource();
                        boolean selected = abstractButton.getModel().isSelected();
                        stop = true; //INTERROMPE L'ESECUZIONE DEL THREAD
                    }
                });

            //PULSANTE A
            interruttoreA = new JToggleButton("TASTO A");
            barraStrumentiBottom.add(interruttoreA);
            interruttoreA.addActionListener(new ActionListener() {
                    public void actionPerformed(ActionEvent pressioneTastoA) {
                        Thread nuovaIstanza = new Thread() {
                                public void run() {
                                    while (!stop) {
                                        interruttoreA.setVisible(false); //ALLA PRESSIONE DI UN TASTO NASCONDO DALL'INTERFACCIA TUTTI I PULSANTI TRANNE interruttoreHome PER EVITARE L'AVVIO DI ULTERIORI THREAD PRIMA CHE QUELLO IN USO SIA TERMINATO
                                        interruttoreB.setVisible(false); //ALLA PRESSIONE DI UN TASTO NASCONDO DALL'INTERFACCIA TUTTI I PULSANTI TRANNE interruttoreHome PER EVITARE L'AVVIO DI ULTERIORI THREAD PRIMA CHE QUELLO IN USO SIA TERMINATO
                                        A();                                        
                                    }
                                    if (stop) {
                                        interruttoreA.setVisible(true); //QUANDO TRAMITE LA PRESSIONE DI interruttoreHome IL THREAD SI INTERROMPE RENDO NUOVAMENTE VISIBILI TUTTI I PULSANTI
                                        interruttoreB.setVisible(true); //QUANDO TRAMITE LA PRESSIONE DI interruttoreHome IL THREAD SI INTERROMPE RENDO NUOVAMENTE VISIBILI TUTTI I PULSANTI
                                        stop = false;
                                        Inizio();
                                    }
                                }
                            };
                        nuovaIstanza.start();
                    }
                });

            //PULSANTE B
            interruttoreB = new JToggleButton("TASTO B");
            barraStrumentiBottom.add(interruttoreB);
            interruttoreB.addActionListener(new ActionListener() {
                    public void actionPerformed(ActionEvent pressioneTastoB) {
                        Thread nuovaIstanza = new Thread() {
                                public void run() {
                                    while (!stop) {
                                        interruttoreA.setVisible(false); //ALLA PRESSIONE DI UN TASTO NASCONDO DALL'INTERFACCIA TUTTI I PULSANTI TRANNE interruttoreHome PER EVITARE L'AVVIO DI ULTERIORI THREAD PRIMA CHE QUELLO IN USO SIA TERMINATO
                                        interruttoreB.setVisible(false); //ALLA PRESSIONE DI UN TASTO NASCONDO DALL'INTERFACCIA TUTTI I PULSANTI TRANNE interruttoreHome PER EVITARE L'AVVIO DI ULTERIORI THREAD PRIMA CHE QUELLO IN USO SIA TERMINATO
                                        B();
                                    }
                                    if (stop) {
                                        interruttoreA.setVisible(true); //QUANDO TRAMITE LA PRESSIONE DI interruttoreHome IL THREAD SI INTERROMPE RENDO NUOVAMENTE VISIBILI TUTTI I PULSANTI
                                        interruttoreB.setVisible(true); //QUANDO TRAMITE LA PRESSIONE DI interruttoreHome IL THREAD SI INTERROMPE RENDO NUOVAMENTE VISIBILI TUTTI I PULSANTI
                                        stop = false;
                                        Inizio();
                                    }
                                }
                            };
                        nuovaIstanza.start();
                    }
                });

            barraDiScorrimento = new JScrollPane(riquadroDiTesto);;
            barraDiScorrimento.getVerticalScrollBar().addAdjustmentListener(new AdjustmentListener() {  
                    public void adjustmentValueChanged(AdjustmentEvent e) {  
                        e.getAdjustable().setValue(e.getAdjustable().getMaximum());  
                    }
                });

            contenitore = finestra.getContentPane();
            contenitore.add(barraDiScorrimento, BorderLayout.CENTER);
            contenitore.add(barraStrumentiBottom, BorderLayout.SOUTH);

            finestra.setVisible(true);
            
            Inizio();
        } catch (Exception errore) {
            JOptionPane.showMessageDialog(null, "Errore di esecuzione");
        }
    }

    //QUESTO METODO QUANDO RICHIAMATO RESTA PERENNEMENTE IMPRIGIONATO NEL while FINO ALLA PRESSIONE DEL TASTO interruttoreHome
        public void InputManager() {
        try {
            while (stop == false) {
                interruttoreHome.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent pressioneInvio) {
                        }
                    });
            }
        } catch (Exception errore) {
            JOptionPane.showMessageDialog(null, "Errore di esecuzione");
        }
    }
    
    //METODO INIZIALE
    public void Inizio() {
        try {
            riquadroDiTesto.setText("Pemi un tasto");
            InputManager();
        }  catch(Exception errore) {
            JOptionPane.showMessageDialog(null, "Errore di esecuzione");
        }
    }
    
    //METODO AVVIATO DA interruttoreA
        public void A() {
        try {
            riquadroDiTesto.setText("Hai premuto il tasto A");
            InputManager();
        }  catch(Exception errore) {
            JOptionPane.showMessageDialog(null, "Errore di esecuzione");
        }
    }
    
    //METODO AVVIATO DA interruttoreB
        public void B() {
        try {
            riquadroDiTesto.setText("Hai premuto il tasto B");
            InputManager();
        }  catch(Exception errore) {
            JOptionPane.showMessageDialog(null, "Errore di esecuzione");
        }
    }
}

Originariamente inviato da mone.java

Prova a dare un occhiata alla classe SwingWorker... Se hai mai programmato con Android è più o meno l'equivalente dell'AsyncTask...

Ciao grazie anche a te del consiglio .
Come primo approccio per adesso ho preferito continuare a lavorare con swing e arrangiarmi come detto sopra. Comunque se in futuro dovessi avere altri impicci con la gestione dei thread mi ricorderò di dare un'occhiata a SwingWorker.

[sottovento]

Il codice comincia ad allungarsi, quini possono scappare delle cose.
Ne ho trovate alcune che andrebbero sistemate, anche se il programma funziona:

        public void InputManager() {
        try {
            while (stop == false) {
                interruttoreHome.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent pressioneInvio) {
                        }
                    });
            }
        } catch (Exception errore) {
            JOptionPane.showMessageDialog(null, "Errore di esecuzione");
        }

Questo e' un ciclo che continua a fare la addActionListener()!
Beh, puo' bastare fatta una volta, non credi?
E poi, questo e' un ciclo proprio stretto stretto, ti mangi un sacco di cpu per nulla! Prima c'erano della pause piuttosto lunghe, ora non ce ne sono piu'. il mio suggerimento e' di controllare stop NON piu' di 10 volte al secondo, potresti inserire un ritardo di 100[ms] in modo da tenere il consumo di cpu sotto controllo, no?

while (!stop) {
      interruttoreA.setVisible(false); 
      interruttoreB.setVisible(false); 
      ...

Swing non e' multithread-safe. Abbiamo parlato di un thread che si occupa di aggiornare l'interfaccia utente, ed abbiamo detto che lo deve fare solo lui.
Qui, hai creato un nuovo thread e gli stai facendo fare il lavoro che dovrebbe fare il thread di prima.
Si tratta di un lavoro semplice, quindi difficilmente avrai mai problemi; tuttavia puoi chiedere all'altro thread di fare questo lavoro per te, per esempio:

SwingUtilities.invokeLater(new Runnable()
    {
        @Override
        public void run()
       { 
          interruttoreA.setVisible(false); 
          interruttoreB.setVisible(false); 
       }
    });

Cosi' sei sicuro che il legittimo thread faccia il suo lavoro correttamente.

Ci sono anche altre cosine, ma sono piu' o meno le stesse cose. Spero ti sia utile. Ciao

[-Leo-]

Grazie delle dritte. Specialmente quella sul ciclo presente in InputManager()... in effetti era un errore piuttosto grossolano. Ho provato a verificare tramite il gestore attività di quanto salisse il carico della cpu, relativo a quel programma, quando entrava nel ciclo ed ho visto percentuali di utilizzo del processore estremamente alte...
Oltre questa correzione volevo provare a delegare, come hai detto tu, tutti i lavori relativi all'interfaccia al Thread principale ed il risultato è questo:

            interruttoreB.addActionListener(new ActionListener() {
                    public void actionPerformed(ActionEvent pressioneTastoB) {
                        SwingUtilities.invokeLater(new Runnable()
                            {
                                @Override
                                public void run()
                                { 
                                    interruttoreA.setVisible(false); 
                                    interruttoreB.setVisible(false); 
                                }
                            });                        
                        Thread nuovaIstanza = new Thread() {
                                public void run() {
                                    while (!stop) {
                                        B();
                                    }
                                    if (stop) {
                                        SwingUtilities.invokeLater(new Runnable()
                                            {
                                                @Override
                                                public void run()
                                                { 
                                                    interruttoreA.setVisible(true); 
                                                    interruttoreB.setVisible(true); 
                                                }
                                            });
                                        stop = false;
                                        Inizio();
                                    }
                                }
                            };
                        nuovaIstanza.start();
                    }
                });

come vedi la cosa pare un po' macchinosa... non so se sia possibile scriverlo meglio.

[sottovento]

Originariamente inviato da -Leo-

come vedi la cosa pare un po' macchinosa... non so se sia possibile scriverlo meglio.

Scusa il ritardo. Beh, forse hai ragione e si puo' scriverlo meglio, ma non mi lamenterei: mi sembra un buon lavoro!
Per inciso: spesso la gente evita la pappardella della SwingUtilities.invokeLater() e chiama il metodo direttamente (soprattutto se si tratta di un cambio di stato dei bottoni) ed il 90% delle volte funziona.
Pero' cosi' sei davvero sicuro. Per esempio, una volta non l'ho utilizzata per aggiornare una progress bar (tanto e' una progress bar) ed il programma mi si e' inchiodato di brutto.... quindi direi che ne vale la pena, no?

ciao

[-Leo-]

Sisi certo ne vale la pena assolutamente. Il mio dubbio era solamente relativo "all'eleganza" del mio actionListener modificato con l'invokeLater.
Grazie ancora dei consigli. Ciao