Swing Die ProgressBar wird nicht angezeigt

[PJ]

Zunächst eine kleine Beschreibung meines Problems:
Das Hauptfenster meines Programms besitzt einfach nur eine Toolbar, in der ein Button "Save..." existiert.
Klickt man auf den Button, dann soll ein Fenster mit einer Progressbar erscheinen und im Hintergrund werden Daten gespeichert. Der Speicherfortschritt soll mit der Progressbar gezeigt werden. Das Fenster mit der ProgressBar ist aber weiß, solange gespeichert wird. Erst nachdem der Speicherprozess beendet wurde, wird die ProgressBar angezeigt. Ich habe bereits im Internet recherchiert, dass ein Thread benutzt werden soll und ich benutze beriets einen Thread, aber es funktioniert noch nicht richtig.
Hier nun mein Quelltext des Programms:
Das Hauptfenster wird durch die Java-datei MainGUI.java definiert.
Der Quelltext von MainGUI.java ist folgender:

package progressBarExample;

import progressBarExample.Serialization;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Toolkit;
import java.io.File;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JToolBar;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;


import progressBarExample.SaveProgress;

/**
 * @author pjx
 *
 */
public class MainGUI {
	private JFrame mainWindow;
	private JToolBar mainGuiMenuToolBar;
	private JButton saveModelButton;
	private SaveProgress windowSaveProgress;
	private Serialization serialization = new Serialization();
	
	public MainGUI(){
		// Create the frame
		mainWindow = new JFrame("Processing SHEMAT");
		// Set the location of the frame as top centered
		int x = (int) (Toolkit.getDefaultToolkit().getScreenSize().width * 0.125);
		int y = 0;
		mainWindow.setLocation(x, y);
		// Set the size of the frame
		int mainWindowWidth = (int) (Toolkit.getDefaultToolkit().getScreenSize().width * 0.75);
		int mainWindowHeight = (int)(Toolkit.getDefaultToolkit().getScreenSize().height * 0.9);
		mainWindow.setPreferredSize(new Dimension(mainWindowWidth,mainWindowHeight));
		mainWindow.setMinimumSize(new Dimension(mainWindowWidth,mainWindowHeight));
		mainWindow.setMaximumSize(new Dimension(mainWindowWidth,mainWindowHeight));
		// Behavior, when the frame closes.
		mainWindow.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);		
		// The toolbar of the main gui and its elements:
		BorderLayout mainFrameLayout = new BorderLayout();
		mainWindow.setLayout(mainFrameLayout);
		mainGuiMenuToolBar = new JToolBar();
		mainGuiMenuToolBar.setFloatable(false);
		mainGuiMenuToolBar.setRollover(true);
		mainGuiMenuToolBar.setCursor(new java.awt.Cursor(java.awt.Cursor.DEFAULT_CURSOR));
		mainGuiMenuToolBar.setDoubleBuffered(true);
		// Add a button to the toolbar
		saveModelButton = new JButton();
		saveModelButton.setText("Save...");
                saveModelButton.setToolTipText("Save model...");
                saveModelButton.setFocusable(false);
                saveModelButton.setHorizontalTextPosition(javax.swing.SwingConstants.CENTER);
                saveModelButton.setVerticalTextPosition(javax.swing.SwingConstants.BOTTOM);
                saveModelButton.addActionListener(new java.awt.event.ActionListener(){
        	public void actionPerformed(java.awt.event.ActionEvent evt) {
        		saveModelButtonActionPerformed(evt);
        	}
        });
        mainGuiMenuToolBar.add(saveModelButton);
        mainWindow.getContentPane().add(mainGuiMenuToolBar,BorderLayout.NORTH);
        // Show the frame.
		mainWindow.setVisible(true);
	}
	
	public void saveModelButtonActionPerformed(java.awt.event.ActionEvent evt){
		windowSaveProgress = new SaveProgress();
		// Set the location of the frame as centered
		Toolkit tk = Toolkit.getDefaultToolkit();
	    Dimension screenSize = tk.getScreenSize();
	    int screenHeight = screenSize.height;
	    int screenWidth = screenSize.width;
	    windowSaveProgress.setLocation((screenWidth / 2) - (windowSaveProgress.getWidth() / 2), (screenHeight / 2) - (windowSaveProgress.getHeight() / 2));
	    windowSaveProgress.setVisible(true);
	
		serialization.setWindowSaveProgress(windowSaveProgress);
		Serialization.serialize();
	}
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		try {
            // Use the look of the operating system
			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
	    } 
	    catch (UnsupportedLookAndFeelException e) {
	       // handle exception
	    }
	    catch (ClassNotFoundException e) {
	       // handle exception
	    }
	    catch (InstantiationException e) {
	       // handle exception
	    }
	    catch (IllegalAccessException e) {
	       // handle exception
	    }
		// Create the main window of the program "Processing SHEMAT" and show it.
		MainGUI main = new MainGUI();

	}

}

Das Fenster mit der Progressbar wird duch die Java-datei SaveProgress.java definiert.
Der Quelltext von SaveProgress.java ist folgender:

package progressBarExample;

import java.awt.BorderLayout;
import java.awt.Cursor;
import java.awt.Insets;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.Random;

import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JProgressBar;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.SwingWorker;

/**
 * @author pjx
 *
 */
public class SaveProgress extends JFrame implements PropertyChangeListener{
	private javax.swing.JLabel messageLabel;
	private javax.swing.JButton okCancelButton;
	private static javax.swing.JProgressBar saveProgressBar;
	private static int progressValue = 0;
	private Task task;
  
	public SaveProgress(){	
	  java.awt.GridBagConstraints gridBagConstraints;

	  saveProgressBar = new javax.swing.JProgressBar();
	  messageLabel = new javax.swing.JLabel();
	  okCancelButton = new javax.swing.JButton();
	
	  setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);
	  getContentPane().setLayout(new java.awt.GridBagLayout());
	  gridBagConstraints = new java.awt.GridBagConstraints();
	  gridBagConstraints.gridx = 0;
	  gridBagConstraints.gridy = 1;
	  gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
	  gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
	  gridBagConstraints.weightx = 1.0;
	  gridBagConstraints.insets = new java.awt.Insets(5, 5, 5, 5);
	  getContentPane().add(saveProgressBar, gridBagConstraints);
	  gridBagConstraints = new java.awt.GridBagConstraints();
	  gridBagConstraints.gridx = 0;
	  gridBagConstraints.gridy = 0;
	  gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
	  gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
	  gridBagConstraints.insets = new java.awt.Insets(5, 5, 5, 5);
	  getContentPane().add(messageLabel, gridBagConstraints);
	
	  okCancelButton.setText("Cancel");
	  okCancelButton.addActionListener(new java.awt.event.ActionListener() {
	      public void actionPerformed(java.awt.event.ActionEvent evt) {
	          okCancelButtonActionPerformed(evt);
	      }
	  });
	  gridBagConstraints = new java.awt.GridBagConstraints();
	  gridBagConstraints.gridx = 0;
	  gridBagConstraints.gridy = 2;
	  gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
	  gridBagConstraints.insets = new java.awt.Insets(5, 5, 5, 5);
	  getContentPane().add(okCancelButton, gridBagConstraints);
	
	  pack();
	}
  
	class Task extends SwingWorker<Void, Void> {
		/*
		 * Main task. Executed in background thread.
		 */
		@Override
		public Void doInBackground() {
			int progress = 0;
			//Initialize progress property.
			setProgress(0);
			while (progress < 100) {				
				progress = progressValue;
				setProgress(progress);
			}
			return null;
		}

		/*
		 * Executed in event dispatching thread
		 */
		@Override
		public void done() {
			Toolkit.getDefaultToolkit().beep();
			setCursor(null); //turn off the wait cursor
			messageLabel.setText("Done!\n");
		}
	}
  
	private void okCancelButtonActionPerformed(java.awt.event.ActionEvent evt) {
		this.dispose();
	}
  
	public JProgressBar getProgressBar(){
		return saveProgressBar;
	}
  
	public void setMaximum(int value){
		this.saveProgressBar.setMaximum(value);
	}
  
 	public void setValue(int value){
 		this.progressValue = value;
 	}
  
 	public void startProgress(){
 		//Instances of javax.swing.SwingWorker are not reusuable, so
 		//we create new instances as needed.
 		task = new Task();
 		task.addPropertyChangeListener(this);
 		task.execute();
 	}
  
 	public void setProgressValue(int value){
 		progressValue = value;
 	}
  
 	/**
 	 * Invoked when task's progress property changes.
 	 */
 	public void propertyChange(PropertyChangeEvent evt) {
 		if ("progress" == evt.getPropertyName()) {
 			int progress = (Integer) evt.getNewValue();
 			saveProgressBar.setValue(progress);
 			messageLabel.setText(String.format(
 					"Completed %d%% of task.\n", task.getProgress()));
      	} 
	}
  
}

Das Speichern der Daten wird durch die Java-datei Serialization.java realisiert.
Der Quelltext von Serialization.java ist folgender:

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Iterator;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.Vector;


/**
 * @author pjx
 *
 */
public class Serialization {
	private static SaveProgress windowSaveProgress;	
	
	public void setWindowSaveProgress(SaveProgress sp){
		windowSaveProgress = sp;
	}
	
	public static void serialize(){
		try {
		  int val = 0;
		  Random random = new Random();
		  windowSaveProgress.setMaximum(100);
		  windowSaveProgress.startProgress();
		  FileOutputStream file = new FileOutputStream( "J:\\Test.txt" );
		  ObjectOutputStream o = new ObjectOutputStream( file );
	      for(int i = 0; i < 100; ++i){
	    	//Sleep for up to one second.
				try {
					Thread.sleep(random.nextInt(1000));
				} catch (InterruptedException ignore) {}
	    	  o.writeObject(new Integer(i));
  			  val++;
	      	  windowSaveProgress.setProgressValue(val);
	      }
	      o.close();
	    }
	    catch ( IOException e ) { 
	    	System.err.println( e ); 
    	}
	}
	
	public static void deserialize(){
		try {
			int val = 0;
			windowSaveProgress.setMaximum(100);
			windowSaveProgress.startProgress();
			FileInputStream file = new FileInputStream( "J:\\Test.txt" );
			ObjectInputStream o = new ObjectInputStream( file );
			for(int i = 0; i < 100; ++i){
				int readedValue = (Integer)o.readObject();
				val++;
				windowSaveProgress.setProgressValue(val);
			}
			o.close();
	    }
	    catch ( IOException e ) { 
	    	System.err.println( e ); 
    	} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}		
	}	
}

Für Hilfe oder Anregungen wäre ich dankbar.
Mit freundlichen Grüßen
PJ

 

[Michael...]

Ganz schön viel - teileweise scheinbar zusammen kopierterer Code - für so eine kleine Anforderung.
Da scheint (viel zu viel) ungenutzter Code mit dabei zu sein.
Sieht nach Standardanfänger Problem aus. Wo benutzt Du denn einen Thread - habe nirgends was gefunden.
In Deiner SaveProgress definierst Du eine SwingWorker Klasse - wird die auch genutzt?
Prinzipiell muss das "Speichern" in einem anderen Thread als im EDT passieren.
Fazit: Erst einmal kleinere Brötchen backen. Im Netz gibt sicher auch ne Demo zur Nutzung eine ProgressBar und wie ein SwingWorker da eingesetzt werden kann.

 

[bERt0r]

Du rufst deine Serialisation im EDT auf und leitest Progressmeldungen an deinen WorkerThread weiter. Das führt den nutzen des WorkerThreads ad absurdum. Es gibt den Worker, damit man darin the langwierigen Berechnungen durchführen kann. Eine statische serialize Methode ist ohnehin seltsam.

 

[PJ]

Soll ich die Serialisierung zunächst in einen eigenen Thread setzen?

 

[bERt0r]

Die Serialisierung muss in einem eigenen Thread laufen, das Updaten der progressbar gehört in den EDT. Aus diesem Grund gibts den SwingWorker weil man damit einen eigenen Thread hat, darin aber trotzdem Änderungen an den Swingkomponenten durchführen kann ohne Sychronitätsprobleme zu verursachen.

 

[PJ]

Nachdem ich das Speicher/Laden in einen Thread getan habe funktioniert es nun. Ich zeige jetzt nur
nochmal, was ich gemacht habe.
Die Serialisierung in serialization.java habe ich in einen Reader und Writer aufgeteilt, die die Schnittstelle Runnable implementieren.
Statt serialization.java habe ich also Reader.java und Writer.java.
Quelltext von Reader.java:

package progressBarExample;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.Random;

/**
 * @author pjx
 *
 */
public class Reader implements Runnable{
	private static SaveProgress windowSaveProgress;
	
	public void setWindowSaveProgress(SaveProgress sp){
		windowSaveProgress = sp;
	}
	
	public void readData(){
		try {
			  int val = 0;
			  Random random = new Random();
			  windowSaveProgress.setMaximum(100);
			  windowSaveProgress.startProgress();
			  FileOutputStream file = new FileOutputStream( "J:\\Test.txt" );
			  ObjectOutputStream o = new ObjectOutputStream( file );
		      for(int i = 0; i < 100; ++i){
		    	//Sleep for up to one second.
					try {
						Thread.sleep(random.nextInt(1000));
					} catch (InterruptedException ignore) {}
		    	  o.writeObject(new Integer(i));
	  			  val++;
		      	  windowSaveProgress.setProgressValue(val);
		      }
		      o.close();
		    }
		    catch ( IOException e ) { 
		    	System.err.println( e ); 
	    	}
	}
	
	@Override
	public void run() {
		readData();
	}

}

Quelltext von Writer.java:

package progressBarExample;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

/**
 * @author pjx
 *
 */
public class Writer implements Runnable{
	private static SaveProgress windowSaveProgress;	
	
	public void setWindowSaveProgress(SaveProgress sp){
		windowSaveProgress = sp;
	}
	
	public void writeData(){
		try {
			int val = 0;
			windowSaveProgress.setMaximum(100);
			windowSaveProgress.startProgress();
			FileInputStream file = new FileInputStream( "J:\\Test.txt" );
			ObjectInputStream o = new ObjectInputStream( file );
			for(int i = 0; i < 100; ++i){
				int readedValue = (Integer)o.readObject();
				val++;
				windowSaveProgress.setProgressValue(val);
			}
			o.close();
	    }
	    catch ( IOException e ) { 
	    	System.err.println( e ); 
    	} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}	
	}
	
	@Override
	public void run() {
		writeData();
	}

}

In MainGui.java habe ich die Methode saveModelButtonActionPerformed wie folgt geändert:

public void saveModelButtonActionPerformed(java.awt.event.ActionEvent evt){
		windowSaveProgress = new SaveProgress();
		// Set the location of the frame as centered
		Toolkit tk = Toolkit.getDefaultToolkit();
	    Dimension screenSize = tk.getScreenSize();
	    int screenHeight = screenSize.height;
	    int screenWidth = screenSize.width;
	    windowSaveProgress.setLocation((screenWidth / 2) - (windowSaveProgress.getWidth() / 2), (screenHeight / 2) - (windowSaveProgress.getHeight() / 2));
	    windowSaveProgress.setVisible(true);
	    
	    // jetzt:
	    reader.setWindowSaveProgress(windowSaveProgress);
	    new Thread(reader).start();
	    // vorher:
//		serialization.setWindowSaveProgress(windowSaveProgress);
//		Serialization.serialize();
	}

SaveProgress.java blieb gleich.
Mit diesen Änderungen funktioniert nun mein Programm.
Vielen Dank für eure Hilfe
Mit freundlichen Grüßen
PJ