Corak reka bentuk kolam objek

Corak reka bentuk perisian yang sering digunakan dalam pengaturcaraan Java ialah corak reka bentuk kolam objek. Mod ini mengawal cara objek dalam kumpulan objek dicipta dan dimusnahkan.

Gunakan corak reka bentuk kolam objek untuk menguruskan pengeluaran dan pemusnahan objek. Konsep corak ini adalah untuk mengumpul objek yang boleh digunakan semula dan bukannya mencipta yang baharu setiap kali ia diperlukan. Untuk situasi di mana kos menghasilkan objek baharu adalah penting, seperti sambungan rangkaian, sambungan pangkalan data atau objek mahal, pengaturcara Java sering menggunakan corak reka bentuk kumpulan objek.

Sintaks reka bentuk kolam objek

Di Jawa, sintaks corak reka bentuk kolam objek adalah seperti berikut −

• Buat koleksi objek bersaiz tetap.

• Mulakan item pool.

• Jejaki item yang sedang berada dalam kolam.

• Apabila diperlukan, periksa sama ada terdapat objek yang boleh diakses di dalam kolam.

• Sila pastikan anda mengambil sendiri mana-mana objek yang tersedia dalam kolam dengan segera dan mengembalikannya dengan sewajarnya seperti yang diperlukan

• Namun, jika tiada item yang tersedia di depositori ini pada masa ini - kami meminta item baharu diwujudkan segera untuk mengelakkan pembaziran masa atau sumber dan kemudian dimasukkan semula ke dalam edaran.

Algoritma yang berbeza untuk reka bentuk kolam objek

Corak reka bentuk kolam objek Java boleh digunakan untuk pelbagai algoritma. Berikut ialah tiga strategi yang mungkin, setiap satu dengan pelaksanaan kod unik:

Pengamatan dan penyegerakan yang malas

import java.util.ArrayList;
import java.util.List;

public class ObjectPool {
   private static ObjectPool instance;
   private List<Object> pool = new ArrayList<>();
   private int poolSize;

   private ObjectPool() {}
   
   public static synchronized ObjectPool getInstance(int poolSize) {
      if (instance == null) {
         instance = new ObjectPool();
         instance.poolSize = poolSize;
         for (int i = 0; i < poolSize; i++) {
            instance.pool.add(createObject());
         }
      }
      return instance;
   }

   private static Object createObject() {
      // Create and return a new object instance
      return new Object();
   }

   public synchronized Object getObject() {
      if (pool.isEmpty()) {
         return createObject();
      } else {
         return pool.remove(pool.size() - 1);
      }
   }

   public synchronized void releaseObject(Object object) {
      if (pool.size() < poolSize) {
         pool.add(object);
      }
   }
}

Teknik yang digunakan di sini menekankan keselamatan benang melalui permulaan kumpulan objek yang malas dan disegerakkan dengan pengehadan kapasiti pratetap yang boleh dipinda kepada pengembangan Kumpulan kosong menghasilkan pengeluaran contoh baharu yang selamat, manakala contoh bukan penuh diperkenalkan semula dengan teliti untuk mengekalkan integriti operasi yang betul. .

Permulaan bersemangat menggunakan struktur data serentak

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class ObjectPool {
   private static final int POOL_SIZE = 10;
   private static ObjectPool instance = new ObjectPool();
   private BlockingQueue<Object> pool = new LinkedBlockingQueue<>(POOL_SIZE);

   private ObjectPool() {
      for (int i = 0; i < POOL_SIZE; i++) {
         pool.offer(createObject());
      }
   }

   private static Object createObject() {
      // Create and return a new object instance
      return new Object();
   }

   public static ObjectPool getInstance() {
      return instance;
   }

   public Object getObject() throws InterruptedException {
      return pool.take();
   }

   public void releaseObject(Object object) {
      pool.offer(object);
   }
}

Dalam pelaksanaan ini, pembolehubah contoh akhir statik digunakan untuk memulakan kumpulan objek dengan bersemangat. Struktur data asas ialah LinkedBlockingQueue, yang menyediakan keselamatan rangkaian tanpa memerlukan penyegerakan. Semasa pemulaan, objek ditambahkan pada kolam dan take() digunakan untuk mendapatkannya daripada baris gilir apabila diperlukan. Apabila item dikeluarkan, gunakan offer() untuk membuat giliran.

Tamat tempoh berasaskan masa

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

public class ObjectPool {
   private static final int POOL_SIZE = 10;
   private static ObjectPool instance = new ObjectPool();
   private BlockingQueue<Object> pool = new LinkedBlockingQueue<>(POOL_SIZE);

   private ObjectPool() {}

   private static Object createObject() {
      // Create and return a new object instance
      return new Object();
   }

   public static ObjectPool getInstance() {
      return instance;
   }

   public Object getObject() throws InterruptedException {
      Object object = pool.poll(100, TimeUnit.MILLISECONDS);
      if (object == null) {
         object = createObject();
      }
      return object;
   }

   public void releaseObject(Object object) {
      pool.offer(object);
   }

}

Kolam objek dalam versi ini menggunakan mekanisme tamat tempoh berasaskan masa dan bukannya saiz tetap. Apabila objek diperlukan, fungsi poll() digunakan untuk mengalih keluar objek daripada kolam Apabila tiada objek yang tersedia, fungsi akan menunggu untuk tempoh masa dan kemudian mengembalikan null. Objek dijana atas permintaan. Jika tiada objek wujud, objek baharu akan dijana dan dikembalikan. Apabila objek dilepaskan, gunakan offer() untuk meletakkannya semula ke dalam kolam. Fungsi expireObjects() digunakan untuk mengalih keluar item tamat tempoh daripada kumpulan berdasarkan nilai tamat masa yang disediakan.

Cara berbeza untuk menggunakan corak reka bentuk Object Pool

Corak reka bentuk kolam objek Java boleh dilaksanakan dalam pelbagai cara. Di bawah ialah dua kaedah biasa, termasuk contoh kod dan hasil −

Kaedah 1: Corak reka bentuk kolam objek ringkas

Salah satu cara untuk membina kumpulan objek yang ringkas dan praktikal adalah dengan menggunakan pendekatan berasaskan tatasusunan. Pendekatan ini berfungsi seperti berikut: setelah dijana sepenuhnya, semua objek disertakan dalam tatasusunan "kolam" yang sepadan untuk kegunaan masa hadapan pada masa jalan, koleksi diperiksa untuk menentukan sama ada mana-mana item yang diperlukan tersedia; Jika ia boleh diperolehi daripada inventori sedia ada, ia akan dikembalikan serta-merta, jika tidak, satu lagi objek baharu akan dihasilkan berdasarkan permintaan.

Contoh

public class ObjectPool {
   private static final int POOL_SIZE = 2;
   private static List<Object> pool = new ArrayList<Object>(POOL_SIZE);
    
   static {
      for(int i = 0; i < POOL_SIZE; i++) {
         pool.add(new Object());
      }
   }
    
   public static synchronized Object getObject() {
      if(pool.size() > 0) {
         return pool.remove(0);
      } else {
         return new Object();
      }
   }
    
   public static synchronized void releaseObject(Object obj) {
      pool.add(obj);
   }
}

Contoh

public class ObjectPoolExample {
   public static void main(String[] args) {
      Object obj1 = ObjectPool.getObject();
      Object obj2 = ObjectPool.getObject();
        
      System.out.println("Object 1: " + obj1.toString());
      System.out.println("Object 2: " + obj2.toString());
        
      ObjectPool.releaseObject(obj1);
      ObjectPool.releaseObject(obj2);
        
      Object obj3 = ObjectPool.getObject();
      Object obj4 = ObjectPool.getObject();
        
      System.out.println("Object 3: " + obj3.toString());
      System.out.println("Object 4: " + obj4.toString());
   }
}

Output

Object 1: java.lang.Object@4fca772d
Object 2: java.lang.Object@1218025c
Object 3: java.lang.Object@4fca772d
Object 4: java.lang.Object@1218025c

Kaedah 2: Corak Reka Bentuk Kolam Objek Universal

Menggunakan senarai sebagai asas, teknik ini memudahkan membina kumpulan objek standard, menyimpan objek dalam koleksi sehingga ia dijana sepenuhnya dan dimasukkan ke dalam koleksi. Setiap kali akses kepada item diperlukan, sistem menyemak imbas pilihan yang tersedia dalam kumpulan. Jika ada satu pilihan yang tersedia, itu sudah mencukupi tetapi jika tiada, anda mesti membuat satu lagi projek baharu.

Contoh

import java.util.ArrayList;
import java.util.List;

public class ObjectPool<T> {
   private List<T> pool;
    
   public ObjectPool(List<T> pool) {
      this.pool = pool;
   }
    
   public synchronized T getObject() {
      if (pool.size() > 0) {
         return pool.remove(0);
      } else {
         return createObject();
      }
   }
    
   public synchronized void releaseObject(T obj) {
      pool.add(obj);
   }
    
   private T createObject() {
      T obj = null;
      // create object code here
      return obj;
   }
    
   public static void main(String[] args) {
      List<String> pool = new ArrayList<String>();
      pool.add("Object 1");
      pool.add("Object 2");
        
      ObjectPool<String> objectPool = new ObjectPool<String>(pool);
        
      String obj1 = objectPool.getObject();
      String obj2 = objectPool.getObject();
        
      System.out.println("Object 1: " + obj1);
      System.out.println("Object 2: " + obj2);
        
      objectPool.releaseObject(obj1);
      objectPool.releaseObject(obj2);
        
      String obj3 = objectPool.getObject();
      String obj4 = objectPool.getObject();
        
      System.out.println("Object 3: " + obj3);
      System.out.println("Object 4: " + obj4);
   }
}

Output

Object 1: Object 1
Object 2: Object 2
Object 3: Object 1
Object 4: Object 2

Amalan terbaik untuk menggunakan kunci peringkat kelas

Pengaturcara Java sering menggunakan corak reka bentuk kolam objek apabila kos menghasilkan objek baharu tinggi. Senario penggunaan biasa termasuk −

Sambungan internet

Dalam program Java, sambungan rangkaian boleh diuruskan menggunakan Corak Reka Bentuk Kolam Objek Adalah lebih baik untuk menggunakan semula sambungan sedia ada daripada kolam daripada perlu membuat sambungan baharu setiap kali ini mungkin meningkatkan fungsi aplikasi sambil mencerahkan beban pada pelayan rangkaian.

Sambungan pangkalan data

Sama seperti pengurusan sambungan rangkaian, aplikasi Java juga boleh menggunakan corak reka bentuk kolam objek untuk mengendalikan sambungan pangkalan data. Adalah lebih baik untuk menggunakan semula sambungan sedia ada daripada kumpulan daripada membuat sambungan baharu setiap kali sambungan pangkalan data diperlukan. Ini boleh meningkatkan prestasi aplikasi dan mengurangkan beban pada pelayan pangkalan data.

Kolam benang

Pembangun yang menggunakan program Java harus menggunakan corak reka bentuk kumpulan objek untuk mengurus kumpulan benang dengan berkesan. Daripada mencipta semula setiap urutan yang diperlukan mengikut keperluan, penggunaan yang dirancang dengan baik bergantung pada penggunaan semula urutan sedia ada yang tersedia dalam kumpulan kerja yang ditetapkan. Oleh itu, ia menggalakkan prestasi aplikasi optimum dengan mengekalkan overhed proses penciptaan dan penamatan benang rendah, didorong oleh kecekapan struktur.

Pemprosesan imej

Apabila berurusan dengan tugas pemprosesan imej intensif dalam program Java, adalah wajar mempertimbangkan untuk melaksanakan corak reka bentuk kumpulan objek. Dengan memanfaatkan objek sedia ada daripada kumpulan khusus, anda boleh mempercepatkan prestasi aplikasi anda sambil mengurangkan permintaan pengkomputeran keseluruhan tugasan pengeditan foto anda.

Operasi sistem fail

Jika anda menghadapi tugas pemprosesan imej yang berat dalam aplikasi Java anda, adalah wajar mempertimbangkan untuk menggunakan corak reka bentuk kolam objek. Teknik ini menggunakan item sedia ada dalam kumpulan khusus untuk meningkatkan kelajuan output program dan mengurangkan sumber pengkomputeran yang diperlukan untuk mengedit foto.

Kesimpulan

Corak reka bentuk kolam objek ialah corak reka bentuk yang berguna dalam pengaturcaraan Java, sesuai untuk situasi di mana kos mencipta objek baharu adalah tinggi. Ia menyediakan cara untuk mengawal bekalan objek boleh guna semula, mengurangkan kos keseluruhan untuk mencipta produk baharu. Kolam Objek Mudah atau Kolam Objek Generik ialah dua contoh pelaksanaan corak reka bentuk Kolam Objek. Corak reka bentuk kolam objek sering digunakan dalam pengaturcaraan Java untuk mengendalikan objek mahal, seperti sambungan pangkalan data dan sambungan rangkaian. Ia serupa dengan tujuan corak Flyweight dan corak Singleton, tetapi mempunyai kegunaan yang berbeza.

Atas ialah kandungan terperinci Corak reka bentuk kolam objek. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!