C++ - Threads und mehrere Warteschlangen

Question

Ich muss ein System von Arbeitern (repräsentiert als Threads) und (mehreren) Warteschlangen aufbauen. Individuelle Aufgaben warten in einer der Warteschlangen und warten darauf, von einem Arbeiter-Thread verarbeitet zu werden. Jeder Arbeiter kann Aufgaben nur aus einigen der Warteschlangen verarbeiten. Kein Dauerschleifen-Warten. C/C++, pthreads, Standard-POSIX.

Das Problem für mich ist die Sache mit den "mehreren Warteschlangen". Ich weiß, wie ich dies mit einer einzelnen Warteschlange implementieren kann. Die Arbeiter müssen auf allen Warteschlangen warten, die sie verarbeiten können (Warten auf BELIEBIGE von ihnen).

Auf Windows würde ich WaitForMultipleObjects verwenden, aber das muss plattformübergreifend sein.

Ich möchte keinen bestimmten Code dafür, nur einen Hinweis oder eine Beschreibung des Modells, das ich verwenden sollte. Danke im Voraus.

Answer 1

Statt für jede Warteschlange ein separates Schloss zu haben, warum nicht ein Schloss für alle Warteschlangen verwenden?

1. Auf das Schloss warten
2. Das Schloss erhalten
3. Aus der jeweiligen Warteschlange entfernen
4. Das Schloss freigeben
5. Das entfernte Element verarbeiten
6. Zu Schritt 1 gehen

Vorausgesetzt, dass das Entfernen vernachlässigbar lange dauert (das Schloss also nur vernachlässigbar kurze Zeit gehalten wird), besteht möglicherweise kein Bedarf an mehr als einem Schloss.

Answer 2

Sie könnten so etwas tun: Jeder Job hat eine ihm zugeordnete "Warteschlange". z. B.:

Angenommen, Sie haben 2 Warteschlangen. Ihre Jobs könnten so aussehen:

job[0].queue = 1; /* Dieser Job gehört zur Warteschlange 1 */
job[1].queue = 1;
job[2].queue = 2; /* Dieser Job gehört zur Warteschlange 2 */
... 
etc

Daher haben Sie Ihre "Tasche mit Threads". Ein Thread wählt einfach einen Job - sagen wir, job[2]. Wenn diesem Thread nur erlaubt ist, Jobs aus Warteschlange 1 zu verarbeiten, legt er diesen Job wieder in die Bereit-Warteschlange und wählt einen anderen Job aus.

Jeder Thread weiß also, welche Warteschlangen er verarbeiten darf, und wenn er einen Job auswählt, stellt er sicher, dass das Feld "queue" dieses Jobs übereinstimmt. Wenn nicht, wählt er einen anderen Job aus.

(Das ist in vielerlei Hinsicht, wie die Prozessplanung in Linux auf mehreren Kernen funktioniert. Jeder Prozess hat ein Bitmasken, die angibt welche Prozessoren erlaubt sind, auf denen er ausgeführt werden darf, und dann stellt der Prozessor sicher, dass er "berechtigt" ist, diesen Prozess auszuführen, bevor er dies tut.)

Answer 3

Ich habe in letzter Zeit darüber nachgedacht und die einzige Idee, die mir eingefallen ist (vorausgesetzt, Sie haben threadsichere Warteschlangen), ist, dass nur mehrere Threads eine einzelne Warteschlange bedienen.

Sie können dann einen oder mehrere Arbeitsproduktions-Threads haben, die Jobs zu einer einzelnen Warteschlange hinzufügen, und einen oder mehrere Worker-Threads, die auf der Warteschlange blockieren, bis sie etwas zum Verarbeiten finden.

Wenn Sie jemals mehrere Warteschlangen haben, auf die mehrere Worker-Threads zugreifen müssen, könnte eine Lösung darin bestehen, für jede Warteschlange einen zusätzlichen Thread hinzuzufügen und eine zusätzliche Warteschlange. Die zusätzlichen Threads blockieren jeweils auf ihrer eigenen einzelnen Warteschlange, leiten die Jobs jedoch einfach an die zusätzliche Warteschlange weiter. Jetzt blockieren die vorhandenen Worker-Threads wieder auf einer einzelnen Warteschlange.