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

Code :

1	java.lang.Thread

und

Code :

1	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

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

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.

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

Mit welchen Threads arbeitest du? Wenn ich einen Thread mit

Code :

1 2 3 4

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

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

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

Code java:

1 2 3 4

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.

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

Ich hab schnell eine kleines Beispiel geschrieben:

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

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 = ""; }

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

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:

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

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.

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.

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.

Hallo,

ich habe jetzt die Thread-Anwendung getestet.

Aber wenn ich auf unsere Produktiv-Anwendung die Thread-Technik zum Laufen kriegen möchte, dann zeichnet meine JProgressBar nicht korrekt neu, obwohl sie ständig von dem Thread durchlaufen wird (unabhängig vom Rückgabetyp des Threads).

Das ganze ist wird über einen JButton - ActionListener aufgerufen. Ich zeige es an meinen aktuellen Code:

Code im Hauptformular

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14

getSuchButton().addActionListener(new ActionListener() {   public void actionPerformed(ActionEvent aActionEvent) {         final ProgressDialog lProgressDialog = new ProgressDialog("Suche...");       new Thread(lProgressDialog).start();         new Thraed(new Runnable() {           public void run() {              // 1. Methodenaufrufe zu SessionBean (Daten holen)              // 2. Methodenaufrufe zu Table (Daten in die Tabelle setzen)           }       }).start();   } });

Code der Progressbar-Dialog

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

public class ProgressDialog extends JDialog implements Runnable {       private static final long   serialVersionUID    = -900018691306280601L;       private boolean         fProgressStart  = false;         private ProgressPanel   fProgressPanel  = null;         private int             fValue          = 0;         public ProgressDialog(String aTitle) {         super(ApplicationSingleton.getInstance().getMainWindowControl().getMainWindowFrame(), aTitle, false);                       fProgressStart = true;                 setLocationRelativeTo(null);                 fProgressPanel = new ProgressPanel(); // enthält Panel mit JProgressbar                                 setLayout(new BorderLayout());         getContentPane().setBackground(new Color(204, 229, 255));         getContentPane().add(fProgressPanel, BorderLayout.CENTER);         setSize(500, 100);           setVisible(true);     }         public void run() {                 boolean lValueAdded = true;                             while (fProgressStart) {                         if (lValueAdded) {                 fValue++;             } else {                 fValue--;             }                                   if (fValue >= 100) {                 lValueAdded = false;                 fValue = 100;             } else if (fValue <= 0) {                 lValueAdded = true;                 fValue = 0;             }                         try {                 Thread.sleep(10);                   EventQueue.invokeLater(new Runnable() {                     public void run() {                         fProgressPanel.getProgressBar().setValue(fValue);                     }                 });                                   } catch (Exception aException) {                 aException.printStackTrace();             }           }           }       @Override     public void dispose() {                 fProgressStart = false;                             setVisible(false);                      super.dispose();     }