Wie kann man das Ausführen der Threads Priorisieren

[ManSues]

Ich habe einen "Hauptthread" und mehrere "Nebenthreads". Alle greifen auf eine TThreadlist zu. Jetzt möchte ich den Zugriff auf TThreadlist priorisieren. Kann mir jemand sagen, wie man das macht?

Details:

HauptThread
TThreadlist.lock
was heraus holen
TThreadlist.unlock
Do something

NebenThread1
NebenThread2
NebenThread3
NebenThread4
:
NebenThread_n
alle rufen folgende Funktion auf
INPUT(data)
TThreadlist.lock
was hinein legen
TThreadlist.unlock

Der HauptThread soll die TThreadlist öffnen und schließen.
Dann soll nur EINER der Nebenthreads TThreadlist öffnen und schließen.
Dann soll wieder der HauptThread die TThreadlist öffnen und schließen.
Jetzt der nächste Nebenthread u.s.w. bis es wieder von vorne anfängt.

[grl]

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

[ManSues]

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!

[Uwe Raabe]

Zitat:

Zitat von ManSues (Beitrag 1253472)

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

Das ist das Wesen einer Multithreadanwendung.

Zitat:

Zitat von ManSues (Beitrag 1253472)

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.

[Namenloser]

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.

[Sir Rufo]

Also generell kann man so etwas mit einem TEvent lösen

Delphi-Quellcode:

type
  TFoo = class
  private
    FThrottle : TEvent;
    FCS : TCriticalSection;
    procedure ReleaseThrottle;
  public
    constructor Create;
    destructor Destroy; override;

    procedure DoSomethingThrottled;
    procedure DoSomethingDifferent;
  end;

implementation

{ TFoo }

constructor TFoo.Create;
begin
  inherited Create;
  FThrottle := TEvent.Create( nil, False, False, '' );
end;

destructor TFoo.Destroy;
begin
  FThrottle.Free;
  FCS.Free;
  inherited;
end;

procedure TFoo.DoSomethingDifferent;
begin
  FCS.Enter;
  try
    // Aus der Liste holen
  finally
    FCS.Leave;
  end;
  ReleaseThrottle; // dem nächsten Thread den Zugang erlauben
end;

procedure TFoo.DoSomethingThrottled;
begin
  if FThrottle.WaitFor = TWaitResult.wrSignaled
  then
  begin
    FCS.Enter;
    try
      // In die Liste Legen
    finally
      FCS.Leave;
    end;
  end;
end;

procedure TFoo.ReleaseThrottle;
begin
  FThrottle.SetEvent;
end;

Der Hauptthread ruft jetzt immer

Delphi-Quellcode:

DoSomethingDifferent

auf und alle SubThreads rufen

Delphi-Quellcode:

DoSomethingThrottled

auf.
Der Event sorgt dafür, dass immer nur ein Thread durchschlüpfen kann und der nächste Thread, wenn im

Delphi-Quellcode:

DoSomethingDifferent

das

Delphi-Quellcode:

ReleaseThrottle

aufgerufen wird.

Über Sinn und Unsinn mag ich hier jetzt nicht diskutieren, aber es geht ;)

PS Die CriticalSection ist natürlich bei einer ThreadList unnötig

[himitsu]

Zitat:

Zitat von Uwe Raabe (Beitrag 1253473)

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.

[ManSues]

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!)

[Sir Rufo]

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:

Delphi-Quellcode:

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

[Namenloser]

Zitat:

Zitat von ManSues (Beitrag 1253495)

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:

Zitat von ManSues (Beitrag 1253495)

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.