Swing Swing ist zu schnell für Multithreading

[DerEisteeTrinker]

Einen wundervollen,

so jetzt bin ich auch mal dran, dass mich gehelft wird

Ich habe eine Swing-Anwendung in einem JDK 1.5. Ist vom Auftraggeber vorgegeben. Innerhalb dieser Anwendung soll der Benutzer einen Ordner angeben und alle darin befindlichen Dateien sollen eingelesen werden. Beim Einlesen werden noch Informationen über die Datei gesammelt, was bei einigen Daten etwas dauert. Sprich ich möchte dem Benutzer in dieser Zeit etwas grafisches geben und dachte da an ein JProgressBar. Die Pfad-Auswahl, den Einlese-Algorithmus und der Fortschrittsbalken stehen schon. Der Fortschrittsbalken liegt auf einem modalen Dialog der von einem ActionListener instanziiert wird. Nun starte ich den Thread.

Thread:

public class PreviewPreWorkingThread extends Thread {

	private static final Logger logger = Logger.getLogger(PreviewPreWorkingThread.class);
	
	private Upload upload;
	private IProgressDialog<Collection<Upload>> dialog;
	
	private boolean finish = false;
	
	@Override
	public void run() {
		super.run();
		
		dialog.setVisible(true);
		
		if (logger.isTraceEnabled()) {
			logger.trace("Thread für die Vorbereitung der Vorschau wurde betreten");
		}
		Collection<Upload> resultCollection = new LinkedList<Upload>();
		File directory = new File(upload.getPfad());
		
		dialog.updateProgress(0, "-----", "Vorbereitungen für das Einlesen!");
		
		try {
			File[] listFiles = directory.listFiles();
			
			int count = 0, max = listFiles.length;
			
			dialog.setProgressMinMax(count, max + 1);
			
			for (File f : listFiles) {
				if (logger.isDebugEnabled()) {
					logger.debug("Datei " + count + " von " + max + " ist '" + f.getName() + "'");
				}
				
				dialog.updateProgress(count, count + " / " + max, f.getName());
				
				resultCollection.add(
						new Upload(
								upload.getUmgebung(),
								upload.getVerfahren(),
								upload.getBenutzer(),
								upload.getArt(),
								upload.getSubject(),
								f.getPath()));
				
				count++;
			}
			
			dialog.setResults(resultCollection);
			dialog.setVisible(false);
			
		} catch (Exception e) {
			logger.error(e.getMessage(), e);
			
			resultCollection = null;
			dialog.setVisible(false);
		}
		
		finish = true;
		
		if (logger.isTraceEnabled()) {
			logger.trace("Thread für die Vorbereitung der Vorschau wird verlassen");
		}
	}
	
	public PreviewPreWorkingThread(IProgressDialog<Collection<Upload>> dialog, Upload upload) {
		this.upload = upload;
		this.dialog = dialog;
	}
	
	public boolean isFinish() {
		return finish;
	}
}

Action:

public class FolderPreviewAction implements ActionListener {

	private static final Logger logger = Logger.getLogger(FolderPreviewAction.class);
	private static Resource resource = SpringApplicationContextAware.getResourceBundleFactory();
	private IFilePanel panel;
	
	public void actionPerformed(ActionEvent e) {
		if (logger.isTraceEnabled()) {
			logger.trace("Preview-Aktion aus dem FolderPanel aufgerufen!");
		}
		
		IErrors errors = panel.validateInputs();
		
		if (!errors.hasErrors()) {
			
			Upload upload = panel.getUploadDataObject();
			
			ProgressDialog dialog = new ProgressDialog(panel.getParentFrame(), "Fortschritt");
			
			PreviewPreWorkingThread t = new PreviewPreWorkingThread(dialog, upload);
			SwingUtilities.invokeLater(t);
			
			DialogResults result = dialog.getResult();

			Collection<Upload> results = dialog.getResults();
			
			dialog.dispose();
			
			if (DialogResults.OK == result) {
				System.out.println(results);
			}
			
		} else {
			
			JOptionPane.showMessageDialog(
				(Component) e.getSource(),
				ErrorDialogHelper.getErrorDialogMessage(errors),
				resource.getMessage("dialog.validate"),
				JOptionPane.ERROR_MESSAGE,
				Icons.FAILURE.getIcon());
			
		}
	}

	public FolderPreviewAction(IFilePanel panel) {
		super();
		this.panel = panel;
	}
}

Dialog:

public class ProgressDialog extends AbstractBasicDialog implements IProgressDialog<Collection<Upload>> {

	private static final long serialVersionUID = 1L;
	private static final Logger logger = Logger.getLogger(ProgressDialog.class);
	
	private JProgressBar progress;
	private JLabel label;
	private Collection<Upload> resultCollection;
	
	public ProgressDialog(Frame owner, String title) throws HeadlessException {
		super(owner, title, true, 400, 150);
		
		JPanel contentPanel = getMyContentPanel();
		
		contentPanel.setLayout(new BorderLayout());
		
		contentPanel.setBorder(BorderFactory.createTitledBorder("Fortschritt bei der Vorbeiterung für die Vorschau:"));
		
		progress = new JProgressBar(JProgressBar.HORIZONTAL);
		progress.setString("------");
		progress.setStringPainted(true);
		
		label = new JLabel("", SwingConstants.CENTER);
		label.setPreferredSize(new Dimension(25,25));
		
		contentPanel.add(generateContentPanel(), BorderLayout.CENTER);
	}

	@Override
	protected JPanel generateContentPanel() {
		JPanel panel = new JPanel();
		
		panel.setLayout(new BorderLayout());
		
		JLabel label = new JLabel("Verarbeitete Dateien: ");
		label.setPreferredSize(new Dimension(25,25));
		
		panel.add(label, BorderLayout.PAGE_START);
		
		panel.add(progress, BorderLayout.CENTER);
		
		panel.add(this.label, BorderLayout.PAGE_END);
		
		return panel;
	}

	public Collection<Upload> getResults() {
		return resultCollection;
	}

	public void updateProgress(int value, String msg, String fileName) {
		
		if (logger.isDebugEnabled()) {
			logger.debug("Fortschritt soll auf [Wert=" + value + "] [Nachricht=" + msg + "] [Datei=" + fileName + "] aktualisiert werden.");
		}
		
		label.setText("Verarbeitung der Datei '" + fileName + "' läuft!");
		label.repaint();
		
		progress.setValue(value);
		progress.setString(msg);
		progress.repaint();
	
	}

	public void setProgressMinMax(int min, int max) {
		progress.setMinimum(min);
		progress.setMaximum(max);
	}

	public void setResults(Collection<Upload> results) {
		resultCollection = results;
		if (results != null) {
			result = DialogResults.OK;
		}
	}
}

Das Problem ist, dass der ActionListener schon das Ergebnis des modalen Dialoges abfragt und der steht default-mäßig auf ABORT bei mir. Dann ist es natürlich klar, dass er nicht weitergeht in der Verarbeitung.

Vllt hat jemand eine sinnvolle Idee, wie man diese Zwickmühle löst.

Danke Euer Eistee

 

[Bierhumpen]

Folgende Probleme mit deinem Code:
- dein PreviewPreWorkingThread wird erst gestartet nachdem dein ActionListener schon vorbei ist
-> daraus folgt dass der Fortschrittsdialog überflüssig ist, weil du eh den EDT blockierst damit
- dein Dialog wird auch erst im "WorkingThread" sichtbar gemacht, daher hat die Tatsache dass er modal ist gar keine Relevanz
-> ergo: getResult() kehrt unmittelbar zurück (und liefert abort)

 

[Niki]

ich hab deinen code nur kurz überflogen, denke aber dass du da ein konzeptionelles problem hast. du startest in deiner actionPerformed methode den thread mittels SwingUtilities.invokeLater. das heißt dein Prozess wird auch wieder am EDT ausgeführt, was du ja eben nicht willst. Das sollte eigentlich das sein was du willst:

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
import javax.swing.WindowConstants;

public class MainFrame extends JFrame {
	public MainFrame(){
		super("Background Thread Demo");
		guiInit();
		pack();
		setLocationRelativeTo(null);
		setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
	}

	private void guiInit(){
		Container cont = getContentPane();
		cont.setLayout(new BorderLayout());

		JButton goButton = new JButton("GO");

		cont.add(goButton, BorderLayout.CENTER);


		goButton.addActionListener(new ActionListener() {

			public void actionPerformed(ActionEvent e) {
				Thread t = new Thread(new Runnable(){
					public void run() {
						final ProgressDialog pd = new ProgressDialog(MainFrame.this);
						pd.init(100);
						SwingUtilities.invokeLater(new Runnable(){
							public void run() {
								pd.setVisible(true);
							}
						});

						for(int i = 0; i < 100; i++){
							SwingUtilities.invokeLater(new Runnable(){
								public void run() {
									pd.increment();
								}
							});
							try {
								Thread.sleep(100);
							} catch (InterruptedException e) {
							}
						}

						SwingUtilities.invokeLater(new Runnable(){
							public void run() {
								pd.dispose();
							}
						});
					}
				});
				t.start();
			}
		});
	}

	public static void main(String[] args) {
		SwingUtilities.invokeLater(new Runnable(){
			public void run() {
				new MainFrame().setVisible(true);
			}
		});
	}
}

und der Dialog:

import java.awt.BorderLayout;
import java.awt.Container;

import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JProgressBar;
import javax.swing.WindowConstants;

public class ProgressDialog extends JDialog {

	private JProgressBar progressBar = null;

	public ProgressDialog(JFrame parent) {
		super(parent, "Progress", true);

		Container cont = getContentPane();
		cont.setLayout(new BorderLayout());

		progressBar = new JProgressBar();
		cont.add(progressBar, BorderLayout.CENTER);

		setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
		pack();
		setLocationRelativeTo(parent);
	}

	public void init(int max){
		progressBar.setMaximum(max);
	}

	public void reset(){
		progressBar.setValue(0);
	}

	public void increment(){
		progressBar.setValue(progressBar.getValue()+1);
	}

	public void setValue(int value){
		progressBar.setValue(value);
	}

}

//EDIT

diese ganzen invokeLater calls könnte man auch direkt im ProgressDialog machen, das würd den Code dann weniger aufblähen. Die Regel ist eigentlich ganz einfach: lange Aktionen vom EDT trennen, alle GUI Änderungen am EDT ausführen

 

[DerEisteeTrinker]

Danke Jungs und Mädels,

da sieht man den Wald vor lauter Bäumen nicht

t.start() statt invokeLater sollte helfen xD


Danke für die Denkhilfe, aber ich glaube ich muss noch zurück ans Zeichenbrett, denn ich glaube der Ansatz mit den Threads ist schon falsch. Denn ich brauche die eingelesenen Daten um die nächste View zu erstellen. Sprich das Hauptprogramm würde nur einen Thread anwerfen um auf ihn zuwarten, das er fertig wird. Sprich ich versuch das im Haupt-Thread zu lassen.

Son sch*piep* wieder Stunden für umsonst gearbeitet *wie ein Rumpelstielzchen umherhüpf und aufstampf*

 

[Gast2]

Schau dir den SwingWorker an, denke das ist genau was du suchst...

 

[Gast2]

t.start() statt invokeLater sollte helfen xD

nein wird es nicht, weil du in deinem Thread auf GUI Elemente zugreifst und diese müssen im EDT bearbeitet werden d.h. da musst du deine beiden Threads synchroniseren...

 

[DerEisteeTrinker]

JRE 1.5 nicht 1.6

 

[Gast2]

JRE 1.5 nicht 1.6

???
Den SwingWorker kann man sich als jar herunterladen?

 

[DerEisteeTrinker]

nein wird es nicht, weil du in deinem Thread auf GUI Elemente zugreifst und diese müssen im EDT bearbeitet werden d.h. da musst du deine beiden Threads synchroniseren...

Dann ist der Ansatz von Niki aber ich glaube auch falsch, weil da der ganze Dialog in einem Thread außerhalb vom EDT läuft. Aber wenn ich so drüber nachdenke, dann könnte ich in dem nebenläufigen Thread vllt ein Event abfeuern oder sogar die Initialisierung der View anstoßen

 

[DerEisteeTrinker]

???
Den SwingWorker kann man sich als jar herunterladen?

Nicht wenn der Kunde keine zusätzlichen libs wünscht. Frag mich nicht, der ist paranoid.

 

[Gast2]

Nicht wenn der Kunde keine zusätzlichen libs wünscht. Frag mich nicht, der ist paranoid.

Okay das ist blöd.
Aber da es ja OpenSource ist , kannst dir den Code ja anschauen und deinen Bedürfnissen anpassen.

 

[SlaterB]

sind anscheinend nur 3 Klassen, wenn du selber irgendwas programmierst kann könnst du die ja als src ganz normal dazupacken

 

[Gast2]

Dann ist der Ansatz von Niki aber ich glaube auch falsch, weil da der ganze Dialog in einem Thread außerhalb vom EDT läuft. Aber wenn ich so drüber nachdenke, dann könnte ich in dem nebenläufigen Thread vllt ein Event abfeuern oder sogar die Initialisierung der View anstoßen

Nee wegen? Er synchronsiert doch alle GUI Operationen im zweiten Thread zum GUI Thread. Passt! So ähnlich macht es der SwingWorker auch.

 

[DerEisteeTrinker]

@SirWayne

Ich muss mich jetzt mal als etwas begriffsstutzig outen

Bei dem Ansatz von Niki gibt es keinen Rückgabewert. Mir geht es in meinem Quellcode (Action Zeile 23 bis 31) um einen Rückgabewert. Wenn der EDT den Nebenläufigen abgesetzt hat, dann läuft er doch weiter? Denn woher soll der EDT wissen, dass er auf den eben abgesetzten Thread warten soll?

 

[Gast2]

@SirWayne

Ich muss mich jetzt mal als etwas begriffsstutzig outen

Bei dem Ansatz von Niki gibt es keinen Rückgabewert. Mir geht es in meinem Quellcode (Action Zeile 23 bis 31) um einen Rückgabewert. Wenn der EDT den Nebenläufigen abgesetzt hat, dann läuft er doch weiter? Denn woher soll der EDT wissen, dass er auf den eben abgesetzten Thread warten soll?

Ja Niki hat auch keine Logik eingebaut sondern dir nur gezeigt wie es GUI technisch möglich ist?

Du sollst im EDT einen Dialog mit JProgressbar anzeigen im Hintergrund Job machst du deine Logik und wenn deine Logik fertig ist signalisierst du deinem Dialog he schließ dich. Der Dialog brauch keinen Rückgabewert. Der Hintergrund Job mit der Logik liefert dir das Result.

Da wo bei Niki Thread.sleep(1000) steht sollest du deine Logik einbauen...

 

[Niki]

der ProgressDialog sollte ja eigentlich gar keinen Rückgabe-Wert haben. Seine Aufgabe ist nur das GUI zu blockieren und dem User den Fortschritt anzuzeigen. Die Arbeit selbst wird im ausgelagerten Thread gemacht, dieser weiß als einziger wie weit er mit der Arbeit ist und aktualisert über den EDT den ProgressDialog

 

[DerEisteeTrinker]

Dann muss ich dem EDT aber auch noch iwie meine Arbeitsergebnisse mitteilen. Denn sonst verschwindet das Zeug ja nur im Nirvana und da kann ich es nicht gebrauchen?

 

[Gast2]

Dann muss ich dem EDT aber auch noch iwie meine Arbeitsergebnisse mitteilen. Denn sonst verschwindet das Zeug ja nur im Nirvana und da kann ich es nicht gebrauchen?

haä??? Ich glaube du hast das Prinzip nicht verstanden^^...


EDIT: Hier Niki sein Code mal ein bischen ausgeschmückt....

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.List;
 
import javax.swing.DefaultListModel;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JList;
import javax.swing.JScrollPane;
import javax.swing.SwingUtilities;
import javax.swing.WindowConstants;
import javax.swing.event.ListSelectionEvent;
 
public class MainFrame extends JFrame {
    public MainFrame(){
        super("Background Thread Demo");
        guiInit();
        pack();
        setLocationRelativeTo(null);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }
    
    private void initProgressDialog(final ProgressDialog pd){
        SwingUtilities.invokeLater(new Runnable(){
            public void run() {
                pd.init(100);
                pd.setVisible(true);
            }
        });
    }
    
    private void closeProgressDialog(final ProgressDialog pd){
        SwingUtilities.invokeLater(new Runnable(){
            public void run() {
                pd.dispose();
            }
        });
    }
    
    private void nextStep(final ProgressDialog pd){
        SwingUtilities.invokeLater(new Runnable(){
            public void run() {
                pd.increment();
            }
        });
    }
    
    private void finishWorkStep(final List<Result> results,final  DefaultListModel listModel){
        SwingUtilities.invokeLater(new Runnable(){
            public void run() {
                for(Result result : results){
                	listModel.addElement(result);
                }
            }
        });
    }
 
    private void guiInit(){
        setLayout(new BorderLayout());
 
        JButton goButton = new JButton("GO");
        add(goButton, BorderLayout.SOUTH);
        final List<Result> results = new ArrayList<Result>();
        final DefaultListModel listModel = new DefaultListModel();
        final JList jList = new JList(listModel);
        add(new JScrollPane(jList), BorderLayout.CENTER);
        
        goButton.addActionListener(new ActionListener() {
 
            public void actionPerformed(ActionEvent e) {
                Thread t = new Thread(new Runnable(){
                    public void run() {
                    	final ProgressDialog pd = new ProgressDialog(MainFrame.this);
                    	initProgressDialog(pd);
 
                        for(int i = 0; i < 100; i++){
                        	nextStep(pd);
                            // hier kommt deine logik hin OHNE Das Sleep
                        	Result result = new Result();
                        	result.setName("Step " + i);
                        	result.setErgebnis(i * i);
                        	results.add(result);
                            try {
                                Thread.sleep(10);
                            } catch (InterruptedException e) {
                            }
                            
                        }
                        //arbeit erledigt
                        closeProgressDialog(pd);
                        finishWorkStep(results, listModel);
                    }
                });
                t.start();

            }
        });
    }
 
    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable(){
            public void run() {
                new MainFrame().setVisible(true);
            }
        });
    }
    
    public static class Result{
    	private String name;
    	private Integer ergebnis;
		public void setName(String name) {
			this.name = name;
		}
		public String getName() {
			return name;
		}
		public void setErgebnis(Integer ergebnis) {
			this.ergebnis = ergebnis;
		}
		public Integer getErgebnis() {
			return ergebnis;
		}
		
		@Override
		public String toString() {
			return name + " " + ergebnis;
		}
    }
}

 

[DerEisteeTrinker]

Jetzt ist der Rubel gerollt. Danke funktioniert. java-forum.org ist doch die beste Anlaufstelle bei Problemen