Serializzazione delle operazioni

[giaomnitel1]

Ciao ragazzi,
sto avendo un piccolo problema con Java...

In pratica nella mia applicazione c'è un algoritmo che prende 4-5 secondi per essere eseguito (poichè un pò pesantuccio)....
Vorrei semplicemente fare questa cosa:

1) Mostrare una finestra di notifica che dice: "attendere prego.."
2) Lanciare l'esecuzione dell'algoritmo...
3) Chiudere la finestra di notifica

Ma a quanto pare...quando si apre la finestra di notifica...essa è trasparente (senza contenuto)...e si riempie solamente quando termina l'algoritmo....per poi chiudersi subito.

Esiste un modo per far iniziare l'esecuzione dell'algoritmo solo dopo che la finestra di notifica è realmente visualizzata?
Grazie

[andbin]

Originariamente inviato da giaomnitel1
In pratica nella mia applicazione c'è un algoritmo che prende 4-5 secondi per essere eseguito (poichè un pò pesantuccio)....
Vorrei semplicemente fare questa cosa:

1) Mostrare una finestra di notifica che dice: "attendere prego.."
2) Lanciare l'esecuzione dell'algoritmo...
3) Chiudere la finestra di notifica

Ma a quanto pare...quando si apre la finestra di notifica...essa è trasparente (senza contenuto)...e si riempie solamente quando termina l'algoritmo....per poi chiudersi subito.

Qui bisognerebbe prima capire in quale contesto (parlo di "thread") stai facendo eseguire questo algoritmo. In pratica dovresti spiegare quando e a seguito di che cosa intendi far partire questo algoritmo.

Ah, stai usando Swing?

[giaomnitel1]

Si...sto usando swing...l'algoritmo parte semplicemente a seguito di un click su un pulsante...non ho gestito esplicitamente i thread...qualche suggerimento?

[andbin]

Originariamente inviato da giaomnitel1
Si...sto usando swing...l'algoritmo parte semplicemente a seguito di un click su un pulsante...non ho gestito esplicitamente i thread...qualche suggerimento?

Appunto ... il punto è sempre il solito (già discusso in lungo e in largo sul forum) .... ovvero le questioni di threading in Swing.
Quando un metodo di un listener viene invocato, si è nel contesto del EDT. Questo è il thread di gestione della interfaccia utente, che non va mai bloccato per troppo tempo pena "congelamento" della interfaccia utente più altri effetti strani/indesiderati di non aggiornamento.

Ti suggerisco di leggere Threads and Swing

[giaomnitel1]

Ok grazie...darò un'occhiata a quell'articolo e ti farò sapere

[giaomnitel1]

Ho fatto qualche tentativo con la classe SwingWorker spiegata in quell'articolo..ma purtroppo senza successo. Il problema è che non posso avviare il thread prima del click sul pulsante...

Io voglio semplicemente realizzare questo:
-Clicco sul pulsante
-Visualizzo una finestrella di notifica che dice di attendere
-Parte l'algoritmo pesante
-Finito l'algoritmo pesante, scompare la notifica e appare il risultato


Ho fatto cosi ma pare non funzionare, ovvero la finestra di notifica mi appare sempre trasparente:

Classe che esegue l'algoritmo (di nome FrontController):

	public static BufferedImage correggiImmagine(BufferedImage image)
	{
		immagineDaCorreggere=image;

		SwingWorker worker=new SwingWorker()
		{
			public Object construct()
			{
				GestoreImmagine gestore=new GestoreImmagine(immagineDaCorreggere);
				return gestore.correctSkew();
			}
		};
		worker.start();
		return (BufferedImage)worker.get();
        }

Evento della JFrame:

	private void btnApriActionPerformed(ActionEvent evt) {
		
		//Ottiene l'immagine dal filesystem
		BufferedImage nuovaImmagine=FrontController.apriImmagine();
		
		if(nuovaImmagine!=null)
		{
			//Setta l'attributo di classe
			imgOriginale=nuovaImmagine;
		
			//Imposta l'immagine nell'area dell'immagine originale e la disegna
			canvasImgOriginale.setImage(imgOriginale);
			
			F_Correzione notifica=new F_Correzione(this);
			notifica.setLocationRelativeTo(this);
			notifica.setVisible(true);

			//Ottiene l'immagine corretta
			imgCorretta=FrontController.correggiImmagine(imgOriginale);
						
			//Imposta l'immagine nell'area dell'immagine corretta e la disegna
			canvasImgCorretta.setImage(imgCorretta);
			
			notifica.setVisible(false);		
			//Attiva il pulsante per il salvataggio dell'immagine corretta
			btnSalva.setEnabled(true);
		}
	}

Secondo me il problema è che comunque avvio il thread alla pressione del pulsante (è posso farlo solo dopo la pressione del pulsante)...e di fatto non ho risolto nulla.
Qualche suggerimento? Grazie e Buona Pasqua a tutti

[giaomnitel1]

Credo che il problema sia che worker.get ( ) blocca comunque l'EDT finchè non è completo lo SwingWorker.....ma non riesco ancora a trovare una soluzione..

Sarebbe possibile un piccolo esempio?
Quello che mi serve è che alla pressione di un bottone accada questo:
1) apparizione di una JDialog che notifichi di aspettare
2) esecuzione di algoritmo lungo
3) scomparizione della JDialog di notifica
4) comparsa del risultato dell'algoritmo ...

[Andrea1979]

Ti posto un esempio che fa uso di Timer

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.Timer;
import java.util.TimerTask;
import java.util.Date;

/**
 *
 * @author Andrea
 */
public class ExpensiveTest extends JFrame implements ActionListener {
    
    JTextField tf;
    JButton start;
    boolean flag = false;

    public void actionPerformed (ActionEvent ae) {
        if (!flag) {
            Date d = new Date();
            Timer t = new Timer();
            t.schedule(new TimerTask() {
                public void run() {
                    flag = true;
                    for (int i = 0; i < 1000000; i++) {
                        tf.setText("Aggiornamento: "+i);
                    }
                    flag = false;
                }            
            }, d);
        }
    }

    public ExpensiveTest() {
        super("this is a test");
        this.getContentPane().setLayout(new BorderLayout());        
        
        tf = new JTextField();
        tf.setColumns(10);
        start = new JButton("Start");
        JPanel north = new JPanel(new GridLayout(1,2));
        north.add(tf);
        north.add(start);
        this.getContentPane().add(north, BorderLayout.NORTH);

        JTextArea ta = new JTextArea();
        
        this.getContentPane().add(new JScrollPane(ta), BorderLayout.CENTER);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        start.addActionListener(this);
        this.setSize(400,300);
        this.setVisible(true);
    }

    public static void main (String[] args) {
        new ExpensiveTest();
    }

}

Esiste anche una classe Timer in Swing di cui onestamente non conosco i dettagli (ma mi pare che sia una versione "semplificata", ovvero meno customizabile, della classe Timer in util). Il mio esempio non vuole essere modello di buona programmazione, ma solo una traccia.

[giaomnitel1]

Ma timer serve ad eseguire un'operazione ogni tot tempo....a quanto ho capito dalla documentazione...

[Andrea1979]

Timer può servire per eseguire un'operazione

- ogni tot tempo
- dopo tot tempo
- ogni tot tempo dopo un certo tempo.

nel mio caso, esegue l'operazione una sola volta, immediatamente dopo il click sul bottone di start. Come potrai notare, se esegui la classettina che ho postato, è ancora possibile scrivere nella textarea sottostante mentre il textfield viene aggiornato con quel ciclo for indegno.
Il flag booleano mi serve solo per assicurarmi che il task non venga avviato più volte contemporaneamente (ovvero successive pressioni sul bottone "Start" saranno ignorate nel caso in cui vi sia ancora il task precedente in esecuzione)