Antrian. Antrian vs. collections.deque

Saya perlu antrian tempat beberapa utas dapat memasukkan berbagai hal, dan beberapa utas dapat dibaca.

Python memiliki setidaknya dua kelas antrian, Antrian. Antrian dan collections.deque, dengan yang pertama tampaknya menggunakan yang terakhir secara internal. Keduanya mengklaim aman dalam dokumentasi.

Namun, dokumen Antrian juga menyatakan:

collections.deque adalah implementasi alternatif dari antrian tidak terbatas dengan operasi append atom cepat () dan popleft () yang tidak memerlukan penguncian.

Yang saya kira saya tidak mengerti: Apakah ini berarti deque tidak sepenuhnya aman setelah semua?

Jika ya, saya mungkin tidak sepenuhnya memahami perbedaan antara kedua kelas. Saya dapat melihat bahwa Antrian menambahkan fungsi pemblokiran. Di sisi lain, ia kehilangan beberapa fitur deque seperti dukungan untuk operator.

Mengakses objek deque internal secara langsung, adalah

x dalam Antrian () .queque

aman?

Juga, mengapa Antrian menggunakan mutex untuk operasi itu ketika deque sudah thread-safe?

Queue.Queuedan collections.dequemelayani berbagai tujuan. Queue.Queue dimaksudkan untuk memungkinkan utas berbeda berkomunikasi menggunakan pesan / data yang antri, sedangkan collections.dequehanya dimaksudkan sebagai struktur data. Itu sebabnya Queue.Queuememiliki metode seperti put_nowait(), get_nowait(), dan join(), sedangkan collections.dequetidak. Queue.Queuetidak dimaksudkan untuk digunakan sebagai koleksi, karena itu ia tidak memiliki suka inoperator.

Intinya begini: jika Anda memiliki banyak utas dan Anda ingin mereka dapat berkomunikasi tanpa perlu kunci, Anda sedang mencari Queue.Queue; jika Anda hanya ingin antrian atau antrian ganda sebagai datastructure, gunakan collections.deque.

Akhirnya, mengakses dan memanipulasi deque internal Queue.Queuebermain dengan api - Anda benar-benar tidak ingin melakukan itu.

Jika semua yang Anda cari adalah cara aman untuk mentransfer objek di antara utas , maka keduanya akan berfungsi (baik untuk FIFO dan LIFO). Untuk FIFO:

• Queue.put()dan Queue.get()aman untuk benang
• deque.append()dan deque.popleft()aman untuk benang

catatan:

• Operasi lain pada deque mungkin tidak aman, saya tidak yakin.
• dequetidak memblokir pop()atau popleft()jadi Anda tidak dapat mendasarkan alur utas konsumen Anda pada pemblokiran sampai item baru tiba.

Namun, tampaknya deque memiliki keunggulan efisiensi yang signifikan . Berikut adalah beberapa hasil benchmark dalam hitungan detik menggunakan CPython 2.7.3 untuk menyisipkan dan menghapus item 100k

deque 0.0747888759791
Queue 1.60079066852

Inilah kode patokan:

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

Untuk informasi, ada tiket Python yang dirujuk untuk keamanan thread deque ( https://bugs.python.org/issue15329 ). Judul "memperjelas metode deque mana yang aman untuk thread"

Intinya di sini: https://bugs.python.org/issue15329#msg199368

Operasi append (), appendleft (), pop (), popleft (), dan len (d) aman di thready di CPython. Metode append memiliki DECREF pada akhirnya (untuk kasus di mana maxlen telah ditetapkan), tetapi ini terjadi setelah semua pembaruan struktur telah dibuat dan invarian telah dipulihkan, jadi tidak apa-apa untuk memperlakukan operasi ini sebagai atom.

Lagi pula, jika Anda tidak 100% yakin dan Anda lebih suka keandalan daripada kinerja, cukup cantumkan Kunci seperti;)

Semua metode elemen tunggal di dequeatomik dan aman. Semua metode lain juga aman untuk thread. Hal-hal seperti len(dq), dq[4]menghasilkan nilai yang benar sesaat. Tapi pikirkan misalnya tentang dq.extend(mylist): Anda tidak mendapatkan jaminan bahwa semua elemen masukmylist diajukan secara berurutan ketika utas lainnya juga menambahkan elemen di sisi yang sama - tetapi itu biasanya bukan persyaratan dalam komunikasi antar-utas dan untuk tugas yang dipertanyakan.

Jadi a deque~ 20x lebih cepat daripada Queue(yang menggunakan dequeunder the hood) dan kecuali Anda tidak memerlukan API sinkronisasi "nyaman" (pemblokiran / batas waktu), maxsizekepatuhan yang ketat atau "Abaikan metode ini (_put, _get, .. ) untuk mengimplementasikan organisasi lain " perilaku sub-klasifikasi antrian , atau ketika Anda mengurus hal-hal seperti itu sendiri, maka telanjangdeque adalah kesepakatan yang baik dan efisien untuk komunikasi antar-jalur berkecepatan tinggi.

Kenyataannya, penggunaan metode mutex ekstra dan metode ekstra ._get()dll. Yang banyak dilakukan Queue.pyadalah karena kendala kompatibilitas ke belakang, desain yang berlebihan di masa lalu, dan kurangnya perawatan untuk memberikan solusi yang efisien untuk masalah bottleneck kecepatan penting ini dalam komunikasi antar-benang. Daftar digunakan dalam versi Python yang lebih lama - tetapi bahkan list.append () /. Pop (0) adalah & adalah atomic dan threadsafe ...

Menambahkan notify_all()ke masing deque append- masing dan popleftmenghasilkan hasil yang jauh lebih buruk dequedaripada peningkatan 20x yang dicapai oleh dequeperilaku default :

deque + notify_all: 0.469802
Queue:              0.667279

@ Jonathan sedikit memodifikasi kodenya dan saya mendapatkan benchmark menggunakan cPython 3.6.2 dan menambahkan kondisi dalam deque loop untuk mensimulasikan perilaku yang dilakukan Queue.

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)

Dan sepertinya kinerja dibatasi oleh fungsi ini condition.notify_all()

collections.deque adalah implementasi alternatif dari antrian tidak terbatas dengan operasi append atom cepat () dan popleft () yang tidak memerlukan penguncian. dokumen Antrian

dequeaman dari benang. "operasi yang tidak memerlukan penguncian" berarti bahwa Anda tidak harus melakukan penguncian sendiri,deque mengurusnya.

Mengambil melihat pada Queuesumber, deque internal disebut self.queuedan menggunakan mutex untuk accesor dan mutasi, sehingga Queue().queueadalah tidak benang-aman untuk digunakan.

Jika Anda mencari operator "in", maka deque atau antrian mungkin bukan struktur data yang paling tepat untuk masalah Anda.

(sepertinya saya tidak memiliki reputasi untuk berkomentar ...) Anda harus berhati-hati metode deque mana yang Anda gunakan dari utas yang berbeda.

deque.get () tampaknya threadsafe, tetapi saya telah menemukan bahwa melakukan

for item in a_deque:
   process(item)

dapat gagal jika utas lainnya menambahkan item pada saat yang sama. Saya mendapat RuntimeException yang mengeluh "deque bermutasi selama iterasi".

Periksa collectionsmodule.c untuk melihat operasi mana yang dipengaruhi oleh ini