Sumber terbuka terkini: perpustakaan pengumpulan objek universal Python yang cekap

Dalam pengaturcaraan, mencipta modul objek terutamanya dicapai dengan menjana objek. Apabila objek digunakan, ia akan menjadi modul yang tidak diperlukan lagi dan dimusnahkan.

Apabila sistem menjana dan memusnahkan objek, penggunaan memori akan meningkat dengan banyak Pada masa yang sama, pemusnahan objek selalunya akan meninggalkan maklumat sisa, yang akan disertai dengan masalah kebocoran memori.

Dalam proses pembangunan program sebenar, selalunya perlu menjana dan memusnahkan sejumlah besar objek pendua, yang menjadikan maklumat yang dijana oleh kebocoran memori terlalu banyak dan tidak boleh dikitar semula oleh sistem, oleh itu menempati lebih banyak memori sistem , dan apabila terdapat terlalu banyak objek yang dihasilkan, adalah mustahil untuk menentukan modul mana yang digunakan dan dilaksanakan, yang memberi beban kepada sistem dan tidak kondusif untuk pengurusan dan operasi seterusnya seperti ini, ia akhirnya akan menyebabkan program menjadi perlahan atau malah ranap.

Kolam objek ialah kolam yang menyimpan sekumpulan objek yang dicipta Ia adalah struktur yang digunakan untuk mengekalkan objek. Apabila atur cara perlu menggunakan objek, ia boleh mendapatkan objek terus daripada kolam dan bukannya membuat instantiation objek baharu.

Dalam proses pengaturcaraan, kebanyakan orang cenderung hanya menumpukan pada penggunaan objek dan realisasi kesan Sebenarnya, terdapat proses permulaan antara penciptaan dan penggunaan, tetapi sistem akan The dua langkah penciptaan digabungkan bersama, yang membolehkan pereka bentuk mengabaikan kesan penciptaan sistem dan pemusnahan objek pada sistem.

Secara umumnya, kos untuk mencipta dan memusnahkan objek adalah sangat kecil dan boleh diabaikan Namun, jika program melibatkan berbilang ciptaan objek dan masa penciptaan agak panjang, maka Anda akan melakukannya jelas merasakan bahawa kelajuan sistem dihadkan oleh bahagian penggunaan ini.

Kolam objek boleh dilihat sebagai kaedah pilihan untuk mengurangkan tekanan GC, dan ia juga merupakan kaedah paling mudah.

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 terhad objek dalam ingatan.
  
• Objek yang mahal untuk dibuat.
  
• Kumpulkan sejumlah besar objek dengan jangka hayat yang singkat dan kos permulaan yang rendah 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 akan dikitar semula lebih awal Dalam sesetengah senario, mungkin terdapat tempoh terbiar apabila tiada sesiapa menggunakan objek itu walaupun objek tersebut dicipta, mengakibatkan Objek dikitar semula. Ia boleh diwakilkan kepada kumpulan objek untuk disimpan dengan selamat.
  

Pengenalan Kolam

Kolam ialah kumpulan objek am 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 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 ia wujud, ia akan menyemak sama ada kolam objek penuh Jika ia penuh, ia akan dimusnahkan 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 mengisytiharkannya terlebih dahulu kelas PooledDogFactory dan melaksanakan 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 Pond:

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

Pond boleh memasukkan beberapa parameter, yang mewakili:

borrowed_timeout: unit ialah saat , tempoh maksimum untuk meminjamkan 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.

Segera kelas kilang:

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

Semua yang mewarisi PooledObjectFactory akan mempunyai pembina 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 boleh. juga menyesuaikan namanya. Nama akan digunakan 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 kumpulan objek terisi.

Meminjam dan memulangkan 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")

Bersihkan kolam objek sepenuhnya:

pond.clear(factory)

Bersihkan kolam objek mengikut nama:

pond.clear(name="PuppyFactory")

Biasanya, anda hanya perlu menggunakan kaedah di atas, kedua-duanya untuk menjana objek dan mengitar semula objek Automatik sepenuhnya.

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