Phtread 2 Klassengesellschaft und Producer-Consumer Problem

Hallo Zusammen,

Ich bräuchte mal wieder eure Hilfe. Ich habe folgendes Szenario:

1 bzw. mehrere Cores:

5 Threads A, B, C, D, E

Die Threads erledigen Aufgaben und sind wie folgt im Gesamtsystem eingebunden:

A: Hier kommen Aufgaben rein ins System -> Warteschlange (W : A) vor A
B: erledigt Aufgaben die von A kommen -> Warteschlange (W : vor B
C: erledigt Aufgaben die von B kommen -> Warteschlange (W : C) vor C
erledigt Aufgaben die von C kommen -> Warteschlange (W : D) vor D
E: erledigt auch Aufgaben die von C kommen -> Warteschlange (W : E) vor E

Zusätzlich gibt es einen Rücklauf von C nach A über Warteschlange W : A

C verteilt also Aufgaben in W : D als auch in W : E und in W : A

Fall 1 Core:

D und E sollen priorisiert ablaufen, da sie das Ende des Systems darstellen, d.h die Ergebnisse sind somit gültig. Thread D arbeitet nicht gerade viel ab und darf somit interleaved mit E ablaufen. Alle anderen Threads (A,B,C) sollen in der Zeit warten (würde diese ablaufen führe dies zu einer längeren Bearbeitungszeit von D und E aufgrund von Threadwechsel und somit würde es länger dauern bis die Ergebnisse fertig berechnet sind).

Sobald E fertig wird, signalisiert er, dass wieder weitergearbeitet werden kann -> A,B,C dürfen laufen. Da aber nur 1 Core da ist, soll genau nur 1 ablaufen.

Umgekehrt muss E immer auf C warten, bis dieser mitteilt, dass wieder etwas zu bearbeiten ist.

Wie könnte ich dies realisieren? D und E sollten ja irgendwie von der Priorität höher sein.

Fall mehrere Cores:

D und E sollen priorisiert ablaufen, da sie das Ende des Systems darstellen, d.h die Ergebnisse sind somit gültig. Thread D arbeitet nicht gerade viel ab und darf somit interleaved mit E ablaufen. Alle anderen Threads (A,B,C) können ablaufen, aber nur soviele, wie noch verbleibende Cores sind (sodass E und D) nicht interleaved werden. Jedoch ist gleiches spiel wie im ersten Fall: Abhängigkeiten zwischen den einzelnen Threads.

Mein Problem dabei ist, dass wenn ich E und D im ersten Fall (1 Core) total priorisieren würde, alle Aufgaben bei A nicht bearbeitet werden würden, bis E und D keine mehr haben -> keine neuen Aufgaben kämen ins System. Würde ich dagegen sagen E und D sind nicht soooo wichtig würde das System vollgestopft werden (A viele abarbeiten) aber keine Aufgaben bei D und E angelangen bei beispielsweise C keine bearbeitet.

Ich habe also 2 Klassen: A,B,C und D,E von Threads

Leider bin ich nun schon mehrere Tage mit Internetsuche, Bücherlesen etc nicht weitergekommen und hoffe einer von euch hat einen Tipp.

Irgendwie muss ich die gleichzeitig ablaufenden Threads von den Cores abhängig machen -> Dachte an Semaphore: Es können nur X Threads ihre Critical Section betreten, während die anderen warten müssen.

Falls Ihr Fragen habt, stellt die gerne. Ich hoffe ich konnte es einigermaßen erklären.

thx

Zur Anmerkung:

Das Producer-Consumer Problem ist natürlich gelöst. Ich habe als Warteschlange eine Linked List als Priority Queue, in die sortiert eingefügt wird und das am Head vom jeweiligen Thread herausgenommen wird. Mir geht es hier eigentlich nur um die Synchronisation zwischen den Threads, sodass ich die Restiktion, dass immer nur 1 Threads (bei einem Core bzw. D und E) bzw. X Threads bei X Cores laufen.