Thread / Prozess stoppen?

[beta20]

Hallo zusammen,

ich möchte innerhalb einer Schleife mehrere Threads / Prozesse starten. (soweit OK).

Ebenfalls möchte ich aber auch die Möglichkeit haben Thread / Prozesse wieder zu beenden.

Generell meine Fragen:
- Hat ein Thread / Prozess eine ID, die ich in einem Objekt einer eigenen Klasse speichern kann? Wenn ja, wie bekomme ich diese?
- Wie kann ich den Thread wieder stoppen?

Mir schweb sowas vor:

public void stopThread(String uuid) {
// stop thread();
}

Danke für jede Hilfe

 

[Robat]

Wenn ja, wie bekomme ich diese?

Thread#getId()

Wie kann ich den Thread wieder stoppen?

Jeder Thread sollte eine Abbruchbedingung haben - also ein Flag - welches du auf true/false setzen kannst um den Thread zu stoppen. Es gibt zwar eine Thread#interrupt() Methode allerdings sagt diese Methode nur, dass der Thread jetzt - irgendwann - gestoppt werden wird.

 

[beta20]

Thread#getId()

Jeder Thread sollte eine Abbruchbedingung haben - also ein Flag - welches du auf true/false setzen kannst um den Thread

Bringt das die Klasse java.lang.Thread nicht von Hause aus mit? Wenn ja, welches Boolean ist das?

 

[mihe7]

Bringt das die Klasse java.lang.Thread nicht von Hause aus mit?

Nein.

 

[Robat]

Bringt das die Klasse java.lang.Thread nicht von Hause aus mit?

Es gibt halt - wie gesagt - dieses interrupted-Flag welches durch die interrupt() Methode gesetzt wird. Aber nur weil dieses Flag auf true ist heißt es noch lange nicht, dass dein Thread wirklich direkt beendet wird.

 

[beta20]

hast du einen Beispielcode? Verstehe dann nicht so ganz wie du das mit dem Flag meinst...?

 

[Robat]

Geht bestimmt auch noch schöner ..

public class StoppableThread {
    private Thread worker;
    private Consumer<StoppableThread> task;

    public StoppableThread(Consumer<StoppableThread> task) {
        this.task = task;
    }

    public void start() {
        worker = new Thread(() -> task.accept(this));
        worker.start();
    }

    public void stop() {
        worker = null;
    }


    public static void main(String[] args)  {
        StoppableThread t = new StoppableThread(task -> {
            for(int i = 0; i < 5; i++) {
                System.out.println("Hallo Welt die " + (i+1)+".");
                sleep(1000);
            }
            task.stop();
        });
        t.start();

        sleep(5000);
        t.stop();
    }

    static void sleep(long ms) {
        try {
            Thread.sleep(ms);
        } catch (InterruptedException e) {
            return;
        }
    }
}

 

[beta20]

danke dir - aber wo ist nun das angesprochene Flag?

 

[Robat]

danke dir - aber wo ist nun das angesprochene Flag?

Berechtigte Frage. Hab dir die falsche Klasse geschickt Sorry

public class StoppableThread {
    private Thread worker;
    private Consumer<StoppableThread> task;
    private boolean running;

    public StoppableThread(Consumer<StoppableThread> task) {
        this.task = task;
        this.running = false;
    }

    public void start() {
        this.running = true;
        worker = new Thread(() -> task.accept(this));
        worker.start();
    }

    public void stop() {
        running = false;
        worker = null;
    }

    public boolean isRunning() {
        return running;
    }

    public static void main(String[] args)  {
        StoppableThread t = new StoppableThread(task -> {
            int i = 0;
            while(task.isRunning()) {
                System.out.println("Hallo Welt die " + (i++ +1)+".");
                sleep(1000);
            }
        });
        t.start();
        sleep(5000);
        t.stop();
    }

    static void sleep(long ms) {
        try {
            Thread.sleep(ms);
        } catch (InterruptedException e) {
            return;
        }
    }
}

 

[beta20]

danke - aber ich weiß gerade nicht so 100% ob das das ist, was ich brauche... vllt sollte ich ein bisschen mehr ausholen, was ich brauche:
1) Ich habe einen @EJB - Container mit einem Schedule, der jede Minute läuft (ich nutze WildFly als APP - Server)
2) Zunächst prüfe ich, ob es ausstehende Aktionen gibt (ScheduleExecution) in der Datenbank gibt.
3) Wenn ja, sollen diese abgearbeitet werden (passiert dann in der for - Schleife)
4) executeAction -> ist dann die Methode in der irgendeine Aktion passiert (könnte man durch sleep() ersetzen)

    @Resource
    private ManagedExecutorService mes;

    private List<Future<?>> tasks;

    @Resource
    private ManagedScheduledExecutorService scheduledExecutorService;

private boolean currentlyRunning = false;

@Timeout
    @AccessTimeout(value = 20, unit = TimeUnit.MINUTES)
    @Schedule(minute = "*/1", hour = "*", persistent = false)
    public void execute() throws Exception {

        LOGGER.info("START SCHEDULER");

        try {
            if (currentlyRunning) {
                LOGGER.warn("Scheduler is currently running...");
                return;
            }

            currentlyRunning = true;

            /**
             * Alle noch nicht ausgeführten Schedules bekommen
             */
            List<ScheduleExecution> scheduleExecutionList = scheduleExecutionService
                    .findAllScheduleExecutionOutstanding();

            if (scheduleExecutionList == null || scheduleExecutionList.size() == 0) {
                LOGGER.info("NO PLANNED SCHEDULES FOUND");
                currentlyRunning = false;
                return;
            }

            LOGGER.info("FOUND SCHEDULES: " + scheduleExecutionList.size());

            tasks = new ArrayList<>();
            
            for (ScheduleExecution scheduleExecution : scheduleExecutionList) {

                synchronized (this) {

                    tasks.add(mes.submit(() -> {
                        try {
                            executeAction(scheduleExecution);
                        }
                        catch(Exception e){
                        }
                    }));
                }
            }

            currentlyRunning = false;
        }

        catch (Exception e) {
            LOGGER.error(ExceptionUtils.getFullStackTrace(e));
            currentlyRunning = false;
        }

        LOGGER.info("END SCHEDULER");
    }

Das Problem sehe ich nun in der Methode ab: synchronized.
- Wie bekomme ich / erstelle ich hier einen Task, womit ich dann auch die ID bekomme.
- Die ID brauche ich dann später um einen Task zu stoppen - auch unter der Berücksichtigung von @Robat

Danke für jede Hilfe

 

[Xyz1]

Ein Prozess ist in Java beendet, wenn er tot ist, dh alle Anweisungen fertig sind.

Ein vorzeitiges Ende kannst Du nur durch eine volatile-Variable erreichen.

Lies dich mal in volatile und Threads ein.

 

[mrBrown]

Aktuell übergibst du eine anonyme Lambda-Funktion als Task - die hat keine ID, an die du kommen könntest.

Erstell stattdessen eine eigene Klasse mit passendem Interface, der kannst du dann eine ID und Möglichkeiten zum abbrechen spendieren.

 

[beta20]

Ok, also sowas wie die StoppableThread von @Robat ?
Aber wie übergebe ich diese dann?
synchronized (this) passt so?
Mache ich dann sowas in der Art:
tasks.add(myStoppableThreadObject) ?

 

[mrBrown]

Ok, also sowas wie die StoppableThread von @@Robat ?

Ja, so in der Art - musst das halt an deine Erfordernisse anpassen.

Aber wie übergebe ich diese dann?

So wie jetzt auch. Musst nur die execute-Funktion entsprechend anpassen, die hat ja bisher niemand gesehen.

synchronized (this) passt so?

Keine Ahnung - wozu ist denn die Task-Liste da?

Mache ich dann sowas in der Art:
tasks.add(myStoppableThreadObject) ?

Du solltest das schon an den ExecutorService übergeben, sonst passiert nicht viel...

 

[beta20]

Ja, so in der Art - musst das halt an deine Erfordernisse anpassen.
Keine Ahnung - wozu ist denn die Task-Liste da?
Du solltest das schon an den ExecutorService übergeben, sonst passiert nicht viel...

Die Taskliste speichert alle ausstehenden Tasks (Prozesse). Weiß nicht, ob das wirklich gebraucht wird?

Du solltest das schon an den ExecutorService übergeben, sonst passiert nicht viel...

Wie genau soll das aussehen?

 

[mihe7]

Die Taskliste speichert alle ausstehenden Tasks (Prozesse). Weiß nicht, ob das wirklich gebraucht wird?

Über die Taskliste kannst Du über eine Art "ID" (= Index der Liste) auf die Futures zugreifen. Allerdings bringt es natürlich nichts, wenn Du lokal eine neue Liste erstellst, die Futurs dort einfügst, um dann nichts mit der Liste anzustellen. Auch brauchst Du dann keinen synchronisierten Zugriff auf die Liste.

Wie genau soll das aussehen?

Wie in Deinem jetzigen Code auch: mes.submit(...)

 

[beta20]

Über die Taskliste kannst Du über eine Art "ID" (= Index der Liste) auf die Futures zugreifen. Allerdings bringt es natürlich nichts, wenn Du lokal eine neue Liste erstellst, die Futurs dort einfügst, um dann nichts mit der Liste anzustellen. Auch brauchst Du dann keinen synchronisierten Zugriff auf die Liste.

naja ich will aber von meiner WebGUI die Prozesse auch killen können.
Was ich mir vorstellen könnte ist, dass ich die ProcessID + den Host in dem "ScheduleExecution" - Objekt speichere.
In der WebGUI zeige ich ja alle ScheduleExecutions an. Hier sollte es dann ebenfalls einen Button geben: " Schedule abbrechen".
Dann wird wird auf diesem Host der Prozess mit diese ID abgebrochen? Oder wie könnte man das lösen?

Wie in Deinem jetzigen Code auch: mes.submit(...)

OK, aber welches Objekt übergebe ich dann? Das von "StoppableThread" ?

 

[Xyz1]

Wie wär s denn damit:

import java.util.ArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class Threads {
	private int i = 0;
	private ArrayList<Runnable> l = new ArrayList<Runnable>();
	private ArrayList<Future<?>> m = new ArrayList<>();
	private ExecutorService es = Executors.newFixedThreadPool(4);

	int addRunnableGetIndex(Runnable r) {
		m.add(es.submit(r));
		l.add(r);
		i++;
		return i;
	}

	boolean stopRunnable(int index) {
		return m.get(index).cancel(true);
	}

	public static void main(String[] args) {
		Threads t = new Threads();
		t.addRunnableGetIndex(() -> {
			try {
				Thread.sleep(5000);
				System.out.println("Hello " + 5000);
			} catch (InterruptedException e) {
				System.out.println(e);
			}
		});
		t.addRunnableGetIndex(() -> {
			try {
				Thread.sleep(4000);
				System.out.println("Hello " + 4000);
			} catch (InterruptedException e) {
				System.out.println(e);
			}
		});
		t.addRunnableGetIndex(() -> {
			try {
				Thread.sleep(3000);
				System.out.println("Hello " + 3000);
			} catch (InterruptedException e) {
				System.out.println(e);
			}
		});
		t.addRunnableGetIndex(() -> {
			try {
				Thread.sleep(10000);
				System.out.println("Hello " + 10000);
			} catch (InterruptedException e) {
				System.out.println(e);
			}
		});
		System.out.println(t.stopRunnable(1));
		System.out.println(t.stopRunnable(3));
	}
}

true
true
java.lang.InterruptedException: sleep interrupted
Hello 3000
Hello 5000

What is happening?
4 threads are queued, 3 are already started, the 4th is not yet started, 2 are stopped (true true), one of them is interrupted, two give out after 3 and 5 seconds. (sorry, heute ist friday, eh ich mein Freitag....)

 

[mihe7]

naja ich will aber von meiner WebGUI die Prozesse auch killen können.

Bei Deiner Liste handelt es sich aktuell um eine lokale Variable. Die gibt es nach dem Methodenaufruf nicht mehr.

OK, aber welches Objekt übergebe ich dann? Das von "StoppableThread" ?

Ja, ein Callable oder ein Runnable.

 

[beta20]

Bei Deiner Liste handelt es sich aktuell um eine lokale Variable. Die gibt es nach dem Methodenaufruf nicht mehr.

Aber wenn der EJB Container global läuft und nicht sessionabhängig ist?

@Tobias-nrw
brauche wie gesagt die ID usw.

 

[Xyz1]

brauche wie gesagt die ID usw

Über eine ID wird das nicht funktionieren, vermute ich.... insofern damit nicht mein Index siehe oben gemeint sei....

 

[beta20]

Über eine ID wird das nicht funktionieren, vermute ich.... insofern damit nicht mein Index siehe oben gemeint sei....

deshalb kam ja der Vorschlag eine eigene Klasse zu schreiben, die eine ID und die stop Methode u.a. enthält?

 

[mrBrown]

Ja, modellier Dir das ganze erstmal sinnvoll, ohne den JavaEE-Kram einzubeziehen.