definición
Un grupo de objetos es una colección de objetos que se han inicializado y utilizable. El usuario del grupo puede obtener objetos de la piscina, operar en ellos y devolverlos a la piscina en lugar de destruirlo si no.
Si la inicialización y la instanciación son caras y es necesario instanciarse con frecuencia, pero el número de instanciaciones es pequeña a la vez, se puede lograr una mejora significativa del rendimiento utilizando grupos de objetos. El tiempo para obtener un objeto del grupo es predecible, pero el tiempo que lleva crear una nueva instancia es incierto.
lograr
1. Reutilizable: objetos en el grupo de objetos, generalmente el costo de la instanciación es relativamente alto.
2. Cliente: use una instancia de un objeto.
3. ReUSABLEPOOL - Gestiona la instanciación, el reciclaje y la destrucción de los objetos.
Las ideas principales en un solo caso
1. Una pila, aquí está la pila
2. Método de inicialización, puede preparar previamente la piscina cuando se abre el contenedor.
3. Métodos para crear una instancia
4. Proporcione un método para obtener instancias de objetos desde la piscina
5. Proporcione un método de retorno, pero las consecuencias son graves.
6. Método para controlar el tiempo de espera de la solicitud. Después de que ha pasado un cierto evento, se devuelve un puntero nulo.
import java.util.stack; @SupessWarnings ("sin verificar") clase pública Objectpool {public objectpool () {} private PoolParam PoolParam; public void setPoolparam (PoolParam PoolParam) {this.poolparam = PoolParam; } // El número total actual de objetos private int curtnum = 0; clase privada Clazz; public void setClazz (class clazz) {this.clazz = clazz; } // La pila se usa para almacenar objetos y simular una pila de pila privada; Public Stack getStack () {Return Stack; } public void setstack (pila pila) {this.stack = stack; } // .................................................................. // Esperando el tiempo de espera para expirar el tiempo privado de TimeWait = 0; // ........................................................................ // Crear un grupo de objetos public void Initialpool (PoolParam PoolParam, Class Clazz) {this.setPoolParam (PoolParam); this.setClazz (Clazz); stack = new Stack (); stack.clear (); // system.out.println ("obj..pool es inicial ..."); // Genere el número mínimo de objetos para configurarlo y empujarlo en la pila Try {for (int i = 0; i <pechleParam.getminObjectCount (); i ++) {// Inicializar el grupo de objetos de acuerdo con PoolParam stack.push (Clazz.newinStance ()); }} Catch (InstanciationException e) {E.PrintStackTrace (); } catch (ilegalAccessException e) {E.PrintStackTrace (); }} // Crear un objeto único objeto privado createObj (class clazz) {object obj = null; intente {obj = clazz.newinstance (); // System.out.println ("Un nuevo ..."); } catch (InstanciationException e) {E.PrintStackTrace (); } catch (ilegalAccessException e) {E.PrintStackTrace (); } return obj; } // Obtener método proporcionado por el objeto Object Public Object getInstance () {// System.out.println (stack.size ()); Objeto objeto = nulo; if (stack.size () == 0) {// Si la longitud de la pila actual es 0, y el número total de objetos no excede el número máximo definido if ((currentNum + PoolParam.getMinObjectCount ()) <PoolParam .getMaxObjectCount ()) {// Cree un nuevo objeto = this.CreateObj (CLAZZ); // Número de objetos +1 CurrentNum ++; } else {sincronizado (this) {try {waitMe (this); } catch (Exception e) {E.PrintStackTrace (); } // Después de obtener la notificación, verifique que la pila esté vacía y proporcione el recurso que acaba de liberar if (! Stack.empty ()) {object = stack.pop (); }}}} else if (stack.size ()> 0) {object = stack.pop (); // System.out.println (stack.size ()); } objeto de retorno; } // método para devolver objeto public void returnObj (object obj) {if (clazz.isinstance (obj)) {stack.push (obj); sincronizado (this) {notify (); }} else {System.out.println ("¡Este objeto no puede presionar para apilar!"); }} // Espere el algoritmo recursivo privado void waitme (objectpool piscol) {// espere el control técnico de 2s if (timeWait> = 2000) {System.out.println ("Jump Up este paso .."); TimeWait = 0; devolver; } else {try {Pool.Wait (500); // Espere a que se acumule el recuento. . TimeWait += 1000; System.out.println ("Tiempo de espera para liberar obj .."); if (stack.empty ()) {system.out.println ("agian ..."); WaitMe (piscina); }} catch (InterruptedException e) {E.PrintStackTrace (); }}}}
Administre las clases de billar, esto no es muy difícil, es bueno sincronizarlo
@SupplesSwarnings ("sin verificar") clase pública ObjectPoolManage {private ObjectPoolManage () {} private static objectpool Pool; // Implementar el método de obtención de un singleton ... Public static static sincronizado ObjectPool GetCacheObject (class Clazz) {if (null! = Pool) {return Pool; } else {createObjectpool (null, clazz); piscina de regreso; }} // Implementar un método de obtención de un singleton ... Public static static sincronizado getCacheObject (PoolParam P, Class Clazz) {if (null! = Pool) {return Pool; } else {createObjectpool (p, clazz); piscina de regreso; }} private static objectpool createObjectPool (PoolParam P, class Clazz) {Pool = new ObjectPool (); if (null == p) {piscina.initalpool (nuevo PoolParam (5,10), Clazz); } else {Pool.initalpool (P, Clazz); } piscina de retorno; } clase estática privada getClazz () {class clazz = null; intente {clazz = class.forname (ppp.getpropertybyname ("objectPath")); } catch (ClassNotFoundException e) {E.PrintStackTrace (); } return Clazz; }}
Preguntas e implementaciones relacionadas
1. El número de objetos puede limitarse en el grupo de objetos. Cuando el límite excede el límite, el grupo de objetos debe devolver una excepción o un valor nulo para notificar al cliente.
2. En un entorno múltiple, los métodos de pago y verificación deben sincronizarse.
3. Limpie los objetos caducados regularmente.