C++ - Threads und mehrere Warteschlangen

Question

Ich muss ein System von Arbeitern (als Threads dargestellt) und (mehrere) Warteschlangen erstellen. Einzelne Jobs warten in einer der Warteschlangen und warten auf einen Worker-Thread, um sie zu verarbeiten. Jeder Worker kann Jobs nur von einigen der Warteschlangen verarbeiten. Keine Warteschleife. C/C++, Pthreads, Standard POSIX.

Das Problem für mich ist das „mehrere Warteschlangen“ Ding. Ich weiß, wie man das mit einer einzigen Warteschlange implementiert. Die Arbeiter müssen auf alle Warteschlangen warten, die sie verarbeiten können (auf ALLE warten).

Unter Windows würde ich WaitForMultipleObjects verwenden, aber dies muss Multi-Plattform 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

Was können Sie tun, ist eine condition variable verwenden. Lassen Sie Ihre Worker-Threads auf eine Bedingungsvariable warten. Wenn ein Job zu einer der Jobwarteschlangen hinzugefügt wird, melden Sie die Bedingungsvariable. Wenn der Worker-Thread dann aufwacht, überprüft er die Warteschlangen, auf die er wartet. Wenn einer von ihnen einen Job hat, nimmt er diesen Job aus der Warteschlange. Andernfalls wird wieder auf die Zustandsvariable gewartet. Wenn Sie auf eine Bedingungsvariable warten, wird der Thread in den Ruhezustand versetzt, sodass keine CPU-Zeit verbraucht wird.

Natürlich sollten Sie alle Zugriffe auf die Jobwarteschlangen mit einem Mutex schützen (z. B. pthread_mutex_t).

Answer 2

Wenn es nicht zu viele Arbeiter für jede Warteschlange sind, könnten Sie eine Bedingungsvariable für jeden Arbeitnehmer machen.

Answer 3

Klingt wie Sie den Einsatz von boost::thread, boost::condition und einem std::queue machen sollte.

Answer 4

Was ich tun würde, ist die Verwendung boost :: asio Daten in die Warteschlange einzureihen, so dass Ihre mehrere Threads gehen an es haben kann. Sie können einen Verweis über den Befehl post an die Warteschlange übergeben und den Thread entsprechend verarbeiten lassen.

Answer 5

Anstatt eine separate Sperre für jede Warteschlange zu haben, warum nicht eine Sperre für alle Warteschlangen haben?

1. Warten auf das Schloss
2. Holen das Schloss
3. Dequeue von welcher Warteschlange
4. die Sperre
5. Verfahren das Aus der Warteschleife angenommene Punkt
6. Goto Schritt 1

Unter der Annahme, dass die Aussperrung nimmt nur eine vernachlässigbare Zeit in Anspruch (so wird die Sperre nur für eine vernachlässigbare Zeit gehalten) Möglicherweise müssen Sie nicht mehr als eine Sperre verwenden.

Answer 6

Sie könnten so etwas tun: Jedem Job ist eine "Warteschlange" zugeordnet. ZB:

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

job[0].queue = 1; /* That job is in queue 1 */ 
job[1].queue = 1; 
job[2].queue = 2; /* this job is in queue 2 */ 
... 
etc 

Also dann haben Sie Ihre "Tasche von Threads". Ein Thread wählt einfach einen Job aus - sagen wir, Job [2]. Wenn dieser Thread nur Jobs aus der Warteschlange 1 verarbeiten darf, stellt er diesen Job wieder in die Bereit-Warteschlange und wählt einen anderen Job aus.

So weiß jeder Thread, welche Warteschlangen er verarbeiten darf, und wenn er einen Job auswählt, stellt er sicher, dass das Feld "Queue" des Jobs übereinstimmt. Wenn dies nicht der Fall ist, wählt es einen anderen Job.

(Dies ist in vielerlei Hinsicht, wie Prozessplanung in Linux auf mehreren Kernen funktioniert. Jeder Prozess hat eine Bitmaske, welche Prozessoren es erlaubt zu laufen, und dann der Prozessor stellt sicher, es ist "erlaubt", diesen Prozess auszuführen bevor dies zu tun)

Answer 7

Wie wäre.

• alle worker-Threads auf einem Semaphor warten
• , wenn etwas in die Warteschlange hinzugefügt wird, wird die Semaphore erhöht, was ein einzelner Thread
• wacht der Faden chec ks die Warteschlangen es interessiert ist, verarbeitet eine von ihnen und geht zurück auf die Semaphore zu warten

Sie zusätzliche Mutex müssen (es) zu tatsächlichen Steuerung lesen & zu den Warteschlangen schreibt.

Answer 8

Ich habe kürzlich darüber nachgedacht und die einzige Idee, die ich bekommen könnte, ist (vorausgesetzt, dass Sie thread-sichere Warteschlangen haben), nur mehrere Threads für eine einzige Warteschlange zu haben.

Sie können dann einen oder mehrere Arbeit produzierende Threads haben, die Jobs zu einer einzelnen Warteschlange und einem oder mehreren Worker-Threads hinzufügen, die in der Warteschlange blockieren, bis sie etwas zur Verarbeitung finden.

Wenn Sie mehrere Warteschlangen haben, die von mehreren Worker-Threads abgefragt werden müssen, besteht die Lösung darin, für jede Warteschlange und eine zusätzliche Warteschlange einen zusätzlichen Thread hinzuzufügen. Die zusätzlichen Threads blockieren jeweils für ihre eigene Warteschlange, leiten Jobs jedoch einfach an die zusätzliche Warteschlange weiter. Jetzt wird der vorhandene Arbeitsthread wieder in einer einzelnen Warteschlange blockiert.