THREADS - Ich verstehe es nicht

[MirWurscht92]

Hallo allerseits,

wie der Titel schon sagt, habe ich Probleme mit dem Verständnis für Threads.
Knappe Situationsbeschreibung:
Ich habe 3 Packages, das eine enthält nur die GUI, die anderen 2 den gesamten Quellcode für 2 Berechnungsverfahren.
Die GUI ist ein JFrame mit einem Button. Wenn ich den drücke, starten die Berechnungen:

    private void buStartActionPerformed(java.awt.event.ActionEvent evt) {
                if (cbComp.getSelectedItem().equals("2003")) {
                    PACKAGE2003.MeineKlasse.starten(cbInst.getSelectedItem().toString());
                } else if (cbComp.getSelectedItem().equals("2007")) {
                    PACKAGE2007.MeineKlasse.starten(cbInst.getSelectedItem().toString());
                }           
    }

Die Berechnungen laufen in einer Endlosschleife (bisher habe ich nach Erreichen des gewünschten Ergebnisses manuell abgebrochen). Das klappt bisher wunderbar, nur will ich das ganze noch weiter Ausbauen, Stop-Button, Weiterberechnen-Button...
Ich verstehe das Threading nicht ganz. Ich müsste doch das was oben ausgeführt wird, wenn der Button gedrückt wird, in einen Thread stecken, nicht wahr? Das heisst, alle Abläufe die mit der Berechnung gemacht werden, sind dann in diesem einen Thread?
Wie Threade ich das ganze?

 

[Empire Phoenix]

Starte einen Thread wenn man auf den button drückt, disable die buttons, wenn der thread fertig ist enable die buttons wieder.
statt while true bau in den threads while not interrupted, und setzte zum vorzeitigen beenden interrupted auf false.

Ich sage guck dir die Insel an, und mach dich DRINGENDST mit grundlegenden synchronisations Konzepten vertraut, sonst wirst du fazinierende random Fehler erleben.

(Das für Prozesse ist fast 1 zu 1 auch auf Threads anwendbar)
http://ki.informatik.uni-mannheim.de/fileadmin/files/Prozesse.pdf (erklärung der grundelgenden Probleme)
http://ki.informatik.uni-mannheim.de/fileadmin/files/Scheduling.pdf(nicht zwingend notwendig, aber sinnvoll)
http://ki.informatik.uni-mannheim.de/fileadmin/files/Semaphoren.pdf (basics,aber eher selten in java benutzt)
http://ki.informatik.uni-mannheim.de/fileadmin/files/Deadlocks.pdf (wäre in dem zusammenhang auch sinnvoll)

Dazu dann noch das Konzept von Monitoren googlen und du solltest erstmal eine solide grundkenntnis haben, und verstehen was ein synchronized(object){bla} bedeuted, bzw ein synchronized in einer Methoden deklaration. Zudem die Objecte Thread,Runnable und SwingWorker oder wie des hieß angucken.

 

[0din]

Threading in Simpel...

Thread basteln:
klasse die in den Thread kommen soll += implements Runnable
die run() bekommt deine schleife bzw. das was der thread machen soll,
er macht das ganze solange bis er am ende der run() angekommen is.

Thread nutzen:

Thread t = new Thread(new KlasseDieRunnableImplements());
t.start(); //startet die run() methode

Thread nehmen ich wann?
Eig. ganz simpel, ich möchte z.b. eine endlosschleife laufen lassen aber gleichzeitig soll ein anderer teil des progs noch andere dinge machen... ->endlosschleife = neuer Thread
oder allgemeiner, wenn ich in einem prog. 2 dinge gleichzeitig machen lassen will

bei dir seh ich weder das eine noch das andere... oder ich verstehs net recht...
du hastn prog.... auf knoppdruck lässte wat ausrechnen un willst das ausgeben?
da brauchste noch keine threads für...

 

[eRaaaa]

bei dir seh ich weder das eine noch das andere... oder ich verstehs net recht...
du hastn prog.... auf knoppdruck lässte wat ausrechnen un willst das ausgeben?
da brauchste noch keine threads für...

Er hat doch gesagt dass er sehr lange/endlose Berechnungen machen will...und gerade auch weil es durch einen Button/Listener aufgerufen wird, sollte man meiner Meinung nach Thread(s) verwenden, weil du sonst nämlich den EDT blockierst !

 

[MirWurscht92]

Ich habe die erwähnte GUI. Ich starte bestimmte Berechnungen mit dem Button. Diese Berechnungen laufen unendlich in einer Endlosschleife. Ich habe bisher das Programm einfach manuell abgebrochen, wenn ich anhand der Ausgabe gesehen habe, dass mein Ergebnis berechnet wurde. Jetzt wollt ich eben diese Berechnungsphase in einen Thread packen, um, im Ausblick auf den Einbau weiterer Funktionen (Pausieren der Berechnungen, Ausgaben in der GUI während der Berechnungen, etc.). Wenn wie jetzt, ohne Threads, die Berechnungen laufen, so geht in der GUI nichts mehr (weil ja die Berechnungen ausgeführt werden).

Konnte ich es erklären?

 

[FArt]

Lange Rede kurzer Sinn... so geht es richtig:
Lesson: Concurrency in Swing (The Java™ Tutorials > Creating a GUI With JFC/Swing)

 

[MirWurscht92]

@FArt

Der Link ist echt gut, habs nicht nur hinbekommen, sondern ein wenig mehr Verständnis für das ganze gewonnen... Danke

 

[MirWurscht]

Wollte hier nochmal fragen, weil ich noch ein paar Fragezeichen habe. Ich habe sehr viele Beispiele ausprobiert. Das ist das Resultat:

    class CalcThread extends Thread {

        @Override
        public void run() {
            while (isRunning) {
                if (cbComp.getSelectedItem().equals("2003")) {
                    PACKAGE2003.MeineKlasse.starten(cbInst.getSelectedItem().toString());
                } else if (cbComp.getSelectedItem().equals("2007")) {
                    PACKAGE2007.MeineKlasse.starten(cbInst.getSelectedItem().toString());
                }
            }
            System.out.println("run verlassen");
        }

        public void stopRunning() {
            isRunning = false;
            interrupt();
        }
    };

Aufrufen tue ich den Thread mit:

            ct = new CalcThread();
            ct.start();

Beenden mit:

ct.stopRunning();

Das dauert dann kurz einige Sekunden, dann sehe ich Anhand der Ausgabe, dass PACKAGE200X.MeineKlasse.starten() nicht mehr ausgeführt wird. Gut.

Aber was ist aus dem Thread geworden? Wenn ich ct.isAlive aufrufe bekomme ich weiterhin ein true.
Ich frage deshalb, weil ich im Anschluss ja weitere Berechnungen über das Obige machen möchte, und wissen will, ob der Thread nun restlos weg ist.

In einem Beispiel habe ich gesehen, dass beim Beenden, der Thread=null gesetzt wird. Wenn ich das mache, ist er nicht mehr alive wie zuvor, ist er damit restlos weg?

 

[MirWurscht92]

Nachtrag:
Also ich möchte dass ein Thread nach dem Beenden restlos weg ist, weil ich sehr viele neue Berechnungen hintereinander starten möchte, und das wäre ja nicht gut, wenn sich durch zuvor erstellte Threads irgendein Datenmüll ansammelt...

 

[LoR]

Das sollte für deine Zwecke besser sein, da du asynchron irgendwelche Berechnungen durchführst und eigentlich nur am Resultat interessiert bist (siehe Callable).

ExecutorService (Java 2 Platform SE 5.0)
Executors (Java 2 Platform SE 5.0)
Callable (Java 2 Platform SE 5.0)

z.B.

import java.util.concurrent.Callable;

public class Problem implements Callable<Integer> {

    private final int counter;

    public Problem(int counter) {
        this.counter = counter;
    }

    public Integer call() throws Exception {
        int result = 0;
        for (int i = 0; i < counter; i++) {
            result += i;
        }
        return result;
    }
}

public class Main {

    public static void main(String[] args) throws Exception {
        ExecutorService pool = Executors.newCachedThreadPool();
        Problem problem = new Problem(100000000);
        Future<Integer> result = pool.submit(problem);
        System.out.println(result.get()); //Warte solange bis das Problem gelöst ist, dan
    }
}

Die Problemklasse ist nicht besonders sinnig, sollte aber die Idee verdeutlichen.

 

[Murray]

Also ich möchte dass ein Thread nach dem Beenden restlos weg ist, weil ich sehr viele neue Berechnungen hintereinander starten möchte, und das wäre ja nicht gut, wenn sich durch zuvor erstellte Threads irgendein Datenmüll ansammelt...

Das sollte so sein - ein Thread stirbt, wenn die run-Methode verlassen wird. Wenn du natürlich sofort nach stopRunning() isAlive() aufrufst, besteht eine gute Chance, noch true zu bekommen - das Stoppen ist ja keine synchrone Aktion; du musst dem System zumindest die Chance geben / die Zit lassen, zwischen den Threads umzuschalten.