Nebenläufige Programmierung

[waste1]

Hallo,
ich habe ein Problem mit Threads. Ich habe auch schon ein wenig hier rumgesucht, aber bin noch nicht fündig geworden. So hoffe ich, dass ihr mir weiterhelfen könnt.

Es wird einfach ein Textfeld und ein Button angezeigt.
In das Textfeld kann man hineinklicken, den Text markieren oder editieren. Soweit so gut. -> OK
Wenn man nun auf den Button klickt, soll im Textfeld der Text verändert und danach ein Thread gestartet werden. Das passiert auch. -> OK
Der Thread dauert 15 Sekunden. -> OK

nun mein Problem:
Während dieser Zeit (solange der Thread läuft) ist die Oberfläche nicht zu benutzen. Aber warum?
Warum blockiert der Thread den Rest? Oder besser, was mache ich genau falsch?
Ich dachte mit display.asyncExec(Thread) erreiche ich einen nebenläufigen Thread.

Ich hätte es gerne so, dass das Textfeld geändert wird, dann der Thread startet und während der Thread läuft sollte die Oberfläche weiter bedienbar sein. (hier also das Textfeld editierbar sein).

Hier mal der Beispielcode:

import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.RowLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;

public class SWTThreadTest extends Thread
{
    private Thread t;
    private Text text;
    
    public static void main(String[] args)
    {
        new SWTThreadTest().start();
    }
    
    public void run()
    {
        final Display display = new Display();
        Shell shell = new Shell(display);

        text = new Text(shell, SWT.NONE);
        text.setText("Noch geht alles. Man kann in diesen Text klicken und ihn markieren");
        
        Button b = new Button(shell, SWT.PUSH);
        b.setText("Klick");
        b.addListener(SWT.Selection, new Listener() 
        {
            public void handleEvent(Event e) 
            {
                t = new Thread()
                {
                    public void run()
                    {                        
                        try
                        {
                            Thread.sleep(10000);
                        }
                        catch (InterruptedException e)
                        {
                            e.printStackTrace();
                        }                        
                        text.setText("Der Thread ist beendet, markieren geht wieder");
                    }
                };
                
                text.setText("Hier ist alles blockiert :( ");
                display.asyncExec(t);
            }
        });
        shell.setLayout(new RowLayout());
        shell.pack();
        shell.open();
        while (!shell.isDisposed()) 
        {
          if (!display.readAndDispatch()) 
            display.sleep();
        }
        display.dispose();
    }
}

Ich danke euch schonmal fürs Lesen und für eventuelle Lösungen.
Ich hoffe wirklich, dass ihr mir helfen könnt.

Gruß
waste1

 

[waste1]

Korrektur:
der Thread dauert natürlich nur 10 Sekunden

 

[Beni]

"asyncExec" ruft die "run"-Methode innerhalb des Gui-Threads (wie auch immer der bei SWT heisst) auf. Du führst hier keinen eigenen Thread aus, sondern lässt einen anderen Thread deinen Code ausführen.

Starte den Thread mit "start()", das "asyncExec" benötigst du nur, um mit der Gui zu kommunizieren (Werte setzen oder lesen, ich geh mal davon aus, dass SWT sowenig threadsicher ist, wie AWT).

 

[waste1]

geht leider nicht, damit bekomme ich eine Exception:

Exception in thread "Thread-0" org.eclipse.swt.SWTException: Invalid thread access
at org.eclipse.swt.SWT.error(SWT.java:3374)
at org.eclipse.swt.SWT.error(SWT.java:3297)
at org.eclipse.swt.SWT.error(SWT.java:3268)
at org.eclipse.swt.widgets.Widget.error(Widget.java:435)
at org.eclipse.swt.widgets.Widget.checkWidget(Widget.java:331)
at org.eclipse.swt.widgets.Text.setText(Text.java:1648)
at swtThreadHangOn.SWTThreadTest$1$1.run(SWTThreadTest.java:46)



Deswegen bin ich ja eigentlich auch auf asyncExec gekommen...
Hast du sonst noch einen Tip? Oder Hinweis oder irgendwas, dass mich weiterbringt?

Wie löst ihr solche Probleme?
Eine Aufgabe dauert etwas länger, die GUI soll aber nicht hängenbleiben.

 

[waste1]

GUI beeinflussen ist ja grade das, was ich machen will/ machen muss.

Szenario:
Es gibt eine Tabelle in der GUI.
Die ist leer.
Mit einem Knopfdruck wird Inhalt berechnet, geholte, was auch immer.
Das holen des Inhaltes dauert etwas (sagen wir erstmal 10 Sek).
Der Inhalt soll in die Tabelle gefüllt werden, wenn er da ist.

Also dachte ich, alles mal initialisieren
Dann einen Thread machen, der den Inhalt holt und aufbereitet und wenn fertig in die Tabelle einträgt.

Wie soll ich das sonst machen?

 

[Beni]

Ich weiss ja nicht, was du jetzt getan hast, aber mein Tipp ist:

das "asyncExec" benötigst du nur, um mit der Gui zu kommunizieren

public void handleEvent(Event e)
            {
                t = new Thread()
                {
                    public void run()
                    {                       
                        try
                        {
                            Thread.sleep(10000);
                        }
                        catch (InterruptedException e)
                        {
                            e.printStackTrace();
                        }

// so würde das meinem Verständnis nach funktionieren
                        display.asyncExec( new Runnable(){
                            public void run(){
                                text.setText("Der Thread ist beendet, markieren geht wieder");
                            }
                        });
                    }
                };
               
                text.setText("Hier ist alles blockiert :( ");
                t.start();
            }

 

[waste1]

ahhh, Jetzt verstehe ich.
Dein Tip war genau das was ich suchte.
Supergroßes Danke für die Erleuchtung

Auf einen Thread im Thread bin ich gar nicht gekommen, aber das mach genau das was ich will.
Nochmal Dankeschön für die Hilfe