Threads Methode unterbrechbar machen

[Crian]

Wie kann ich die

run()

Methode eines Threads, in der eine komplexe Berechnung in einer anderen Klasse aufgerufen wird, unterbrechen?

Ich habe es so versucht:

    @Override
    public void run() {
        String result = "";
        try {
            result = einObjekt.fuehreKomplexeBerechnungDurch();
        }
        catch (InterruptedException e) {
            result = "UNTERBROCHEN";
        }
        // ...
    }

und hab dann von außen halt [c]myThread.interrupt()[/c] aufgerufen. Aber das kompiliert natürlich nicht, da

fuehreKomplexeBerechnungDurch()

keine

InterruptedException

wirft.


Wie kann ich das Problem lösen?

 

[VfL_Freak]

Moin,

Aber das kompiliert natürlich nicht, da

fuehreKomplexeBerechnungDurch()

keine

InterruptedException

wirft.
Wie kann ich das Problem lösen?

Indem Du in Deiner Methode an den von Dir gewünschten Stellen händisch diese Exception wirfst !

Das richtige Stichwort für die Methodendeklaration müsste hier throws sein!

Gruß
Klaus

 

[Crian]

Das geht eben nicht, da die komplexe Berechnung in der Ausführung eines komplexen regulären Ausdrucks besteht und ich nicht die Java-RegExp-Maschinerie umschreiben kann oder will.

 

[SlaterB]

@VfL_Freak
was ist denn das für ein Vorschlag, es soll doch von außen passieren,
und das geht in Java schlicht nicht, außer vielleicht mit Thread.stop(), ich vergesse das immer so schnell wieder,
gibt alle paar Monate so ein Thema,

dein Code müsste ansonsten regelmäßig, z.B. bei Schleifenverarbeitung gut machbar, von selber aus nachschauen ob das Interrupted-Flag gesetzt ist oder sonst eine Kommunikation pflegen und dann aus eigener Entscheidung aus anhalten,
dann durchaus möglicherweise per Exception,
um Speicherung des Zustandes/ Rückkehr musst du dich auch selber kümmern, falles es später weitergehen soll,
vielleicht leichter dort zu bleiben und nur temporär nichts/ etwas anderes zu machen


Interrupt an sich hilft nur wenn der Thread schläft

------

edit:
> Das geht eben nicht, da die komplexe Berechnung in der Ausführung eines komplexen regulären Ausdrucks besteht und ich nicht die Java-RegExp-Maschinerie umschreiben kann oder will.

dann siehts schwer aus..

 

[Crian]

Das ganze ist im Moment eine Konzeptstudie. Ich lasse einen regulären Ausdruck laufen und wenn er nach X Sekunden nicht fertig geworden ist, möchte ich den Thread auffordern, sich zu beenden.

Und wie gesagt, in das System für die regulären Ausdrücke kann ich leider nicht eingreifen. Schade, dass das nicht unterbrechbar ist.

 

[nrg]

dann spricht aber bei diesem Fall nichts gegen stop. Solang dein Process nicht Transaktionssicher o.ä. sein muss, kannst du ihn doch ruhig die Keule geben...

Java API:

Deprecated. This method is inherently unsafe. Stopping a thread with Thread.stop causes it to unlock all of the monitors that it has locked (as a natural consequence of the unchecked ThreadDeath exception propagating up the stack). If any of the objects previously protected by these monitors were in an inconsistent state, the damaged objects become visible to other threads, potentially resulting in arbitrary behavior. Many uses of stop should be replaced by code that simply modifies some variable to indicate that the target thread should stop running. The target thread should check this variable regularly, and return from its run method in an orderly fashion if the variable indicates that it is to stop running. If the target thread waits for long periods (on a condition variable, for example), the interrupt method should be used to interrupt the wait. For more information, see Why are Thread.stop, Thread.suspend and Thread.resume Deprecated?.

 

[SlaterB]

stop() geht und sogar suspend() + resume(),
wenn auch deprecated, siehe Beschreibung in der API, da steht ähnliches wie z.T. schon gesagt

public class Test
{
    public static void main(String[] args)
        throws Exception
    {
        Runnable r = new Runnable()
            {

                public void run()
                {
                    long start = System.currentTimeMillis();
                    while (true)
                    {
                        long sum = 0;
                        for (int i = 0; i < Integer.MAX_VALUE / 10; i++)
                        {
                            sum += i;
                        }
                        System.out.println("time: " + 
                              (System.currentTimeMillis() - start) % 20000 + ", " + sum);

                    }
                }
            };
        Thread t = new Thread(r);
        t.start();

        Thread.sleep(3000);
        System.out.println("suspend");
        t.suspend();
        Thread.sleep(3000);
        System.out.println("resume");
        t.resume();
        Thread.sleep(3000);
        System.out.println("stop");
        t.stop();
    }
}

Ausgabe:

time: 627, 23058429812964066
time: 1255, 23058429812964066
time: 1882, 23058429812964066
time: 2509, 23058429812964066
suspend
resume
time: 6148, 23058429812964066
time: 6775, 23058429812964066
time: 7402, 23058429812964066
time: 8030, 23058429812964066
time: 8641, 23058429812964066
stop

 

[nrg]

ich finds auch ehrlich gesagt etwas hart, stop direkt deprecated zu machen. soll doch jeder selber entscheiden, ob es passt oder nicht.

 

[Volvagia]

Was spricht denn gegen VFLs Vorschlag?
Die komplexe Berechnung muss nur regelmäßig prüfen ob der currentThread interrupted ist und wenn dann einfach eine Exception schmeißen. ???:L

 

[SlaterB]

dagegen spricht einerseits, wie gesagt wurde, dass es sich hier um unveränderbaren API-RegEx-Code handelt,
und andererseits, dass man quasi beliebigen Programmcode damit verschandeln kann/ muss, vielleicht irgendwelche komplett andere Klassen, die eigentlich gar nicht wissen welcher Thread sie gerade ausführt, ob interrupt jeweils wirklich stop sein soll oder nicht

 

[Crian]

Ich hab nun wie vorgeschlagen stop() verwendet und es funktioniert damit so, wie ich es mir dachte.

Bei Interesse kann ich das ganze auch posten, weiß aber nicht, ob das erwünscht ist.

 

[Crian]

Also zunächst mal die einfachen Sachen. Ich habe eine Klasse, die eine u.u. sehr lang dauernde Berechnung durchführt:

package threads.extended;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class SpecialRegularExpression {

    private final static Pattern pattern = Pattern.compile(
            "c*c*c*c*c*c*c*c*c*c*c*c*c*c*c*c*c*c*c*d");

    public String workWith(String jobString) {
        Matcher m = pattern.matcher(jobString);
        if (m.matches()) {
            return "getroffen";
        }
        else {
            return "nicht getroffen";
        }
    }

}

Natürlich ist der Reguläre Ausdruck sinnlos, aber er dauert u.U. schön lange.

Nun ist die normale Herangehensweise diese:

package threads.extended.start;

import java.util.ArrayList;
import java.util.List;

import threads.extended.SpecialRegularExpression;

public class SimpleBadStarter1 {

    public static void main(String[] args) {
        List<String> jobStrings = new ArrayList<String>();
        jobStrings.add("a");
        jobStrings.add("b");
        jobStrings.add("c");
        jobStrings.add("cccccccccccccccccccccccccccccccccccccc");
        jobStrings.add("ccccccccccccccccccccccccccccccccccccc");
        jobStrings.add("d");
        jobStrings.add("e");

        SpecialRegularExpression worker = new SpecialRegularExpression();
        for (String jobString : jobStrings) {
            String result = worker.workWith(jobString);
            System.out.println(jobString + " -> " + result);
        }
    }

}

Nach

a -> nicht getroffen
b -> nicht getroffen
c -> nicht getroffen

Steht der Prozess und wartet auf die Beendigung des regulären Ausdrucks. Das könnte dauern...

Deshalb habe ich die folgende Klasse ins Spiel gebracht:

package threads.extended;

public class RegularExpressionWorker {

    private class DoTheWork extends Thread {

        private final long FOR_A_DAY = 1000         // 1 Sekunde
                                       * 60         // 1 Minute
                                       * 60         // 1 Stunde
                                       * 24         // 24 Stunden
                                       ;

        @Override
        public void run() {
            while (!isInterrupted()) {
                try {
                    sleep(FOR_A_DAY);
                }
                catch (InterruptedException e) {
                    interrupt();
                }
            }
        }

        public String workWith(String jobString) {
            SpecialRegularExpression special = new SpecialRegularExpression();
            String result = special.workWith(jobString);
            return result;
        }

    }

    private DoTheWork theWorkingThread;

    public RegularExpressionWorker() {
        theWorkingThread = new DoTheWork();
    }

    /** Lässt den Arbeitsthread die Arbeit machen und gibt das Ergebnis zurück. */
    public String workWith(String jobString) {
        return theWorkingThread.workWith(jobString);
    }

    /**
     * Bricht die aktuelle Verarbeitung ab und stellt für weitere Bearbeitungen
     * einen neuen Arbeitsthread zur Verfügung.
     */
    @SuppressWarnings("deprecation")
    public void cancelPatternMatching() {
        theWorkingThread.stop();
        theWorkingThread = null;
        theWorkingThread = new DoTheWork();
    }

}

Aber auch diese Klasse direkt angewendet bringt natürlich keinerlei Besserung, da die Abbruchkriterien ja nicht in ihrem Inneren stecken:

package threads.extended.start;

import java.util.ArrayList;
import java.util.List;

import threads.extended.RegularExpressionWorker;

public class SimpleBadStarter2 {

    public static void main(String[] args) {
        List<String> jobStrings = new ArrayList<String>();
        jobStrings.add("a");
        jobStrings.add("b");
        jobStrings.add("c");
        jobStrings.add("cccccccccccccccccccccccccccccccccccccc");
        jobStrings.add("ccccccccccccccccccccccccccccccccccccc");
        jobStrings.add("d");
        jobStrings.add("e");

        RegularExpressionWorker worker = new RegularExpressionWorker();
        for (String jobString : jobStrings) {
            String result = worker.workWith(jobString);
            System.out.println(jobString + " -> " + result);
        }
    }

}

Nach

a -> nicht getroffen
b -> nicht getroffen
c -> nicht getroffen

Steht das ganze wieder und wartet auf den Abbruch, so ist nichts gewonnen.

Etwas besser sieht das ganze so aus:

package threads.extended.start;

import java.util.ArrayList;
import java.util.List;

import threads.extended.RegularExpressionWorker;

public class BetterStarter {

    public static void main(String[] args) {
        new BetterStarter();
    }

    public BetterStarter() {
        List<String> list = new ArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("cccccccccccccccccccccccccccccccccccccc");
        list.add("ccccccccccccccccccccccccccccccccccccc");
        list.add("d");
        list.add("e");

        RegularExpressionWorker worker = new RegularExpressionWorker();
        for (String jobString : list) {
            String result = calculateResult(jobString, worker);
            System.out.println(jobString + " -> " + result);
        }
    }

    private class MyThread extends Thread {
        private String jobString;
        private RegularExpressionWorker worker;
        private String result;
        public MyThread(String jobString, RegularExpressionWorker worker) {
            this.jobString = jobString;
            this.worker = worker;
        }
        public void run() {
            result = worker.workWith(jobString);
        }
        public String getResult() {
            return result;
        }
    }

    @SuppressWarnings("deprecation")
    private String calculateResult(String jobString,
            RegularExpressionWorker worker) {
        final long MAXIMAL_JOB_RUNTIME_IN_MILLIS = 10 * 1000;

        MyThread myThread = new MyThread(jobString, worker);
        myThread.start();

        try {
            Thread.sleep(MAXIMAL_JOB_RUNTIME_IN_MILLIS);
        }
        catch (InterruptedException e) {
        }

        if (myThread.isAlive()) {
            System.out.println("Interrupted!");
            myThread.stop();
            return "CANCELED";
        }

        return myThread.getResult();
    }

}

Es dauert, aber dann bekommt man zu lesen:

a -> nicht getroffen
b -> nicht getroffen
c -> nicht getroffen
Interrupted!
cccccccccccccccccccccccccccccccccccccc -> CANCELED
Interrupted!
ccccccccccccccccccccccccccccccccccccc -> CANCELED
d -> getroffen
e -> nicht getroffen

Was schon eher in unserem Sinne ist.

(Fortsetzung folgt)

 

[Crian]

Die eigentliche Nutzung ist etwas komplexer, da ich die Jobs (hier einfache Strings) nicht sequentiell, sondern parallel ablaufen lassen will.

Da sieht der Start so aus:

package threads.extended.start;

import java.util.ArrayList;
import java.util.List;

import threads.extended.Organizer;

public class Starter {

    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("cccccccccccccccccccccccccccccccccccccc");
        list.add("ccccccccccccccccccccccccccccccccccccc");
        list.add("d");
        list.add("e");
        Organizer o = new Organizer(list);
        o.work();
    }

}

Das Organisations-Objekt sieht so aus:

package threads.extended;

import java.util.ArrayList;
import java.util.List;

public class Organizer {

    private static final long MAXIMAL_JOB_RUNTIME_IN_MILLIS = 10 * 1000;

    private RegularExpressionWorker regularExpressionWorker;
    private List<String> jobStrings;
    private List<Job> jobs;

    /** Konstruktor */
    public Organizer(List<String> list) {
        jobStrings = list;
        regularExpressionWorker = new RegularExpressionWorker();
        jobs = new ArrayList<Job>();
    }

    /** Start der eigentlichen Verarbeitung. */
    public void work() {
        System.out.println(this.getClass().getName() + ": Start");

        for (String jobString : jobStrings) {
            startJob(jobString);
            pause(1);
        }

        boolean allDone = false;
        while (!allDone) {
            pause(2);
            allDone = checkJobs();
        }

        printResumee();

        System.out.println(this.getClass().getName() + ": normales Ende");
    }

    /** Startet einen Job. */
    private void startJob(String jobString) {
        System.out.println(this.getClass().getName()
                + ": Starte Verarbeitung von " + jobString);
        Job job = new Job(jobString, regularExpressionWorker);
        jobs.add(job);
    }

    /** Wartet die angegebene Zeit in Sekunden. */
    private void pause(long seconds) {
        try {
            Thread.sleep(1000 * seconds);
        }
        catch (InterruptedException e) {
        }
    }

    /** Überprüft die Jobs. */
    private boolean checkJobs() {
        boolean allDone = true;

        for (Job job : jobs) {
            if (job.isAlive()) {
                allDone = false;
                long since = job.isRunningSince();
                if (since > MAXIMAL_JOB_RUNTIME_IN_MILLIS) {
                    job.cancel();
                }
            }
        }

        return allDone;
    }

    /** Schreibt einen Abschlussbericht. */
    private void printResumee() {
        System.out.println(this.getClass().getName() + ": Resumee:");
        List<Job> canceled = new ArrayList<Job>();
        for (Job job : jobs) {
            System.out.println("    Job " + job.getJobString() + " ergab "
                    + job.getResult());
            if (job.wasCanceled()) {
                canceled.add(job);
            }
        }
        if (canceled.size() > 0) {
            System.out.println("    ABGEBROCHENE JOBS:");
            for (Job job : canceled) {
                System.out.println("        " + job.getJobString());
            }
        }
    }

}

Die Jobklassen so:

package threads.extended;

public class Job {

    private long startTime;
    private String jobString;
    private WorkerThread workerThread;
    private boolean canceled;

    public Job(String jobString, RegularExpressionWorker regularExpressionWorker) {
        this.jobString = jobString;
        startTime = java.lang.System.currentTimeMillis();
        canceled = false;
        workerThread = new WorkerThread(jobString, regularExpressionWorker);
        workerThread.start();
    }

    /** Gibt die Laufzeit des Jobs in Millisekunden zurück. */
    public long isRunningSince() {
        return java.lang.System.currentTimeMillis() - startTime;
    }

    public void cancel() {
        canceled = true;
        workerThread.cancel();
    }

    public boolean isAlive() {
        boolean isAlive = workerThread.isAlive();
        System.out.println("Job [" + jobString + "] lebt "
                + (isAlive ? "noch" : "nicht mehr"));
        return isAlive;
    }

    public String getResult() {
        return workerThread.getResult();
    }

    boolean wasCanceled() {
        return canceled;
    }

    public String getJobString() {
        return jobString;
    }

}

Und die eigentlichen Worker-Threads so:

package threads.extended;

public class WorkerThread extends Thread {

    private String jobString;
    private RegularExpressionWorker regularExpressionWorker;
    private String result;

    public WorkerThread(String jobString,
            RegularExpressionWorker regularExpressionThread) {
        this.jobString = jobString;
        this.regularExpressionWorker = regularExpressionThread;
        this.result = "";
    }

    @Override
    public void run() {
        System.out.println(this.getClass().getName() + "(" + jobString
                + "): Start");

        result = regularExpressionWorker.workWith(jobString);

        System.out.println(this.getClass().getName() + "(" + jobString
                + "): berechnete zu [" + jobString + "] das Ergebnis ["
                + result + "].");

        System.out.println(this.getClass().getName() + "(" + jobString
                + "): normales Ende");
    }

    @SuppressWarnings("deprecation")
    public void cancel() {
        regularExpressionWorker.cancelPatternMatching();
        result = "CANCELED";
        System.out.println(this.getClass().getName() + "(" + jobString
                + "): Abgebrochen!");
        stop();
    }

    public String getResult() {
        return result;
    }

}

Damit bekommt man folgende Ausgabe:

threads.extended.Organizer: Start
threads.extended.Organizer: Starte Verarbeitung von a
threads.extended.WorkerThread(a): Start
threads.extended.WorkerThread(a): berechnete zu [a] das Ergebnis [nicht getroffen].
threads.extended.WorkerThread(a): normales Ende
threads.extended.Organizer: Starte Verarbeitung von b
threads.extended.WorkerThread(b): Start
threads.extended.WorkerThread(b): berechnete zu [b] das Ergebnis [nicht getroffen].
threads.extended.WorkerThread(b): normales Ende
threads.extended.Organizer: Starte Verarbeitung von c
threads.extended.WorkerThread(c): Start
threads.extended.WorkerThread(c): berechnete zu [c] das Ergebnis [nicht getroffen].
threads.extended.WorkerThread(c): normales Ende
threads.extended.Organizer: Starte Verarbeitung von cccccccccccccccccccccccccccccccccccccc
threads.extended.WorkerThread(cccccccccccccccccccccccccccccccccccccc): Start
threads.extended.Organizer: Starte Verarbeitung von ccccccccccccccccccccccccccccccccccccc
threads.extended.WorkerThread(ccccccccccccccccccccccccccccccccccccc): Start
threads.extended.Organizer: Starte Verarbeitung von d
threads.extended.WorkerThread(d): Start
threads.extended.WorkerThread(d): berechnete zu [d] das Ergebnis [getroffen].
threads.extended.WorkerThread(d): normales Ende
threads.extended.Organizer: Starte Verarbeitung von e
threads.extended.WorkerThread(e): Start
threads.extended.WorkerThread(e): berechnete zu [e] das Ergebnis [nicht getroffen].
threads.extended.WorkerThread(e): normales Ende
Job [a] lebt nicht mehr
Job [b] lebt nicht mehr
Job [c] lebt nicht mehr
Job [cccccccccccccccccccccccccccccccccccccc] lebt noch
Job [ccccccccccccccccccccccccccccccccccccc] lebt noch
Job [d] lebt nicht mehr
Job [e] lebt nicht mehr
Job [a] lebt nicht mehr
Job [b] lebt nicht mehr
Job [c] lebt nicht mehr
Job [cccccccccccccccccccccccccccccccccccccc] lebt noch
Job [ccccccccccccccccccccccccccccccccccccc] lebt noch
Job [d] lebt nicht mehr
Job [e] lebt nicht mehr
Job [a] lebt nicht mehr
Job [b] lebt nicht mehr
Job [c] lebt nicht mehr
Job [cccccccccccccccccccccccccccccccccccccc] lebt noch
threads.extended.WorkerThread(cccccccccccccccccccccccccccccccccccccc): Abgebrochen!
Job [ccccccccccccccccccccccccccccccccccccc] lebt noch
Job [d] lebt nicht mehr
Job [e] lebt nicht mehr
Job [a] lebt nicht mehr
Job [b] lebt nicht mehr
Job [c] lebt nicht mehr
Job [cccccccccccccccccccccccccccccccccccccc] lebt nicht mehr
Job [ccccccccccccccccccccccccccccccccccccc] lebt noch
threads.extended.WorkerThread(ccccccccccccccccccccccccccccccccccccc): Abgebrochen!
Job [d] lebt nicht mehr
Job [e] lebt nicht mehr
Job [a] lebt nicht mehr
Job [b] lebt nicht mehr
Job [c] lebt nicht mehr
Job [cccccccccccccccccccccccccccccccccccccc] lebt nicht mehr
Job [ccccccccccccccccccccccccccccccccccccc] lebt nicht mehr
Job [d] lebt nicht mehr
Job [e] lebt nicht mehr
threads.extended.Organizer: Resumee:
    Job a ergab nicht getroffen
    Job b ergab nicht getroffen
    Job c ergab nicht getroffen
    Job cccccccccccccccccccccccccccccccccccccc ergab CANCELED
    Job ccccccccccccccccccccccccccccccccccccc ergab CANCELED
    Job d ergab getroffen
    Job e ergab nicht getroffen
    ABGEBROCHENE JOBS:
        cccccccccccccccccccccccccccccccccccccc
        ccccccccccccccccccccccccccccccccccccc
threads.extended.Organizer: normales Ende

Später werden die Jobs nicht die Bearbeitung einzelner Strings sein. Und es wird auch nicht um die Anwendung eines einzelnen Regulären Ausdrucks gehen. Es werden vielmehr Dateien verarbeitet und mit einer Reihe von regulären Ausdrücken behandelt, wo es nicht auszuschließen ist, dass einige davon in speziellen Fällen sehr lange laufen.

Mit diesem System möchte ich sicherstellen, dass ich am Ende sagen kann, welche Teile komplett bearbeitet wurden und welche nur teilweise.