definição
Um pool de objetos é uma coleção de objetos que foram inicializados e utilizáveis. O usuário do pool pode obter objetos do pool, operar neles e devolvê -los ao pool em vez de destruí -lo, se não.
Se a inicialização e a instanciação forem caras e precisará ser instanciada com frequência, mas o número de instanciações é pequeno por vez, uma melhoria significativa de desempenho pode ser alcançada usando pools de objetos. O tempo para obter um objeto do pool é previsível, mas o tempo que leva para criar uma nova instância é incerto.
concluir
1. Objetos reutilizáveis no pool de objetos, geralmente o custo da instanciação é relativamente alto.
2. Cliente - Use uma instância de um objeto.
3. ReusablePool - gerencia a instanciação, reciclagem e destruição de objetos.
As principais idéias em uma única instância
1. Uma pilha, aqui está a pilha
2. Método de inicialização, você pode pré-criar o pool quando o contêiner é aberto.
3. Métodos para criar uma instância
4. Forneça um método para obter instâncias de objetos da piscina
5. Forneça um método de retorno, mas as consequências são graves.
6. Método para controlar o tempo de espera da solicitação. Depois que um certo evento se passou, um ponteiro nulo é devolvido.
importar java.util.stack; @Suppresswarnings ("desmarcado") classe pública ObjectPool {public objectPool () {} private poolparam poolparam; public void setPoolParam (Poolparam Poolparam) {this.PoolParam = PoolParam; } // O número total atual de objetos privado int currentnum = 0; Clazz de classe particular; public void setClazz (classe clazz) {this.clazz = clazz; } // A pilha é usada para armazenar objetos e simular uma pilha privada de piscina; public Stack getStack () {return Stack; } public void setStack (pilha de pilha) {this.stack = pilha; } // .................................................................. // Aguardando o tempo limite expirando privado int timewait = 0; // .................................................................... // Crie um pool de objetos public void InitialPool (Poolparam Poolparam, Class clazz) {this.setPoolParam (Poolparam); this.setClazz (clazz); pilha = new Stack (); Stack.clear (); // System.out.println ("obj..pool é inicial ..."); // Gere o número mínimo de objetos para configurar e empurrá -lo para a pilha, tente {for (int i = 0; i <poolparam.getMinObjectCount (); i ++) {// inicialize o pool de objetos de acordo com Poolparam Stack.push (clazz.newinstance ()); }} catch (instantionException e) {e.printStackTrace (); } catch (ilegalAccessException e) {E.PrintStackTrace (); }} // Crie um único objeto privado CreateObj (classe clazz) {objeto obj = null; tente {obj = clazz.newinstance (); // System.out.println ("Um novo ..."); } catch (instantiationException e) {e.printStackTrace (); } catch (ilegalAccessException e) {E.PrintStackTrace (); } retornar obj; } // Obter método fornecido pelo pool de objetos Public Object getInstance () {// System.out.println (Stack.size ()); Objeto objeto = nulo; if (Stack.size () == 0) {// Se o comprimento da pilha atual for 0, e o número total de objetos não exceder o número máximo definido se ((currentnum + poolparam.getMinObjectCount ()) <PoolParam .getMaxObject ()) {// Crie um novo objeto = this.cret.CRATEBJ (PoolParam. // número de objetos +1 currentNum ++; } else {sincronizado (this) {try {waitme (this); } catch (Exceção e) {e.printStackTrace (); } // Depois de obter a notificação, verifique se a pilha está vazia e fornece o recurso que acaba de ser lançado se (! Stack.empty ()) {object = staack.pop (); }}}} else if (Stack.size ()> 0) {object = stack.pop (); // System.out.println (Stack.size ()); } retornar objeto; } // Método para retornar o objeto public void ReturnObj (object obj) {if (clazz.isInsinStance (obj)) {stack.push (obj); sincronizado (this) {notify (); }} else {System.out.println ("Este objeto não pode pressionar para empilhar!"); }} // aguarde o algoritmo recursivo privado void waitme (pool de objectpool) {// aguarde o controle técnico de 2s se (timewait> = 2000) {System.out.println ("salte esta etapa .."); Timewait = 0; retornar; } else {try {pool.wait (500); // Aguarde a contagem acumular. . Timewait += 1000; System.out.println ("Hora de espera para libertar obj .."); if (Stack.Empty ()) {System.out.println ("Aian ..."); espera (piscina); }} catch (interruptEdException e) {e.printStackTrace (); }}}}
Gerenciar aulas de pool, isso não é muito difícil, é bom sincronizá -lo
@Suppresswarnings ("desmarcado") classe pública ObjectPoolManage {Private ObjectPoolManage () {} private Static ObjecjotPool Pool; // implementa o método de obtenção de um singleton ... Padrão public estático sincronizado ObjectPool getCacheObject (classe clazz) {if (null! = Pool) {return pool; } else {createObjectPool (null, clazz); piscina de retorno; }} // Implemente o método de obtenção de um singleton ... Public Static Syncronized ObjectPool GetCacheObject personalizado (Poolparam p, classe clazz) {if (null! = Pool) {return pool; } else {createObjectpool (P, Clazz); piscina de retorno; }} Private estático ObjectPool CreateObjectPool (Poolparam P, Class clazz) {Pool = new Objectpool (); if (null == p) {pool.initalpool (novo Poolparam (5,10), clazz); } else {Pool.initalpool (P, Clazz); } retornar pool; } classe estática privada getClazz () {classe clazz = null; tente {clazz = classe.ForName (ppp.getPropertyByName ("objectPath")); } catch (classNotFoundException e) {e.printStackTrace (); } retornar clazz; }}
Perguntas e implementações relacionadas
1. O número de objetos pode ser limitado no pool de objetos. Quando o limite excede o limite, o pool de objetos precisa retornar uma exceção ou um valor nulo para notificar o cliente.
2. Em um ambiente multithread, os métodos de check-out e check-in precisam ser sincronizados.
3. Limpe os objetos expirados regularmente.