definisi
Kumpulan objek adalah kumpulan objek yang telah diinisialisasi dan dapat digunakan. Pengguna kumpulan dapat memperoleh objek dari kumpulan, beroperasi di atasnya, dan mengembalikannya ke kumpulan alih -alih menghancurkannya jika tidak.
Jika inisialisasi dan instantiasi mahal dan ada kebutuhan untuk sering dipakai, tetapi jumlah instantiasi kecil pada suatu waktu, peningkatan kinerja yang signifikan dapat dicapai dengan menggunakan kumpulan objek. Waktu untuk mendapatkan objek dari kumpulan dapat diprediksi, tetapi waktu yang diperlukan untuk membuat instance baru tidak pasti.
menyelesaikan
1. Dapat digunakan kembali - objek di kumpulan objek, biasanya biaya instantiasi relatif tinggi.
2. Klien - Gunakan instance suatu objek.
3. ReusablePool - Mengelola Instantiasi, Daur Ulang dan Penghancuran Benda.
Ide utama dalam satu contoh
1. Tumpukan, ini tumpukan
2. Metode Inisialisasi, Anda dapat membuat pra-membuat kolam saat wadah dibuka.
3. Metode untuk membuat instance
4. Menyediakan metode untuk mendapatkan instance objek dari kumpulan
5. Berikan metode pengembalian, tetapi konsekuensinya serius.
6. Metode untuk Mengontrol Permintaan Waktu Tunggu. Setelah acara tertentu telah berlalu, pointer nol dikembalikan.
impor java.util.stack; @SuppressWarnings ("Uncecked") Public Class ObjectPool {public ObjectPool () {} Private PoolParam PoolParam; public void setPoolParam (PoolParam PoolParam) {this.poolparam = poolparam; } // Jumlah total objek saat ini private int currentNum = 0; clazz kelas pribadi; public void setClazz (class clazz) {this.clazz = clazz; } // Tumpukan digunakan untuk menyimpan objek dan mensimulasikan tumpukan tumpukan pribadi biliar; public stack getStack () {return stack; } public void setStack (stack stack) {this.stack = stack; } // .................................................................. // Menunggu batas waktu untuk kedaluwarsa int private int timewait = 0; // ........................................................................ // Buat pool objek public void initialpool (poolparam poolparam, class clazz) {this.setpoolparam (poolparam); this.setClazz (clazz); stack = stack baru (); stack.clear (); // System.out.println ("Obj..pool adalah awal ..."); // Hasilkan jumlah minimum objek untuk mengonfigurasi dan mendorongnya ke tumpukan coba {untuk (int i = 0; i <poolparam.getMinObjectCount (); i ++) {// inisialisasi kumpulan objek sesuai dengan stack.push PoolParam (clazz.newinstance ()); }} catch (InstantiationException e) {E.PrintStackTrace (); } catch (ilegalAccessException e) {e.printstacktrace (); }} // Buat objek tunggal objek pribadi createobj (class clazz) {objek obj = null; coba {obj = clazz.newinstance (); // System.out.println ("yang baru ..."); } catch (InstantiationException e) {E.PrintStackTrace (); } catch (ilegalAccessException e) {e.printstacktrace (); } kembalikan obj; } // Dapatkan metode yang disediakan oleh objek objek objek publik getInstance () {// system.out.println (stack.size ()); Objek objek = null; if (stack.size () == 0) {// Jika panjang tumpukan saat ini adalah 0, dan jumlah total objek tidak melebihi angka maksimum yang ditentukan jika ((currentNum + poolparam.getMinObjectCount ()) <poolparam .getmaxObjectCount ()) {// Buat objek baru = this.crate. GetMaxObjectCount ()) {) {// Buat objek baru = this. // jumlah objek +1 currentNum ++; } else {disinkronkan (ini) {coba {waitme (this); } catch (Exception e) {E.PrintStackTrace (); } // Setelah mendapatkan pemberitahuan, periksa bahwa tumpukan kosong dan memberikan sumber daya yang baru saja dirilis if (! Stack.empty ()) {object = stack.pop (); }}}} else if (stack.size ()> 0) {object = stack.pop (); // System.out.println (stack.size ()); } return objek; } // metode untuk mengembalikan objek public void returnobj (objek obj) {if (clazz.isInstance (obj)) {stack.push (obj); disinkronkan (ini) {notify (); }} else {System.out.println ("Objek ini tidak dapat mendorong untuk menumpuk!"); }} // Tunggu algoritma rekursif private void waitme (objekpool pool) {// tunggu kontrol teknis 2s if (timeWait> = 2000) {System.out.println ("Jump Up Step ini .."); TIMEWAIT = 0; kembali; } else {coba {pool.wait (500); // tunggu hitungan penghitungan. . TimeWait += 1000; System.out.println ("Waktu menunggu untuk membebaskan obj .."); if (stack.empty ()) {System.out.println ("AGian ...."); waitme (biliar); }} catch (InterruptedException e) {E.PrintStackTrace (); }}}}
Kelola kelas biliar, ini tidak terlalu sulit, ada baiknya menyinkronkannya
@SuppressWarnings ("Uncecked") Public Class ObjectPoolManage {Private ObjectPoolManage () {} private static ObjectPool Pool; // Menerapkan metode memperoleh singleton ... default public static yang disinkronkan objectPool getCacheObject (class clazz) {if (null! = Pool) {return pool; } else {createObjectPool (null, clazz); kumpulan kembali; }} // Menerapkan metode perolehan singleton ... public static static static ObjectPool getCacheObject (PoolParam P, class clazz) {if (null! = Pool) {return pool; } else {createObjectPool (p, clazz); kumpulan kembali; }} private static ObjectPool createObjectPool (poolparam p, class clazz) {pool = new ObjectPool (); if (null == p) {pool.initalpool (Poolparam baru (5,10), clazz); } else {pool.initalpool (p, clazz); } return pool; } private static class getClazz () {class clazz = null; coba {clazz = class.forname (ppp.getpropertybyname ("objectPath")); } catch (ClassNotFoundException e) {E.PrintStackTrace (); } return clazz; }}
Pertanyaan dan implementasi terkait
1. Jumlah objek dapat dibatasi di kumpulan objek. Ketika batas melebihi batas, kumpulan objek perlu mengembalikan pengecualian atau nilai nol untuk memberi tahu pelanggan.
2. Dalam lingkungan multi-threaded, metode checkout dan checkin perlu disinkronkan.
3. Bersihkan objek kadaluwarsa secara teratur.