Frage zu XE7 Threadpool

[newbe]

Hallo allerseits,

ich hätte mal einige Fragen bezüglich TThreadpool unter XE7.

Wenn ich mit folgenden Code Worker erzeuge

Delphi-Quellcode:

  
TThreadPool.Default.QueueWorkItem(procedure
      begin
        TestPing5(IP, Node, Interval, Hop);
      end)

;

erzeugt er dann TTaskObjecte oder TThread Objecte? Frage weil in der Workerroutine dat hier funktioniert

PingResult.ThreadID:= TThread.CurrentThread.ThreadID; beim Zugriff über TTask.CurrentTask knallt es, weil das Taskobject nil ist.

Und zweite Frage ich habe es jetzt so programmiert, das die Workers sich selber sauber beenden mittels globalen Boolean Stopvariablen. Finde ich sehr unschön. Zugriff von Außen habe ich damit auch nicht auf den Worker, um ihn zum Besipiel zu pausieren oder zu wieder aufzunehmen. Ich hab irgendwo gelesen, das TThreadpool eine Threadsichere Liste anbieten soll, mit der ich von Außen Zugriff auf die einzelnen Workers als TTask bekomme. Jedoch kann ich nirgens so eine Liste im TThreadpoolobject finden. Hat Jemand eine Idee?

mfg newbe

[Sir Rufo]

Es wird weder noch erzeugt. Wenn du einen Task haben möchtest, dann nimm TTask.Run oder TTask.Create , dann funktioniert auch TTask.CurrentTask .

TThread.CurrentThread.ThreadID funktioniert deshalb, weil das immer funktioniert. Egal was da läuft, alles läuft in einem Thread. Die Frage ist allerdings ob im MainThread (ist auch ein Thread) oder nicht.

Der ThreadPool sorgt aber dafür, dass die Methode in einem Thread <> MainThread abgearbeitet wird, allerdings nicht mit einem Task-Gerüst drumherum (du hast ja auch keinen Task erzeugt).

Das Abbrechen von den Tasks ist generell in der TPL sehr unglücklich gelöst. Und obwohl vieles von .NET abgekupfert ist, hat man die Details (z.B. CancellationToken/CancellationTokenSource etc.) einfach mal weggelassen und so eine Schmalspur-Variante eingebaut.

[newbe]

@ Sir Rufo

dann habe ich offensichtlich die Videos zur TPL nicht ganz verstanden. Ich nahm an, das die gesamte TPL auf der TTask Implementierung basiert, sozusagen einer Klasse mit etwas Overhead, welcher aber das Threadhandling sehr vereinfacht. Ich dachte wenn ich über

TThreadPool.Default.QueueWorkItem Workermethoden hinzufüge wird automatisch daraus ein TTaskobject erstellt. Das ist also nicht so?
Bleibt meine Frage nach der Locking Threadlist die es in TThreadpool geben soll und welche meine generierten Threads managen soll.
Das ist ja eigentlich eine der Kernfunktionen welche es beim Threadmanagment gibt. Ansonsten kann ich auch die OTL nutzen. Das mit dem fehlenden Cancellation Token ist auch mal wieder typischer halbgarer Embarcadero Käse, aber wir sind es ja schon gewöhnt. Will mich jetzt auch nicht aufregen. Kurze Frage noch an dich. Ich habe im Inet einen Beitrag von dir zu Bugs in der TPL entdeckt auf SO entdeckt (Stichwort Threadstealing) Kannst du mir sagen ob diese Bugs in XE7 Update 1 denn überhaupt gefixt wurden? Ansonsten ist ja wahrscheinlich von der Seite aus nix mehr von Emba zu erwarten.

mfg Newbe

[Sir Rufo]

Wieso macht die TPL doch und wenn du damit richtig arbeitest, dann hast du doch auch einen Task.

Was ist denn jetzt so schwer daran?

Und welche von dir generierten Threads gibt es denn? Nicht einen, denn du erzeugst Tasks und keine Threads.

Die Threads erzeugt der ThreadPool und damit werden die Tasks abgearbeitet.

Warum willst du jetzt auf die Threads zugreifen?

In XE8 sind meine BugFixes (soweit ich das gesehen habe) wohl 1:1 übernommen worden. Das XE7U1 habe ich komplett ausgelassen, denn die alten Bugs hatte ich behoben und mit den neuen wollte ich mich nicht nochmal auseinandersetzen

[pertzschc]

Zitat von newbe:

ich hätte mal einige Fragen bezüglich TThreadpool unter XE7.

Ich habe auch eine Frage: kann man diese auch unter Delphi 2010 nutzen oder gibt es dort analog etwas (von Drittanbietern)?
Grüße, Christoph

[Sir Rufo]

Zitat von pertzschc:

Zitat von newbe:

ich hätte mal einige Fragen bezüglich TThreadpool unter XE7.

Ich habe auch eine Frage: kann man diese auch unter Delphi 2010 nutzen oder gibt es dort analog etwas (von Drittanbietern)?
Grüße, Christoph

OTL => OmniThreadLibrary

[pertzschc]

Zitat von Sir Rufo:

OTL => OmniThreadLibrary

Danke!

[newbe]

@Sir Rufo

Ich halte ma fest, der Threadstealingbug ist also auch in Xe7 UPd1 drin, sehr toll. Mit XE8 will ich aber nicht arbeiten. Neues Design find ich kacke von den Bugs ma ganz ab.

Bzg. der TThreads/TTask bin ich etwas verwirrt, da du ja in dem vorherigen Post schriebst das ich keine mit meinem Code erzeuge.

Nochmal zum Verständnis, Ich möchte von Dir wissen wie ich dann halt diese Threadsichere locking Tasklist nutzen kann, und zwar nachdem die Tasks im Threadpool queued wurden. Alles was ich bisher an Task Beispielen gesehen habe sind nach dem schema: task.run mache was was endliche zeit dauert.
Ich habe hier aber Task die die ganze Zeit laufen und suche nach einer Methode diese von Außen zu suspenden bzw. abzubrechen und zwar ohne Stopvariablen und solche einen Quark. Werde mit rotzdem ma parallel die OTL anschauen.

mfg newbe

[Sir Rufo]

Die TPL ist für begrenzt laufende Aufgaben gedacht und nicht für Dauerläufer. Denn wenn du Pech hast, dann laufen einige von deinen Dauertasks erst gar nicht an.

Der ThreadPool steuert wieviele Worker gleichzeitig Tasks abarbeiten anhand der Systemauslastung und CPU-Anzahl.

Somit ist das also der falsche Weg. Bau dir einen Thread und gut ist. Auch mit der OTL wirst du da nicht glücklich werden, denn auch da ist die Anzahl der Threads begrenzt, egal ob die nun die meiste Zeit schlafen oder nicht.

Mit einem Blick auf .Net wäre das was du als Wrapper suchst wohl eher der BackgroundWorker, den man auch in Delphi nachbauen kann. Da ist es dann egal, wieviele davon aktiv laufen (solange das System und der Speicher das mitmachen).

[newbe]

@Sir Rufo

Ich kenne den .Net Backgroundworker und denke er wäre in meinem Falle nicht angebracht. Auch finde ich die Threadlimetierung von TThreadpool praktisch.
Da es sich bei meinen Thread um Network IO Threads handelt und zu viele gleichzeitig laufende zu Problemen führen. In meinem konkreten Fall habe ich maximal 32 Threads gleichzeitig am laufen, meistens jedoch nur so ca. 8-10. Wenn ich auf 6 limitiere läuft alles gut. Klar könnte ich das alles auch mit if's und while schleifen lösen, aber eben genau das will ich nicht, weil ich solche konstruckte unschön finde. Die Threads oder auch Tasks im Threadpool zu queuen ist da schon die optimalste Lösung denk ich. Läuft ja auch schon alles so wie es soll. Ich suche nur nach ner Möglichkeit die laufenden Threads
zu suspenden und Threadpool zu sagen und unterbrich die Abarbeitung der Queue. Später möchte ich das ganze natürlich auch resumen können. darum gehts mir. Ich muss also von außen an die Thread/taskobjecte rann. Falls das mit Threadpool nich gehen sollte fänd ich das ganze Ding etwas sinnlos. Klar könnte ich threads erzeugen und mir die handles in ne liste ballern dann ginge das. ich habe aber im inet gelesen das das angeblich mit Threadpool so einfach gehn soll da dieses einen threadsafe locking Liste bieten soll.

mfg newbe