définition
Un pool d'objets est une collection d'objets qui ont été initialisés et utilisables. L'utilisateur de la piscine peut obtenir des objets de la piscine, les opérer sur eux et les rendre à la piscine au lieu de le détruire sinon.
Si l'initialisation et l'instanciation sont coûteuses et qu'il est nécessaire d'être instanciée fréquemment, mais le nombre d'instanciations est faible à la fois, des améliorations de performances significatives peuvent être réalisées à l'aide de pools d'objets. Le temps d'obtenir un objet du pool est prévisible, mais le temps nécessaire pour créer une nouvelle instance est incertain.
accomplir
1. Réutilisables - objets dans le pool d'objets, généralement le coût de l'instanciation est relativement élevé.
2. Client - Utilisez une instance d'un objet.
3. ReusablePool - gère l'instanciation, le recyclage et la destruction des objets.
Les principales idées en un seul cas
1. Une pile, voici la pile
2. Méthode d'initialisation, vous pouvez pré-créer le pool lorsque le conteneur est ouvert.
3. Méthodes pour créer des instances
4. Fournir une méthode pour obtenir des instances d'objet à partir du pool
5. Fournir une méthode de retour, mais les conséquences sont très graves.
6. Méthode pour contrôler le temps d'attente de la demande. Une fois un certain événement passé, un pointeur nul est renvoyé.
import java.util.stack; @SuppressWarnings ("Unchecked") Public classe ObjectPool {public ObjectPool () {} privé PoolParam PoolParam; public void SetPoolParam (PoolParam PoolParam) {this.poolParam = PoolParam; } // Le nombre total actuel d'objets private int currentNum = 0; Classe privée Clazz; public void SetClazz (classe Clazz) {this.clazz = Clazz; } // La pile est utilisée pour stocker des objets et simuler une pile de pile privée de pool; Public Stack getStack () {return stack; } public void setStack (pile stack) {this.stack = pile; } // .................................................................. // En attente de délai d'expiration pour expirer private int timeWait = 0; // ........................................................................ // Créer un objet Pool public void InitialPool (PoolParam PoolParam, class Clazz) {this.setpoolParam (PoolParam); this.setClazz (Clazz); Stack = new Stack (); stack.clear (); // System.out.println ("obj..pool est initial ..."); // Générez le nombre minimum d'objets à configurer et à le pousser dans la pile essayez {pour (int i = 0; i <PoolParam.getMinObjectCount (); i ++) {// initialiser le pool d'objets selon PoolParam stack.push (Clazz.NewInstance ()); }} catch (InstantiationException e) {e.printStackTrace (); } catch (illégalaccessException e) {e.printStackTrace (); }} // Créer un seul objet objet privé createObj (class Clazz) {objet obj = null; essayez {obj = Clazz.NewInstance (); // System.out.println ("un nouveau ..."); } catch (InstantiationException e) {e.printStackTrace (); } catch (illégalaccessException e) {e.printStackTrace (); } return obj; } // GORT Méthode fournie par l'objet public de pool d'objets GetInstance () {// System.out.println (stack.size ()); Objet objet = null; if (stack.size () == 0) {// Si la longueur de la pile actuelle est 0, et le nombre total d'objets ne dépasse pas le nombre défini maximum if ((currentNum + PoolSParam.getMinObjectCount ()) <PoolParam .getMaxObjectCount ()) {// Créer un nouvel objet Object = this.createObj (clilak); // Nombre d'objets +1 currentNum ++; } else {synchronisé (this) {try {waitMe (this); } catch (exception e) {e.printStackTrace (); } // Après avoir obtenu la notification, vérifiez que la pile est vide et donne à la ressource qui vient de publier if (! Stack.empty ()) {object = stack.pop (); }}}} else if (stack.size ()> 0) {object = stack.pop (); // system.out.println (stack.size ()); } return objet; } // Méthode pour retourner objet public void returnObj (objet obj) {if (Clazz.isinstance (obj)) {stack.push (obj); synchronisé (this) {notify (); }} else {System.out.println ("Cet objet ne peut pas pousser pour empiler!"); }} // attendez un algorithme récursif private void waitMe (objetpool pool) {// attendez le contrôle technique de 2s if (TimeWait> = 2000) {System.out.println ("sauter cette étape .."); TimeWait = 0; retour; } else {try {pool.Wait (500); // attendez que le nombre s'accumule. . TimeWait + = 1000; System.out.println ("temps d'attente pour libérer obj .."); if (stack.empty ()) {System.out.println ("Agian ...."); WaitMe (piscine); }} catch (InterruptedException e) {e.printStackTrace (); }}}}
Gérer les cours de piscine, ce n'est pas très difficile, c'est bien de le synchroniser
@SuppressWarnings ("Unchecked") public class ObjectPoolManage {private ObjectPoolManage () {} Pool privé ObjectPool statique; // Implémentez la méthode d'obtention d'une singleton ... par défaut public statique synchronisé objectpool getCacheObject (class Clazz) {if (null! = Pool) {return pool; } else {createObjectPool (null, Clazz); Pool de retour; }} // Implémentez la méthode d'obtention d'une singleton ... Public personnalisé statique synchronisé objetPool getCacheObject (PoolParam p, class Clazz) {if (null! = Pool) {return pool; } else {CreateObjectPool (p, Clazz); Pool de retour; }} Private Static ObjectPool CreateObjectPool (PoolParam P, class Clazz) {pool = new ObjectPool (); if (null == p) {Pool.InitalPool (New PoolParam (5,10), Clazz); } else {Pool.InitalPool (P, Clazz); } return pool; } classe statique privée getClazz () {class Clazz = null; essayez {cllazz = class.forname (ppp.getProperTyByName ("ObjectPath")); } catch (classNotFoundException e) {e.printStackTrace (); } return Clazz; }}
Questions et implémentations connexes
1. Le nombre d'objets peut être limité dans le pool d'objets. Lorsque la limite dépasse la limite, le pool d'objets doit renvoyer une exception ou une valeur nul pour informer le client.
2. Dans un environnement multi-thread, les méthodes de paiement et de vérification doivent être synchronisées.
3. Nettoyez régulièrement les objets expirés.