Progressbar mit Rückgabe-Wert nach Speichern

[amaier]

Hallo zusammen,

ich verwende für ein Projekt das JDK 1.5 und es wird demnächst nicht auf das JDK 1.6 umgestellt.

In dem Projekt verwendete ich eine Verarbeitungs-Routine. Während der Verarbeitungs-Routine läuft eine JProgressbar im Vordergrund, um die Verarbeitung für den Benutzer zu optisch hervorzuheben. Zu der Verarbeitungs-Routine verwende ich

java.lang.Thread

und

java.lang.Runnable

, damit die JProgressbar das zeichnen im DispatchEvent Thread nicht unterbricht.

Jetzt stehe ich vor dem Problem, dass die Verarbeitungs-Routine ein Rückgabewert zurück liefern soll (Verarbeitung erfolgreich/nicht erfolgreich).

Das Runnable-Objekt liefert keinen Rückgabewert und wenn ich Collable verwende, dann hängt sich der DispatchEvent Thread auf.

Könnt ihr mir dabei bitte helfen? Die Progressbar muss weiter selbstständig zeichnen, die Verarbeitungs-Routine laufen und einen Rückgabewert (return-Wert) liefern. Danke!

Gruß
amaier

 

[Flo<H>]

Hallo!
Was mir so spontan dazu einfällt wäre das Observer Pattern. Beispielweise meldest du an dem Thread der den Wert zurückliefern soll einen Listener an. Und wenn der Thread fertig ist, informiert er als letzte Aktion noch die Listener.
mfg flo

 

[amaier]

Danke für die sehr schnelle Antwort.

Leider ist es nicht die Lösung, die ich mir erhoffe. Ich habe mit Swing und dem Dispatch-Event-Thread zu kämpfen. Ich möchte dass die Progressbar sich ständig neu zeichnet, obwohl der DispatchEvent Thread auf ein Ergebnis aus der Verarbeitungs-Routine erwartet.

 

[Flo<H>]

Hm, ich denke ich habe vergessen zu sagen, dass die Verarbeitungsroutine weiterhin in einem eigenen Thread laufen muss. Irgendwo wirst du ja diese Routine erstellen und den Thread starten. Hier hast du ja Zugriff auf diese Routine und kannst deinen Listener anmelden.
Die Verarbeitungsroutine läuft dann in einem eigenen Thread und sollte den EventDispatchThread nicht blocken und über den Listener kann eine "Rückgabewert" übergeben werden wenn die Verarbeitungsroutine fertig ist.
mfg flo

 

[amaier]

Mit welchen Threads arbeitest du? Wenn ich einen Thread mit

new Thread(new Runnable()
  public void run() {
  }
).start();

initialisiere, dann habe ich hier keinen Rückgabewert oder?

 

[Flo<H>]

Nein, hier hast du keinen Rückgabewert. Deswegen meinte ich ja dass du hier einen Listener anmelden sollst:

MyThread myThread = new MyThread(); // MyThread implements Runnable
myThread.addListener(this);
Thread doMyThread = new Thread(myThread);
doMyThread.start();

Somit kann dann myThread über den Listener einen Rückgabewert liefern.

 

[amaier]

Ist es dann so, dass der Rückgabewert nicht im DispatchEvent Thread sondern im erzeugten doMyThread gesetzt wird?

 

[Flo<H>]

Ich hab schnell eine kleines Beispiel geschrieben:

public class MainThread
{
	public static void main(String... args)
	{
		MainThread mainThread = new MainThread();
	}
	
	public MainThread()
	{
		SubThread subThread = new SubThread(this);
		Thread runSubThread = new Thread(subThread);
		runSubThread.start();
		int i = 0;
		while(returnValue.length() == 0)
		{
			try
			{
				Thread.sleep((long) (Math.random() * 50 + 1));
			} 
			catch (InterruptedException e)
			{
				e.printStackTrace();
			}
			System.out.println("MainThread: " + i);
			i++;
		}
		System.out.println("MainThread - ReturnValue of Subthread: " + returnValue);
	}
	
	public void setReturnValue(String rv)
	{
		returnValue = rv;
	}
	
	private String returnValue = "";
}

public class SubThread implements Runnable
{
	public SubThread(MainThread mt)
	{
		mainThread = mt;
	}

	@Override
	public void run()
	{
		for(int i = 0; i < 15; i++)
		{
			try
			{
				Thread.sleep((long) (Math.random() * 50 + 1));
			} 
			catch (InterruptedException e)
			{
				e.printStackTrace();
			}
			System.out.println("Subthread: " + i);
		}
		mainThread.setReturnValue("finished");

	}
	
	private final MainThread mainThread;
}

Output:

MainThread: 0
Subthread: 0
MainThread: 1
MainThread: 2
Subthread: 1
Subthread: 2
Subthread: 3
MainThread: 3
MainThread: 4
Subthread: 4
Subthread: 5
Subthread: 6
MainThread: 5
Subthread: 7
MainThread: 6
MainThread - ReturnValue of Subthread: finished

MainThread startet einen weiteren Thread. Beide Threads laufen parallel. Wenn der Subthread fertig ist übergibt er seinen "Rückgabewert" an den Mainthread.

 

[amaier]

Danke, werde ich testen!

Eine Frage habe ich noch:

Wozu ist im Hauptthread diese Thread.sleep()-Berechnung gut?
(long) (Math.random() * 50 + 1)

Kann das an der Stelle nicht irgendein fester Wert sein? Im SubThread ist diese Berechnung mir klar, um eine Verarbeitung zu simulieren.

 

[Flo<H>]

Die beiden Thread.sleep() mit Random-Zahlen könnten natürlich auch ein fester Wert haben. Hab das bloß schnell bei einer anderen Klasse rauskopiert.