Threadproblem JTabbedPane

[masterbeef]

Habe eine Klasse die eine JTabbedPane beinhaltet, welche JComponents aufnehmen können soll.
Die JComponents stammen aus unterschiedlichen Threads und repräsentieren diesen.
Ich habe 3 Funktionen. Das loader-objekt ist eine JTabbedPane.
Die Jtabbedpane wird ausgeblendet wenn keine Jcomponents auf ihr liegen.

Folgende Funktionen hat diese Klasse:

...
        private void setLoaderVisible()
	{
		if (loader.getTabCount() == 0)
		{
			loader.setVisible(false);
		} else
		{
			loader.setVisible(true);
		}
	}

	public void removeLoaderComponent(final JComponent component)
	{
		SwingUtilities.invokeLater(new Runnable()
		{

			public void run()
			{
				loader.remove(component);
				setLoaderVisible();
			}
		});
	}

	public void setLoaderComponent(final JComponent component)
	{
		SwingUtilities.invokeLater(new Runnable()
		{

			public void run()
			{
				loader.addTab("Thread " + (loader.getTabCount() + 1), component);
				loader.setSelectedComponent(component);
				setLoaderVisible();
			}
		});
	}
...

Manchmal kommen solche Fehlermeldungen ganz sporadisch:
Exception in thread "AWT-EventQueue-0" java.lang.NullPointerException
at java.awt.Container.createHierarchyEvents(Container.java:1335)
at java.awt.Component.show(Component.java:1268)
at java.awt.Component.show(Component.java:1300)
at java.awt.Component.setVisible(Component.java:1253)
at javax.swing.JComponent.setVisible(JComponent.java:2535)
at javax.swing.plaf.basic.BasicTabbedPaneUI.setVisibleComponent(BasicTabbedPaneUI.java:1401)
at javax.swing.plaf.basic.BasicTabbedPaneUI$TabbedPaneScrollLayout.layoutContainer(BasicTabbedPaneUI.java:2621)

Weiß jemand was ich da falsch mache?

 

[Wildcard]

Die JComponents stammen aus unterschiedlichen Threads und repräsentieren diesen.

Führ das mal näher aus. Hört sich sehr ungesund an.

 

[Guest]

ich führe in extra threads berechnungen aus, die sehr lange dauern jetzt möchte ich diese berechnungen mit jprogressbars anzeigen diese jprogressbars werden eben mit setLoaderComponent() und removeLoaderComponent()
hinzugefügt und falls fertig wieder entfernt.

So hat man dann während des programmlaufs eine JTabbedpane im Vordergrund mit mehreren Tabs die alle Thread 1, Thread 2 etc. heißen und ab und dann wieder von der JTabbedPane entfernt werden.

 

[Guest]

Wende ich das SwingUtilities.invokeLater() nicht richtig an?

 

[Wildcard]

In einem anderen Thread ein GUI Objekt zu erstellen ist keine gute Idee.

 

[Guest]

genau genommen werden die in einem SwingWorker thread erstellt und dort mittels setLoaderComponent() und removeLoaderComponent() benutzt.
Das sollte doch gehen, oder?

 

[Wildcard]

Das hängt davon ab. Im SwingWorker treffen sich mehrere Threads, die Frage ist also wie die Implementierung aussieht.
Warum erstellst du die Komponenten nicht einfach bevor der SwingWorker läuft?

 

[Guest]

Hier mal vereinfacht...
Die Art wie ich Swingworker benutze ist doch korrekt, oder?

public class Main
{
	public static void main(String[] args)
	{
		Window window = new Window();
		LoadingScreen.setWindow(window);
	}
}

import java.awt.Color;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLayeredPane;
import javax.swing.JTabbedPane;

public class Window extends JFrame implements ActionListener
{

	private static final long serialVersionUID = 8642944444967066592L;

	private JTabbedPane loader;

	public Window()
	{
		super();
		JButton button = new JButton("Berechne");
		button.addActionListener(this);
		getContentPane().add(button);
		pack();
		setVisible(true);
		initLoader();
	}

	private void initLoader()
	{
		loader = new JTabbedPane();
		loader.setBackground(Color.LIGHT_GRAY);
		loader.setTabLayoutPolicy(JTabbedPane.SCROLL_TAB_LAYOUT);
		loader.setBorder(BorderFactory.createCompoundBorder(BorderFactory.createLineBorder(Color.GRAY), BorderFactory.createEmptyBorder(2, 2, 2, 2)));
		loader.setSize(new Dimension(600, 65));
		JLayeredPane ebene = getLayeredPane();
		ebene.add(loader, JLayeredPane.POPUP_LAYER);
		setLoaderVisible();
	}

	private void setLoaderVisible()
	{
		if (loader.getTabCount() == 0)
		{
			loader.setVisible(false);
		} else
		{
			loader.setVisible(true);
		}
	}

	public void removeLoaderComponent(final JComponent component)
	{
		SwingWorker worker = new SwingWorker()
		{

			public Object construct()
			{

				return null;
			}

			public void finished()
			{
				loader.remove(component);
				setLoaderVisible();
			}
		};
		worker.start();
	}

	public void setLoaderComponent(final JComponent component)
	{
		SwingWorker worker = new SwingWorker()
		{

			public Object construct()
			{

				return null;
			}

			public void finished()
			{
				loader.addTab("Thread " + (loader.getTabCount() + 1), component);
				loader.setSelectedComponent(component);
				setLoaderVisible();
			}
		};
		worker.start();
	}

	public void actionPerformed(ActionEvent e)
	{
		for (int j = 0; j < 100; j++)
		{
			SwingWorker worker = new SwingWorker()
			{

				public Object construct()
				{
					LoadingScreen s = new LoadingScreen();
					for (int i = 0; i < 100; i++)
						s.setTitle(i + "");
					s.endWithSuccess("Erfolg.");
					return null;
				}

				public void finished()
				{
				}
			};
			worker.start();
		}
	}

}

class WindowClosingAdapter extends WindowAdapter
{

	private boolean exitSystem;

	public WindowClosingAdapter(boolean exitSystem)
	{
		this.exitSystem = exitSystem;
	}

	public void windowClosing(WindowEvent event)
	{
		event.getWindow().setVisible(false);
		event.getWindow().dispose();
		if (exitSystem)
			System.exit(0);
	}
}

import java.awt.BorderLayout;
import java.awt.Dimension;

import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JProgressBar;

public class LoadingScreen
{

	private static final long serialVersionUID = -5952541571303829093L;

	private static Window mainwindow;

	private JProgressBar statusbar;

	private JLabel title;

	private JPanel panel;

	public LoadingScreen()
	{
		LoadingScreen.mainwindow.setEnabled(false);
		setMainWindowEditable(false);
		title = new JLabel("Aktion wird gestartet...");
		statusbar = new JProgressBar();
		statusbar.setBorderPainted(false);
		statusbar.setStringPainted(true);
		setIndeterminate(true);
		panel = new JPanel(new BorderLayout(5, 5));
		panel.setPreferredSize(new Dimension(550, 40));
		panel.add(title, BorderLayout.NORTH);
		panel.add(statusbar, BorderLayout.CENTER);
		mainwindow.setLoaderComponent(panel);
	}

	public static void setWindow(Window grundFenster)
	{
		LoadingScreen.mainwindow = grundFenster;
	}

	private void setMainWindowEditable(boolean bool)
	{
		if (bool)
			mainwindow.removeLoaderComponent(panel);
		mainwindow.setEnabled(bool);
	}

	public void setProgressMaximum(int max)
	{
		statusbar.setMaximum(max);
	}

	public void setProgress(int prozent)
	{
		setIndeterminate(false);
		statusbar.setValue(prozent);
	}

	public int getProgress()
	{
		return statusbar.getValue();
	}

	public void setTitle(String text)
	{
		title.setText(text);
	}

	public void setIndeterminate(boolean status)
	{
		if (status)
			statusbar.setStringPainted(false);
		else
			statusbar.setStringPainted(true);
		statusbar.setIndeterminate(status);
	}

	public void endWithBugReportAndPause(String fehlermeldung, int seconds)
	{
		setIndeterminate(false);
		setProgress(statusbar.getMaximum());
		for (int i = seconds; i > 0; i--)
		{
			setTitle(fehlermeldung + " Das Fenster schließt in " + i + " Sekunden");
			try
			{
				Thread.sleep(1000);
			} catch (InterruptedException e)
			{
			}
		}
		setMainWindowEditable(true);
	}

	public void endWithBugReportAndPause(String fehlermeldung, Exception exception, int seconds)
	{
		endWithBugReportAndPause(fehlermeldung + " Die Meldung ist: " + exception.getMessage(), seconds);
	}

	public void endWithSuccess(String text)
	{
		if (text != null && !text.equals(""))
		{
			setTitle(text);
		} else
			setTitle("Die Aktion wurde erfolgreich beendet.");
		setProgress(statusbar.getMaximum());
		for (int i = 1; i > 0; i--)
		{
			try
			{
				Thread.sleep(200);
			} catch (InterruptedException e)
			{
			}
		}
		setMainWindowEditable(true);
	}

	public void endWithSuccess(String text, int seconds)
	{
		if (text != null && !text.equals(""))
		{
			setTitle(text);
		} else
			setTitle("Die Aktion wurde erfolgreich beendet.");
		setProgress(statusbar.getMaximum());
		for (int i = seconds; i > 0; i--)
		{
			if (text != null && !text.equals(""))
			{
				setTitle("Die Aktion wurde erfolgreich beendet " + " in " + i + " Sekunden.");
			}
			setTitle(text + " Das Fenster schließt  in " + i + " Sekunden");
			try
			{
				Thread.sleep(1000);
			} catch (InterruptedException e)
			{
			}
		}
		setMainWindowEditable(true);
	}

}

 

[Wildcard]

Welcher SwingWorker ist das? Der SwingWorker der Java Klassenbibliothek sieht anders aus.

 

[Guest]

denn hab ich mal im netz aufgegabelt. Verstehen tu ich ihn nicht wirklich, aber funktionieren tut er, denk ich =)
Aber ansonsten wende ich das korrekt an?

 

[Guest]

So sieht er aus

import javax.swing.SwingUtilities;

public abstract class SwingWorker
{

	private static class ThreadVar
	{

		private Thread thread;

		ThreadVar(Thread t)
		{
			thread = t;
		}

		synchronized Thread get()
		{
			return thread;
		}

		synchronized void clear()
		{
			thread = null;
		}
	}

	private Object value;

	private ThreadVar threadVar;

	public abstract Object construct();

	public SwingWorker()
	{
		final Runnable doFinished = new Runnable()
		{

			public void run()
			{
				finished();
			}
		};
		Runnable doConstruct = new Runnable()
		{

			public void run()
			{
				try
				{
					setValue(construct());
				}
				catch (Exception e)
				{
					System.err.print("Fehler in neuem Thread: ");
					e.printStackTrace();
				}
				finally
				{
					threadVar.clear();
				}
				SwingUtilities.invokeLater(doFinished);
			}
		};
		Thread t = new Thread(doConstruct);
		threadVar = new ThreadVar(t);
	}

	public void start()
	{
		Thread t = threadVar.get();
		if (t != null)
		{
			t.start();
		}
	}

	public Object get()
	{
		while (true)
		{
			Thread t = threadVar.get();
			if (t == null) { return getValue(); }
			try
			{
				t.join();
			}
			catch (InterruptedException e)
			{
				Thread.currentThread().interrupt();
				return null;
			}
		}
	}

	protected synchronized Object getValue()
	{
		return value;
	}

	private synchronized void setValue(Object x)
	{
		value = x;
	}

	public void finished()
	{
	}

	public void interrupt()
	{
		Thread t = threadVar.get();
		if (t != null)
		{
			t.interrupt();
		}
		threadVar.clear();
	}
}

 

[Wildcard]

Wie du siehst wird construct() bei diesem SwingWorker nicht im EDT ausgeführt, die GUI Objekte darfst du also dort nicht anfassen.

 

[Guest]

Das heißt dann das ist falsch und Loadingscreen darf ich nicht in construct() erzeugen?
Dann kann ich während einer intensiven Berechnung aber nicht die Progressbar updaten..

...
 SwingWorker worker = new SwingWorker()
         {

            public Object construct()
            {
               [b]LoadingScreen s = new LoadingScreen();[/b]
               for (int i = 0; i < 100; i++)
                  s.setTitle(i + "");
               s.endWithSuccess("Erfolg.");
               return null;
            }

            public void finished()
            {
            }
         };
         worker.start(); 
...

Is so dann besser?

...
 SwingWorker worker = new SwingWorker()
         {

            public Object construct()
            {
             
            }

            public void finished()
            {
               [b]LoadingScreen s = new LoadingScreen();[/b]
               for (int i = 0; i < 100; i++)
                  s.setTitle(i + "");
               s.endWithSuccess("Erfolg.");
               return null;
            }
         };
         worker.start(); 
...

 

[Wildcard]

-Erzeug die Komponente einfach vorher
-verzichte ganz auf den SwingWorker
-nimm den der bei Java dabei ist

Alles drei würde funktionieren