Threads Threads anhalten und wieder fortführen

[JavaPan]

Hallo,

ich habe gesucht und auch etliches gefunden jedoch keine echte Lösung für mein Problem.

Ich habe einen Thread der bis zu fünf Threads (nach selber festgelegten Prioritäten) verwalten
soll. Dazu habe ich mir überlegt, dass ich ein ThreadArray anlege in welchem ich die Referenzen
zu meinen Threads halte.
Es sollen die Threads aber immer sequentiell abgearbeitet werden, dazu gibt es die Prioritäten.

Thread[] threadArray = new Thread[4]; // threadArray[0] = höchste Priorität
                                      // threadArray[4] = niedrigste Priorität

Jetzt möchte ich nur!! das Falls in meinem Array ein Thread mit höherer Priorität auftaucht,
den aktuellen (falls seine Prio niedriger ist) unterbrechen und den anderen ausführen, später
soll dann die Referenz des Unterbrochenen Threads wieder geladen und weiterverarbeitet werden.

Meine Ansätze waren bisher mit ReentrantLock und Timer zu arbeiten was keinen Erfolg brachte.
Die suspend- und notify-Methoden von Thread sind ja deprecated und bringen auch keinen Erfolg.
Dann hatte ich noch ein Beispiel gelesen wo geraten wurde in Thread Klassen die angehalten werden
sollen, stopflags zu setzten und abzufragen und später dort weiterzumachen, was in meinem Fall jedoch
sehr umständlich, unübersichtlich und aufwendig wäre.

Ich kann mir nicht vorstellen das das in Java so quasi unmöglich ist Threads anzuhalten und dann was anderes
zu machen und später wieder aufzunehmen. Ich habe ja schon eigene Prioritäten festgelegt da die von der
JVM ja nicht bei allen OS funktionieren.

Ich danke für jeden Tipp oder weiterführenden Link.
Grüße JavaPan

 

[Asgar13]

Was du brauchst ist so etwas wie ein .waitFor() (nur für Prozess), das wartet auf den Prozess, bis dieser zu Ende ist.

Etwas passenden für Thread, kenne ich leider nicht :bahnhof:

 

[SlaterB]

> Ich habe ja schon eigene Prioritäten festgelegt da die von der JVM ja nicht bei allen OS funktionieren.
und was genau bewirken die? doch wohl nur bei deinem manuellen Code, bei deiner Auswahl von Aktionen irgendwas,
komplett von der Java-Thread-Verwaltung unabhängig,
wieso erwartest du bei einer anderen komplizierten Thread-Geschichte Besserung?

bei einer Eigenimplementierung besteht der Vorteil, dass ein Thread 10.000 Dinge machen kann, bevor ein Mensch auch nur blinzelt,
Kontrollcode muss also nur an relativ wenigen Stellen, evtl. in wichige Schleifen usw.,
wenn du dann noch alles in einer Methode check(); versteckst, dann vielleicht doch nicht mehr so aufwendig?

so wie ich das verstanden habe, reicht eine Methode check(), die die von außen gesetze Information 'du hast jetzt Pause ja/nein' prüft,
dann solange Pause macht oder auch nicht -> es geht weiter?

-------

edit:
falls du Thread-unabhängigen Code nicht mit diesem Controll-Aufruf verschandeln willst, dann solltest du diesen irgendwie modularisieren, aber bei langen Schleifen ist das wohl kaum möglich,
bisschen Code dann doch nicht vermeidbar, falls nicht AOP usw. reinkommt,
aber zumindest muss dieser Code nicht direkt vom Thread abhängen sondern könnte sich auf ein Interface Owner beziehen,
owner.workCheckpoint();

eine solche Struktur kann allgemein von Vorteil sein, z.B. auch um den Fortschritt der Arbeit in % zu dokumentieren

-----

wie funktioniert denn die Steuerung der Threads bisher, der Main-Thread außen vergleicht die Prioritäten, gibt die Zeit vor,
aber muss ja auch den Threads irgendwas mitteilen, diese dann arbeiten, hast du nicht also schon eine ähnliche Methode/ Codestelle?
nur vielleicht bisschen zentraler bisher?

> Es sollen die Threads aber immer sequentiell abgearbeitet werden, dazu gibt es die Prioritäten.

oder läuft jeder Thread bisher nur genau einmal von Anfang bis Ende durch, in Reihenfolge?

 

[gizmo]

Ich kann mir nicht ganz vorstellen, was du erreichen willst, wann welcher Thread an die Reihe kommt, wird vom OS oder der VM bestimmt. Falls die Threads voneinander abhängig sind, kannst du es machen, wie im untersten Beispiel auf: Java Concurrency - Part 5 : Monitors (Locks and Conditions) | @Blog("Baptiste Wicht")

Wenn es nur darum geht, Aufgaben parallel auszuführen, schau dir ThreadPool an. Es gibt hier ein Beispiel: Java Concurrency / Multithreading - Tutorial

Um Threads zu stoppen/weiterlaufen zu lassen, würde ich einen ReentrantLock verwenden.

 

[gizmo]

Es sollen die Threads aber immer sequentiell abgearbeitet werden, dazu gibt es die Prioritäten.

Ist mir erst jetzt aufgefallen. Bist du dir sicher, dass Threads der Richtige Ansatz sind? Der Sinn von Threads ist es, Aufgaben parallel abzuarbeiten, wenn du es sequentiell machst, brauchst du auch keine Threads...

 

[SlaterB]

bisher war es vielleicht nicht nötig, gerade jetzt mit der Unterbrechung zeigt sich der zweite, eher noch wichtigere Sinn von Threads
(da für den historischen Standardfall einer CPU letztlich sowieso alles sequentiell läuft)

der zweite Vorteil:
Threads teilen Arbeit auf, organisieren sie unabhängig, gerade so dass sie unterbrechbar sind und an anderer Stelle mit anderen Daten weiter gemacht werden kann,
das wäre anderenfalls wirklich schwer zu managen, und Organisation ist das O und das O in OO

edit: ok, das meintest du vielleicht auch

 

[gizmo]

@SlaterB: Kann sein, dass Threads sinnvoll sind, ich sehe aber noch nicht genau was der OP damit machen will...

@JavaPan: Kannst du grob umschreiben, was du insgesamt erreichen möchtest? Es scheint mir als wolltest du eine eigene Threadverwaltung programmieren. Brauchst du das wirklich?

 

[JavaPan]

Hallo,

vielen Dank erstmal für die Anregungen und Hilfestellungen.

Warum ich Threads für sequentielle Abarbeitung Einsetzten möchte:
Die Aufgaben der einzelnen Threads sind sehr komplex bzw. können
es sein, diese möchte ich klar voneinander getrennt haben und sie laufen
zwar sequentiell ab aber mein Hauptprogramm läuft ja auch noch und
muss die ganze Zeit auf API-Calls o.ä. reagieren.

ZU

@JavaPan: Kannst du grob umschreiben, was du insgesamt erreichen möchtest? Es scheint mir als wolltest du eine eigene Threadverwaltung programmieren. Brauchst du das wirklich?

Einige Threads z.B. ein Posting bei Facebook und protokollierung aller Daten und der
getätigten Aktionen in meiner CouchDB + MySql DB können sehr komplexe neue Aufgaben
anstossen z.B. Crawlen von Feeds / Friendlists o.ä..
Jetzt gibt es API Anfragen für die direkte Ausführung einiger Aktivitäten und Jobs, welche ich mir
wiederum vom Frontend hole, diese Aufgaben haben eine hohe Priorität und sollen möglichst sofort
(wenn ich das hinbekomme auch parallel ausgeführt werden).
Die daraus resultierenden weiterführenden Aktivitäten (welche, wie gesagt aber sehr komplex sein können)
sollen die oben erwähnten Aufgaben aber auf keinen Fall verzögern oder gar verhindern, daher sollen die
nur angestossen werden wenn keine Aufgaben dieser Prio laufen und auch angehalten (und später fort-
geführt werden) werden können wenn zwischenzeitlich eine Aufgabe mit höherer Prio anfällt.

Da kommen noch weitere Tätigkeiten hinzu daher 5 Prio-Stufen.

Ich schaue mir mal die Liks von gizzmo an evtl. helfen die ja dann schreibe ich noch was.

Danke euch erstmal für die Mühe

 

[SlaterB]

solange nicht unterbrochen wird, würde ein Thread reichen, um alle 5 bzw. beliebig viele Aufgaben in Reihenfolge zu setzen und nach und nach auszuführen,
das wäre immer noch nebenläufig zum sonstigen Programm

 

[JavaPan]

Danke,

Problem ist jetzt gelöst, zwar anders als ich mir das ursprünglich vorgestellt hatte aber
es funtzt und erfüllt seinen Zweck.
Habe die Lösung anhand der Links von gizzmo mit ReentrantLock und Conditions
zusammengebastelt. Und ich muss halt jetzt an geeigneten Stellen meiner Thread-Job
Klassen immer diese Methode aufrufen (die Klasse wird implementiert.)

	ReentrantLock rl;
	Condition c;
	
	public void mayInterrupt(){
		rl.lock();
		c.signal();
		c.awaitUninterruptibly();
		rl.unlock();
	}