Construir un pool de objetos en Java

Cuando nos sumergimos en el mundo de las aplicaciones multiusuario en tiempo real, es conveniente implementar una estructura de datos que incremente drásticamente el rendimiento de nuestro programa. Por ejemplo, suponiendo que el tiempo medio que nuestra aplicación invierte en transacciones básicas (como construir objetos) sea de unos 250 milisegundos, utilizando un pool de objetos conseguiremos reducir ese tiempo hasta los 30 milisegundos.

La idea básica de un pool de objetos es muy similar a cómo se trabaja en una biblioteca: si quieres leer un libro, lo tomas prestado, lo lees y finalmente lo devuelves. Obviamente, es una operación mucho más económica que comprarlo y eso lo notan nuestros bolsillos. De la misma forma, para un proceso es más económico (con respecto a memoria y velocidad) tomar prestado un objeto, trabajar con él y finalmente devolverlo a su lugar de origen. En otras palabras, supongamos que nuestra aplicación necesita un objeto, y en vez de instanciarlo lo obtiene de una estructura que contiene ya esos objetos construidos: el pool de objetos. Hay que tener en cuenta que existen unas pequeñas diferencias entre nuestro pool y la biblioteca. Es decir, si necesitamos un libro en concreto, pero todas las copias están cogidas, tendremos que esperar a que alguien devuelva una copia para poder obtener la nuestra. Está claro que nuestra aplicación no puede estar esperando tranquilamente a que otras devuelvan el objeto que necesita, por lo que el pool creará copias nuevas cuando sea necesario. Para no saturar nuestro pool de objetos no utilizados habrá que buscar alguna forma de poder limpiarlo periódicamente.

El pool implementado en este artículo es lo suficientemente genérico como para gestionar el almacenamiento, el seguimiento y los tiempos de expiración de los objetos almacenados. Por el contrario, la construcción, validación y destrucción de los mismos se conseguirán empleando la Herencia (subclassing). Es decir, si queremos un pool de conexiones a una base de datos, partiremos del comportamiento base del pool de objetos, heredando atributos y métodos de la clase que lo define, y añadiendo el resto de la funcionalidad en la clase derivada resultante.

Ahora que tenemos claros los conceptos básicos, pasemos a la práctica. A continuación puedes apreciar la implementación del pool de objetos. Parte del código señalado por los puntos suspensivos (...) se verá más adelante.

import java.util.Hashtable; 
import java.util.Enumeration; 

public abstract class PoolObjetos{
 private long tiempoExpiracion;
 private Hashtable bloqueados, nobloqueados;

 PoolObjetos(){...}

 abstract Object crear();
 abstract boolean validar( Object o );
 abstract void expirar( Object o );
 synchronized Object checkOut() {...}
 synchronized void checkIn( Object o ){...}
}
        

El almacenamiento interno de los objetos se gestionará con dos tablas hash, una para los objetos bloqueados y otra para los no bloqueados. Los mismos objetos serán las claves de las entradas de la tabla hash y la última vez que se utilizó (en milisegundos), el valor asociado a cada clave. De esta manera, si un objeto supera el tiempo de expiración, podremos eliminarlo y liberar memoria. A título de curiosidad, el pool de objetos debería permitir a las clases que hereden de él establecer el tamaño inicial de las tablas hash, su factor de carga y el tiempo de expiración. Estos parámetros se han preestablecido en el constructor para no complicar más este ejemplo.

PoolObjetos(){ 
  tiempoExpiracion = 30000; // 30 segundos
  bloqueados = new Hashtable();
  nobloqueados = new Hashtable();
}
        

Lo primero que hace el método checkOut() es comprobar si hay objetos en la tabla de bloqueados. De ser así, itera en la búsqueda de uno de ellos que sea válido. Ese proceso de validación depende de dos cosas. Primera, el pool comprueba que el tiempo en que se utilizó ese objeto por última vez no supera el tiempo de expiración, la clase que marca esa última vez es la derivada de nuestra PoolObjetos. Segunda, el pool llama el método abstracto validate() , definido en la subclase, que comprueba alguna propiedad específica del propio objeto para poder reutilizarlo. Si esta validación falla, se libera el objeto y continua el bucle al siguiente objeto en la tabla.

Usuarios que han visto este tema también han visto...

- Servlet Hola Mundo con Java
- Recibir parametros en una JSP
- Deshabilitar todos los componentes incluidos en un Container Swing en Java
- Introducción al J2ME
- Conectar Java con MySQL en NetBeans

- Versión imprimible de este documento

- Enviar por e-mail este documento