Hmmmm - es sollen also die Nebenthreads warten "bis sie dran sind"? Widerspricht das nicht dem Konzept der Threads?

Ich löse sowas eigentlich immer über Thread.Priority - der wirklich wichtige bekommt eben mehr Priorität.

Wenn es wirklich wichtig ist, daß immer EINMAL der HauptThread und dann EINMAL einer der NebenThreads schreibt, dann würde ich mir überlegen, ob das Design richtig ist und ob's nicht gescheiter ist, das alles über den Hauptthread abzuwickeln ist, da du da zwangsläufig eine Wartesituation zusammenbringst.

Nur mal aufgrund der Informationen ins Blaue geraten,

GRL

Hallo,

nicht ganz, vielleicht sollte ich noch erwähnen, dass sich die Nebenthreads in DLLs befinden und es nicht vorhersehbar ist, wann sie schreiben wollen.
Noch genauer: die DLLs füllen die TThreadlist mit Telegrammen und der Hauptthread versendet sie per TCP.
Problem: Wenn ich die Nebenthreads nicht in ihre Schranken weise, schreiben die so viel, dass ich keine Zeit mehr habe um die Daten zu versenden!

Zitat von ManSues:

dass sich die Nebenthreads in DLLs befinden und es nicht vorhersehbar ist, wann sie schreiben wollen.

Das ist das Wesen einer Multithreadanwendung.

Zitat von ManSues:

Noch genauer: die DLLs füllen die TThreadlist mit Telegrammen und der Hauptthread versendet sie per TCP.
Problem: Wenn ich die Nebenthreads nicht in ihre Schranken weise, schreiben die so viel, dass ich keine Zeit mehr habe um die Daten zu versenden!

Dann solltest du das konsequent im Code umsetzen - z.B. das Schreiben nur erlauben, wenn die Liste nicht zu voll ist oder über eine Semaphore den maximalen Füllstand der Liste beschränken oder wie auch immer. Die Thread-Prioritäten zu ändern kann durchaus auch unerwünschte Nebenwirkungen haben.

Zitat von Uwe Raabe:

Die Thread-Prioritäten zu ändern kann durchaus auch unerwünschte Nebenwirkungen haben.

Und wenn genügend CPU-Kerne frei sind, dann bringt es auch absolut nichts.
Denn selbst wenn ein Thread eine geringere Prio hat, wie ein anderer Thread, so kann es dennoch sein, daß der mit der geringeren Prio genauso schnell oder sogar schneller ist.

Das mit den Events ist ein sehr interessanter und konstruktiver Vorschlag, danke.
Vielleicht habe ich mich mit dem Wort "Priorität" falsch ausgedrückt. Ich meinte nicht die Thread-Priorität. Man kann es auch einfach als Umschalter sehen zwischen füllen und leeren. Und schließlich muss mehr geleert werden als gefüllt, sonst funktioniert es nicht. Da ist es auch OK, wenn ein Füller wartet. Also ganz primitive betrachtet eine einfache Serialisierung.

Jeder DLL eine eigene Liste zu geben würde den Aufwand produzieren, dass wieder die DLL Listen gelockt und verwaltet werden müssten.

Man kann es auch mal ganz extrem sehen (was auch möglich wäre): Es gibt 100 Nebenthreads die fast gleichzeitig schreiben wollen. Da wäre der Hauptthread lange am warten, bis er wieder dran kommt (in Versuch nachgewiesen!)

Das mit dem Event kann man auch umdrehen.

Wenn der Sende-Thread lesen möchte, dann wird der Event zurückgesetzt und alle Empfangs-Threads werden durch den Event aufgehalten und können erst mal nicht mehr schreiben.
Ist der Sende-Thread fertig mit lesen, dann setzt der wieder den Event und alle schreiben wieder lustig in die Liste.

Dazu muss der Event wie folgt initialisiert werden:

markieren

Delphi-Quellcode:

TEvent.Create(
  nil,
  True, {ManualReset}
  True, {InitialState}
  '' );

Zitat von ManSues:

Jeder DLL eine eigene Liste zu geben würde den Aufwand produzieren, dass wieder die DLL Listen gelockt und verwaltet werden müssten.

Was ist daran mehr Aufwand? Aktuell lockst du doch auch bei jedem Zugriff eine Liste.

Zitat von ManSues:

Man kann es auch mal ganz extrem sehen (was auch möglich wäre): Es gibt 100 Nebenthreads die fast gleichzeitig schreiben wollen. Da wäre der Hauptthread lange am warten, bis er wieder dran kommt (in Versuch nachgewiesen!)

In dem Fall wäre dann die Thread-Priorität eigentlich schon die richtige Stellschraube.

Edit: Falls es nicht klar war, jede Liste hätte natürlich auch ihr eigenes Lock. Sonst wäre die Sache witzlos.

Zitat von Namenloser:

Zitat von ManSues:

Man kann es auch mal ganz extrem sehen (was auch möglich wäre): Es gibt 100 Nebenthreads die fast gleichzeitig schreiben wollen. Da wäre der Hauptthread lange am warten, bis er wieder dran kommt (in Versuch nachgewiesen!)

In dem Fall wäre dann die Thread-Priorität eigentlich schon die richtige Stellschraube.

Nicht wirklich. Daran schrauben ist schon ok und sollte man wohl auch machen, aber als richtige Lösung ist das nicht zu sehen, da man sich hier auf eine Verhalten stützt, was man selber nicht wirklich in der Hand hat.
Und wirklich viele Prioritäts-Stufen hat man nicht (ist auch unnötig), so dass die echte Kontrolle immer selber erfolgen sollte. Die Priorität ist nur unterstützend zu sehen und hilft dem Betriebssystem beim Verteilen der Zeitscheiben.

Hi Sir Rufo,

danke für den 2. Hinweis. Genau so brauche ich es. Denn wenn es nichts zu senden gibt, sollen die Clients in die Liste ja ungehindert schreiben können. Damit wäre auch der Charakter des Multithreading wieder vorhanden, eben nur mit einen Thread-König, der das sagen hat. So wie ich dem Thread-König sein Thread-Sleep einstelle, verschiebe ich die Zeitscheibe für schreiben und lesen. Effekt ganz nebenbei: Die Clients schreiben nicht nur, sondern packen die Daten auch in schon vorhandene Telegramme, also packen Telegramme voll damit der Overhead zu den Nutzdaten klein bleibt.
Du siehst, es ist eine feine Abstimmung, damit es richtig funktioniert. Aber jetzt habe ich wenigstens eine Stellschraube!

Warum schreiben die alle in die gleiche Liste? Mach doch für jeden Thread eine eigene Liste, und dann arbeitest du die Listen im Hauptthread nach Priorität ab.