Cara menggunakan perpustakaan pengumpulan objek universal Python yang cekap

Mod kumpulan objek sesuai terutamanya untuk senario aplikasi berikut:

• Senario dengan sumber terhad. Sebagai contoh, dalam persekitaran yang tidak memerlukan kebolehskalaan (sumber fizikal seperti CPU dan ingatan adalah terhad), prestasi CPU tidak cukup kuat, ingatan agak ketat, pengumpulan sampah, dan kegelisahan memori akan mempunyai kesan yang agak besar, dan kecekapan pengurusan ingatan perlu dipertingkatkan Responsif adalah lebih baik daripada kuantiti adalah lebih penting.
  

• Bilangan objek yang terhad dalam ingatan.
  

• Objek yang mahal untuk dibuat.
  

• Sebilangan besar objek dengan jangka hayat pendek dan kos permulaan yang rendah dikumpulkan untuk mengurangkan peruntukan memori dan kos pengagihan semula serta mengelakkan pemecahan memori.
  

• Dalam bahasa dinamik seperti Python, GC bergantung pada teknologi rujukan untuk memastikan objek tidak dikitar semula lebih awal Dalam sesetengah senario, ia mungkin berlaku walaupun objek itu dicipta, tiada siapa akan Tempoh terbiar yang digunakan menyebabkan objek dikitar semula. Ia boleh diwakilkan kepada kumpulan objek untuk disimpan dengan selamat.
  

Pengenalan Kolam

Kolam ialah kumpulan objek umum yang cekap dalam Python, dengan ciri prestasi yang baik, penggunaan memori yang kecil dan kadar pukulan yang tinggi . Keupayaan untuk mengitar semula secara automatik berdasarkan kekerapan berdasarkan statistik anggaran secara automatik boleh melaraskan bilangan objek percuma dalam setiap kumpulan objek.

Oleh kerana pada masa ini Python tidak mempunyai perpustakaan pengumpulan objek yang lebih baik dengan kes ujian lengkap, ulasan kod lengkap dan dokumentasi lengkap Pada masa yang sama, perpustakaan pengumpulan objek arus perdana tidak mempunyai automatik pintar mekanisme kitar semula.

Pond mungkin perpustakaan pengumpulan objek pertama dalam Python dengan kes ujian lengkap yang didedahkan oleh komuniti, kadar liputan lebih daripada 90%, ulasan kod lengkap dan dokumentasi lengkap.

Pond diilhamkan oleh Apache Commons Pool, Netty Recycler, HikariCP, dan Kafein, menyepadukan kelebihan kebanyakannya.

Kedua, Pond mengira kekerapan penggunaan setiap kumpulan objek dalam ruang memori yang sangat kecil dengan menggunakan pengiraan anggaran dan mengitar semulanya secara automatik.

Apabila trafik secara relatif rawak dan purata, strategi lalai dan berat boleh mengurangkan penggunaan memori sebanyak 48.85%, dan kadar hit peminjaman ialah 100%.

Apabila trafik lebih selaras dengan undang-undang 2/8, strategi lalai dan berat boleh mengurangkan penggunaan memori sebanyak 45.7%, dan pinjaman melanda kadar adalah 100%.

Gambaran Keseluruhan Reka Bentuk

Pond terutamanya terdiri daripada FactoryDict, Counter, PooledObjectTree dan benang kitar semula yang berasingan.

FactoryDict

Menggunakan Pond memerlukan pelaksanaan kilang objek PooledObjectFactory menyediakan penciptaan objek, permulaan, pemusnahan, pengesahan dan operasi lain, dan dipanggil oleh Pond.

Jadi untuk kumpulan objek menyokong penyimpanan objek yang sama sekali berbeza, Pond menggunakan kamus untuk merekodkan nama setiap kelas kilang dan objek instan bagi kelas kilang yang dilaksanakannya.

Setiap PooledObjectFactory harus mempunyai empat fungsi untuk mencipta objek, memusnahkan objek, mengesahkan sama ada objek masih tersedia dan menetapkan semula objek.

Apa yang istimewa ialah Pond menyokong tetapan semula automatik objek, kerana dalam sesetengah senario mungkin terdapat situasi di mana objek perlu diberikan nilai terlebih dahulu dan diluluskan, dan kemudian dikitar semula selepas diluluskan untuk mengelakkan pencemaran, ini disyorkan Fungsi ini boleh direalisasikan dalam pelbagai senario.

Kaunter

Kaunter menyimpan anggaran anggaran.

PooledObjectTree

PooleedObjectTree ialah kamus Setiap kunci sepadan dengan baris gilir masuk dahulu, keluar dahulu.

Setiap baris gilir memegang berbilang PooleedObjects. PooledObject menjimatkan masa penciptaan, masa pinjaman terakhir dan objek sebenar yang diperlukan.

Selamat untuk benang

Peminjaman bon dan kitar semula Pond adalah selamat untuk benang. Modul baris gilir Python menyediakan struktur data masuk dahulu, keluar dahulu (FIFO) yang sesuai untuk pengaturcaraan berbilang benang. Ia boleh digunakan untuk menghantar mesej atau data lain dengan selamat antara rangkaian pengeluar dan pengguna.

Kunci dikendalikan oleh pemanggil dan semua berbilang rangkaian boleh berfungsi dengan selamat dan mudah menggunakan tika Baris yang sama. Peminjaman dan kitar semula Pond kedua-duanya beroperasi pada baris gilir, jadi ia pada asasnya boleh dianggap selamat untuk benang.

Mekanisme pinjaman

Apabila menggunakan Pond untuk meminjamkan objek, ia akan menyemak dahulu sama ada jenis objek yang ingin anda pinjamkan sudah wujud dalam PooledObjectTree Jika ia wujud, ia akan Menyemak sama ada kumpulan objek objek ini kosong, dan mencipta yang baharu jika ia kosong.

Jika terdapat lebihan objek dalam kumpulan objek, baris gilir akan digunakan untuk memaparkan objek dan mengesahkan sama ada objek ini tersedia. Jika ia tidak tersedia, Kilang yang sepadan akan dipanggil secara automatik untuk membersihkan dan memusnahkan objek Pada masa yang sama, kiraan GC dalam Python akan dikosongkan, supaya ia boleh dikitar semula oleh GC dengan lebih cepat, dan yang seterusnya akan diambil. berterusan sehingga satu tersedia.

Jika objek ini tersedia, ia akan dikembalikan terus. Sudah tentu, sama ada objek dikeluarkan daripada kumpulan objek atau objek baharu dicipta, Counter akan digunakan untuk menambah kiraan.

Mekanisme kitar semula

Apabila mengitar semula objek, ia akan menentukan sama ada kumpulan objek sasaran wujud Jika wujud, ia akan menyemak sama ada kolam objek penuh Jika ia penuh, objek itu untuk dikembalikan akan musnah secara automatik.

Kemudian ia akan menyemak sama ada objek telah dipinjamkan terlalu lama Jika ia melebihi masa maksimum yang dikonfigurasikan, ia juga akan dikosongkan.

Kitar semula automatik

Kitar semula automatik akan dilaksanakan sekali-sekala, lalainya ialah 300 saat. Bersihkan objek secara automatik dalam kumpulan objek yang tidak kerap digunakan.

Arahan penggunaan

Anda boleh memasang perpustakaan Pond terlebih dahulu dan merujuknya dalam projek anda.

pip install pondpond

from pond import Pond, PooledObjectFactory, PooledObject

Mula-mula anda perlu mengisytiharkan kelas kilang untuk jenis objek yang anda ingin letakkan. Contohnya, dalam contoh berikut kami mahu objek terkumpul menjadi Anjing, jadi kami mula-mula mengisytiharkan Kelas PooledDogFactory dan Laksanakan PooledObjectFactory.

class Dog:
 name: str
 validate_result:bool = True
class PooledDogFactory(PooledObjectFactory):
 def creatInstantce(self) -> PooledObject:
 dog = Dog()
 dog.name = "puppy"
 return PooledObject(dog)
 def destroy(self, pooled_object: PooledObject):
 del pooled_object
 def reset(self, pooled_object: PooledObject) -> PooledObject:
 pooled_object.keeped_object.name = "puppy"
 return pooled_object
 def validate(self, pooled_object: PooledObject) -> bool:
 return pooled_object.keeped_object.validate_result

Kemudian anda perlu mencipta objek Kolam:

pond = Pond(borrowed_timeout=2,
 time_between_eviction_runs=-1,
 thread_daemon=True,
 eviction_weight=0.8)

Kolam boleh memasukkan beberapa parameter, yang mewakili:

borrowed_timeout: unit adalah saat, pinjam objek Tempoh maksimum Objek yang melebihi tempoh akan dimusnahkan secara automatik apabila dikembalikan dan tidak akan dimasukkan ke dalam kumpulan objek.

time_between_eviction_runs: Unit ialah saat, selang antara kitar semula automatik.

thread_daemon: benang daemon, jika Benar, benang kitar semula secara automatik akan ditutup apabila benang utama ditutup.

eviction_weight: Berat semasa kitar semula automatik akan didarab dengan kekerapan penggunaan maksimum Objek dalam kumpulan objek yang kekerapan penggunaannya kurang daripada nilai ini akan memasuki langkah pembersihan.

Kelas kilang segera:

factory = PooledDogFactory(pooled_maxsize=10, least_one=False)

Semua yang mewarisi PooledObjectFactory akan mempunyai pembinanya sendiri yang boleh melepasi parameter pooled_maxsize dan least_one.

pooled_maxsize: Bilangan maksimum objek yang boleh diletakkan dalam kumpulan objek yang dijana oleh kelas kilang ini.

least_one: Jika Benar, apabila memasuki pembersihan automatik, kumpulan objek objek yang dijana oleh kelas kilang ini akan mengekalkan sekurang-kurangnya satu objek.

Daftar objek kilang ini dengan Pond Secara lalai, nama kelas kilang akan digunakan sebagai kunci PooledObjectTree:

pond.register(factory)

Sudah tentu, anda juga boleh menyesuaikan. namanya, namanya akan Sebagai kunci PooledObjectTree:

pond.register(factory, name="PuppyFactory")

Selepas pendaftaran berjaya, Pond akan mula mencipta objek secara automatik mengikut set pooled_maxsize di kilang sehingga kolam objek diisi.

Pinjam dan pulangkan objek:

pooled_object: PooledObject = pond.borrow(factory)
dog: Dog = pooled_object.use()
pond.recycle(pooled_object, factory)

Sudah tentu anda boleh meminjam dan memulangkan objek mengikut nama:

pooled_object: PooledObject = pond.borrow(name="PuppyFactory")
dog: Dog = pooled_object.use()
pond.recycle(pooled_object, name="PuppyFactory")

Kosongkan kolam objek sepenuhnya:

pond.clear(factory)

Bersihkan kolam objek mengikut nama:

pond.clear(name="PuppyFactory")

Dalam keadaan biasa, anda hanya perlu menggunakan kaedah di atas dan penjanaan objek serta kitar semula adalah automatik sepenuhnya.

Atas ialah kandungan terperinci Cara menggunakan perpustakaan pengumpulan objek universal Python yang cekap. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!