Queue.Queue vs. collection.deque

Ich brauche eine Warteschlange, in die mehrere Threads Inhalte einfügen können und aus der mehrere Threads lesen können.

Python hat mindestens zwei Warteschlangenklassen, Queue.Queue und collection.deque, wobei die erstere anscheinend die letztere intern verwendet. Beide behaupten, in der Dokumentation threadsicher zu sein.

In den Warteschlangendokumenten heißt es jedoch auch:

collection.deque ist eine alternative Implementierung von unbegrenzten Warteschlangen mit schnellen atomaren append () - und popleft () -Operationen, für die kein Sperren erforderlich ist.

Was ich wohl nicht ganz verstehe: Bedeutet das, dass Deque doch nicht vollständig threadsicher ist?

Wenn ja, kann ich den Unterschied zwischen den beiden Klassen nicht vollständig verstehen. Ich kann sehen, dass die Warteschlange Blockierungsfunktionen hinzufügt. Auf der anderen Seite verliert es einige Deque-Funktionen wie die Unterstützung des In-Operators.

Der direkte Zugriff auf das interne Deque-Objekt ist

x in Queue (). deque

Thread-sicher?

Warum verwendet Queue einen Mutex für seine Operationen, wenn deque bereits threadsicher ist?

Queue.Queueund collections.dequedienen verschiedenen Zwecken. Queue.Queue ist dafür vorgesehen, dass verschiedene Threads mithilfe von Nachrichten / Daten in der Warteschlange kommunizieren können, während sie collections.dequelediglich als Datenstruktur gedacht sind. Warum das Queue.Queuehat Methoden wie put_nowait(), get_nowait()und join(), während collections.dequedies nicht tut. Queue.Queueist nicht dazu gedacht, als Sammlung verwendet zu werden, weshalb es an den inBetreibern mangelt .

Es läuft darauf hinaus: Wenn Sie mehrere Threads haben und möchten, dass diese ohne Sperren kommunizieren können, suchen Sie nach Queue.Queue; Wenn Sie nur eine Warteschlange oder eine Warteschlange mit zwei Enden als Datenstruktur möchten, verwenden Sie collections.deque.

Schließlich spielt der Zugriff auf und die Manipulation der internen Deque von a Queue.Queuemit dem Feuer - das wollen Sie wirklich nicht.

Wenn Sie nur nach einer thread-sicheren Methode suchen , um Objekte zwischen Threads zu übertragen , funktionieren beide (sowohl für FIFO als auch für LIFO). Für FIFO:

• Queue.put()und Queue.get()sind threadsicher
• deque.append()und deque.popleft()sind threadsicher

Hinweis:

• Andere Operationen sind dequemöglicherweise nicht threadsicher, ich bin mir nicht sicher.
• dequeblockiert nicht pop()oder popleft()so können Sie Ihren Consumer-Thread-Fluss nicht auf das Blockieren stützen, bis ein neuer Artikel eintrifft.

Es scheint jedoch, dass Deque einen signifikanten Effizienzvorteil hat . Hier sind einige Benchmark-Ergebnisse in Sekunden mit CPython 2.7.3 zum Einfügen und Entfernen von 100.000 Elementen

deque 0.0747888759791
Queue 1.60079066852

Hier ist der Benchmark-Code:

import time
import Queue
import collections

q = collections.deque()
t0 = time.clock()
for i in xrange(100000):
    q.append(1)
for i in xrange(100000):
    q.popleft()
print 'deque', time.clock() - t0

q = Queue.Queue(200000)
t0 = time.clock()
for i in xrange(100000):
    q.put(1)
for i in xrange(100000):
    q.get()
print 'Queue', time.clock() - t0

Zur Information gibt es ein Python-Ticket, auf das für die Sicherheit von Deque-Threads verwiesen wird ( https://bugs.python.org/issue15329 ). Titel "Klarstellen, welche Deque-Methoden threadsicher sind"

Fazit hier: https://bugs.python.org/issue15329#msg199368

Die Operationen append (), appendleft (), pop (), popleft () und len (d) der Deque sind in CPython threadsicher. Die Append-Methoden haben am Ende ein DECREF (für Fälle, in denen Maxlen festgelegt wurde). Dies geschieht jedoch, nachdem alle Strukturaktualisierungen vorgenommen und die Invarianten wiederhergestellt wurden. Daher ist es in Ordnung, diese Operationen als atomar zu behandeln.

Wie auch immer, wenn Sie nicht 100% sicher sind und Zuverlässigkeit der Leistung vorziehen, setzen Sie einfach ein ähnliches Schloss;)

Alle Einzelelementmethoden dequesind atomar und threadsicher. Alle anderen Methoden sind ebenfalls threadsicher. Solche Dinge len(dq), dq[4]ergeben momentane richtige Werte. Aber denken Sie zB an dq.extend(mylist): Sie erhalten keine Garantie dafür, dass alle Elemente in mylisteiner Reihe abgelegt werden, wenn andere Threads auch Elemente auf derselben Seite anhängen - dies ist jedoch normalerweise keine Voraussetzung für die Kommunikation zwischen Threads und für die fragliche Aufgabe.

A dequeist also ~ 20x schneller als Queue(was a dequeunter der Haube verwendet) und es sei denn, Sie benötigen nicht die "komfortable" Synchronisations-API (Blockieren / Timeout), die strikte maxsizeEinhaltung oder die "Diese Methoden überschreiben" (_put, _get, .. ) um das Unterklassifizierungsverhalten anderer Warteschlangenorganisationen zu implementieren , oder wenn Sie sich selbst um solche Dinge kümmern, ist ein Bare dequeein gutes und effizientes Geschäft für die Hochgeschwindigkeitskommunikation zwischen Threads.

Tatsächlich ist die häufige Verwendung eines zusätzlichen Mutex und einer zusätzlichen Methode ._get()usw. Queue.pyauf Abwärtskompatibilitätsbeschränkungen, frühere Überkonstruktionen und mangelnde Sorgfalt bei der Bereitstellung einer effizienten Lösung für dieses wichtige Problem mit Geschwindigkeitsengpässen bei der Kommunikation zwischen Threads zurückzuführen. In älteren Python-Versionen wurde eine Liste verwendet - aber auch list.append () /. Pop (0) war & ist atomar und threadsicher ...

Hinzufügen notify_all()zu jedem deque appendund popleftführt zu weit schlechteren Ergebnissen für dequeals die 20x Verbesserung durch Standard erreicht dequeVerhalten :

deque + notify_all: 0.469802
Queue:              0.667279

@ Jonathan ändert seinen Code ein wenig und ich erhalte den Benchmark mit cPython 3.6.2 und füge eine Bedingung in der Deque-Schleife hinzu, um das Verhalten der Warteschlange zu simulieren.

import time
from queue import Queue
import threading
import collections

mutex = threading.Lock()
condition = threading.Condition(mutex)
q = collections.deque()
t0 = time.clock()
for i in range(100000):
    with condition:
        q.append(1)
        condition.notify_all()
for _ in range(100000):
    with condition:
        q.popleft()
        condition.notify_all()
print('deque', time.clock() - t0)

q = Queue(200000)
t0 = time.clock()
for _ in range(100000):
    q.put(1)
for _ in range(100000):
    q.get()
print('Queue', time.clock() - t0)

Und es scheint, dass die Leistung durch diese Funktion begrenzt ist condition.notify_all()

collection.deque ist eine alternative Implementierung unbegrenzter Warteschlangen mit schnellen atomaren append () - und popleft () -Operationen, für die kein Sperren erforderlich ist. docs Queue

dequeist threadsicher. "Vorgänge, für die kein Sperren erforderlich ist" bedeutet, dass Sie das Sperren nicht selbst durchführen müssen, sondern sich darum dequekümmern.

Wirft man einen Blick auf die QueueQuelle, wird der interne deque genannt self.queueund verwendet ein Mutex für Zugriffs- und Mutationen, so Queue().queueist nicht zu verwenden Thread-sicher.

Wenn Sie nach einem "In" -Operator suchen, ist eine Deque oder Warteschlange möglicherweise nicht die am besten geeignete Datenstruktur für Ihr Problem.

(Anscheinend habe ich keinen Ruf zu kommentieren ...) Sie müssen vorsichtig sein, welche Methoden der Deque Sie aus verschiedenen Threads verwenden.

deque.get () scheint threadsicher zu sein, aber ich habe festgestellt, dass dies der Fall ist

for item in a_deque:
   process(item)

kann fehlschlagen, wenn ein anderer Thread gleichzeitig Elemente hinzufügt. Ich habe eine RuntimeException erhalten, die sich über "während der Iteration mutierte Deque" beschwert hat.

Überprüfen Sie collectionsmodule.c, um festzustellen, welche Vorgänge davon betroffen sind