[JAVA] Problema con interruzione Programma

[Ansharja]

Ciao a tutti, ho ancora bisogno di aiuto per risolvere un problema:

Ho un metodo che cambia le icone di alcune JLabel , e voglio che subito dopo averle sostituite il programma si interrompa per un certo tempo (2 secondi per ora).

Il problema è che durante l'esecuzione del programma le icone vengono sostituite dopo il tempo di interruzione.

Per ora queste 2 soluzioni provocano il risultato di cui ho detto:

Finestra.butta(cG,true);
/* Il metodo butta di Finestra aggiorna le icone delle JLabel e richiama sul pannello che le contiene
il metodo revalidate() e repaint ().Il tutto funziona ma solo dopo aver interrotto l'esecuzione con il 
comando nella riga qui sotto*/
Thread.sleep(2000);
/* Ho provato anche a sostituire il Thread.sleep sopra con:
long inizio=System.currentTimeMillis();
while((System.currentTimeMillis()-inizio)<2000);
Ma ottengo lo stesso risultato
*/

Sapreste come risolvere il problema?

[andbin]

Ne ho parlato tantissime volte, ad esempio qui

[Ansharja]

Grazie, allora prima di chiedere ancora cerco un po' in giro

[Ansharja]

Ok ho provato a costruire delle classi di esempio per gestire il threading in Swing, in questo codice premendo un bottone, scambio le icone di due JLabel e ad operazione effettutata aspetto due secondi.Posto le classi create:

public class Finestra 
{
	static JLabel icona,altraIcona;
	public static void main(String args[])
	{
		JFrame frame = new JFrame("Prova Thread");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		JButton button=new JButton("Inverti");
		icona=new JLabel(new ImageIcon("../2c.png"));
		altraIcona=new JLabel(new ImageIcon("../img.png"));
		button.addMouseListener(new Ascoltatore());
		Container c=frame.getContentPane();
		JPanel p=new JPanel(); 
		c.add(p);
		p.add(icona);
		p.add(button);
		p.add(altraIcona);
		frame.setSize(500,500);
		frame.setVisible(true);
	}
}
public class Ascoltatore implements MouseListener
{
	public void mouseClicked(MouseEvent e)
	{
		System.out.print("\nBottone cliccato");
		new Thread(new Esecutore()).start();
	}
	public void mouseEntered(MouseEvent e){}
	public void mouseExited(MouseEvent e){}
	public void mouseReleased(MouseEvent e){}
	public void mousePressed(MouseEvent e){}
}
public class Esecutore implements Runnable
{
	public void run()
	{
		try 
		{
			EventQueue.invokeAndWait(new Inverti());			
			Thread.sleep(2000);
			System.out.print("\nOk fatto");	
		} 
		catch (InterruptedException e)
		{
			e.printStackTrace();
		}
		catch(InvocationTargetException e)
		{
			e.printStackTrace();
		}
	}
}
public class Inverti implements Runnable
{
	public void run()
	{
		Icon tmp=Finestra.icona.getIcon();		
		Finestra.icona.setIcon(Finestra.altraIcona.getIcon());
		Finestra.altraIcona.setIcon(tmp);
	}
}

Il risultato è quello che mi aspetto, volevo sapere se sto facendo il tutto in modo corretto

[andbin]

Il risultato è quello che mi aspetto, volevo sapere se sto facendo il tutto in modo corretto

A dire il vero, il fatto che nel run di Esecutore lo sleep lo usi solo per aspettare a scrivere "Ok fatto" rende di fatto inutile tutta la faccenda, se non appunto per l'attesa della scritta.

Comunque hai fatto tante classi separate e quindi hai dovuto fare cose parecchio brutte. Hai messo campi static accessibili da altre classi e hai acceduto a quei campi es. Finestra.icona.getIcon(). Il design generale delle classi quindi fa abbastanza "acqua".

[Ansharja]

Si certo, quello che volevo testare era se appunto riuscivo a invertire le immagini (e quindi in generale intervenire sull'interfaccia)
prima che il programma si interrompa per un certo periodo.
Solo che speravo che l'invokeAndWait fosse del tutto "bloccante", ma se invece di inserire le istruzioni da fare solo dopo lo sleep del thread all'interno del Run di Esecutore io richiamo il tutto da un metodo di un'altra classe sono sicuro che prima di andare avanti con l'esecuzione delle istruzioni del metodo il thread faccia appunto quello che voglio,cioè aggiornare l'interfaccia, bloccare, e solo dopo andare avanti?

[andbin]

volevo testare era se appunto riuscivo a invertire le immagini

Ma questo lo puoi fare anche senza multi-threading.

prima che il programma si interrompa per un certo periodo.

Non si "interrompe" un bel niente nel tuo caso. Cioè non c'è nulla nella interfaccia che si "blocca".

Solo che speravo che l'invokeAndWait fosse del tutto "bloccante"

invokeAndWait infatti è bloccante. Quando invokeAndWait ritorna, sei sicuro che quel Runnable è stato eseguito nel EDT. Ma il EDT è sicuramente molto libero (hai lanciato un thread a parte proprio per non bloccarlo) e il codice in Inverti è praticamente quasi istantaneo perché fa solo banali get/set su delle proprietà.

ma se invece di inserire le istruzioni da fare solo dopo lo sleep del thread all'interno del Run di Esecutore io richiamo il tutto da un metodo di un'altra classe sono sicuro che prima di andare avanti con l'esecuzione delle istruzioni del metodo il thread faccia appunto quello che voglio,cioè aggiornare l'interfaccia, bloccare, e solo dopo andare avanti?

Il Event Dispatch Thread comunque non lo devi mai tenere "impegnato" tu con operazioni bloccanti, read da file/socket, sleep, ecc...

[Ansharja]

Il Event Dispatch Thread comunque non lo devi mai tenere "impegnato" tu con operazioni bloccanti, read da file/socket, sleep, ecc...

Quindi se io inserissi il metodo sleep all'interno di invokeAndWait sarebbe un problema?
E' che io ho bisogno proprio di fermare tutto, perchè i cambiamenti all'interfaccia devono essere visibili per un certo lasso di tempo prima di farne di successivi e via così...

[andbin]

Quindi se io inserissi il metodo sleep all'interno di [COLOR=#333333]invokeAndWait sarebbe un problema?

Se intendi nel run eseguito dal invokeAndWait, sì, è un problema perché essendo nel EDT lo terresti impegnato tu.

E' che io ho bisogno proprio di fermare tutto

Il fatto di impedire l'uso da parte dell'utente lo si fa facendo in modo che per un certo tot di tempo i componenti rilevanti siano disabilitati o usando dei flag in modo che a livello applicativo non succedano le modifiche.
Non mettendo uno sleep nel EDT.

[Ansharja]

Il fatto di impedire l'uso da parte dell'utente lo si fa facendo in modo che per un certo tot di tempo i componenti rilevanti siano disabilitati o usando dei flag in modo che a livello applicativo non succedano le modifiche.

Si si' questo l'ho già fatto in altre situazioni,cerco di spiegarmi meglio perchè così sto solo girando attorno al problema.
L'applicazione cerca di gestire una partita di carte tra un giocatore (che quindi preme i bottoni) e il computer.
Quando il giocatore preme il bottone della carta setto le icone delle label in modo da mostrare la carta scelta,poi tocca al computer.
Il problema viene fuori quando il computer fa due mosse consecutive: devo trovare il modo di aggiornare la JLabel corrispondente alla mossa, lasciarla visibile per un certo periodo (per quello volevo usare lo sleep), dopodichè il computer fa un altra mossa e rendo visibile pure quella.Da questo momento in poi non serve più bloccare perchè tanto la mossa successiva toccherà per forza al giocatore.
Se in quel periodo io tengo impegnato l'EDT non dovrebbe essere un problema perchè un azione da parte dell'utente sarebbe comunque da ignorare,a meno che così non nascano ulteriori problemi...