Instanciar con una clase Pool <T> a través de la interfaz PoolObjectFactory

A continuación se muestra un ejemplo de uso de Java Pool (conjunto de genéricos) para instanciar TouchEvents para Android:

import java.util.ArrayList; import java.util.List; public class Pool<T> { public interface PoolObjectFactory<T> { public T createObject(); } private final List<T> freeObjects; private final PoolObjectFactory<T> factory; private final int maxSize; public Pool(PoolObjectFactory<T> factory, int maxSize) { this.factory = factory; this.maxSize = maxSize; this.freeObjects = new ArrayList<T>(maxSize); } public T newObject() { T object = null; if (freeObjects.isEmpty()) { object = factory.createObject(); } else { object = freeObjects.remove(freeObjects.size() - 1); } return object; } public void free(T object) { if (freeObjects.size() < maxSize) { freeObjects.add(object); } } }

Sin embargo, realmente no entiendo cómo funciona este código:

 if (freeObjects.isEmpty()) { object = factory.createObject(); } else { object = freeObjects.remove(freeObjects.size() - 1); }

Digamos que tenemos:

 touchEventPool = new Pool<TouchEvent>(factory, 100);

¿Significa esto que va a almacenar un Array de 100 eventos (y cuando # 101 viene dentro, dispondrá # 1, como first-in-first-out)?

Supongo que se supone que mantener un número máximo de objetos y luego disponer de la extra. Leí la descripción del libro como 10 veces .. y no podía conseguirlo. Tal vez alguien explicar cómo funciona esto?

Supongo que se supone que mantener un número máximo de objetos y luego disponer de la extra. Leí la descripción del libro como 10 veces .. y no podía conseguirlo. Tal vez alguien explicar cómo funciona esto?

Tipo de. La clase mantiene un caché de objetos pre-creados en una List denominada pool . Cuando solicita un objeto nuevo (a través del método newObject ), primero comprobará el pool para ver si un objeto está disponible para su uso. Si la piscina está vacía, sólo crea un objeto y se lo devuelve. Si hay un objeto disponible, elimina el último elemento del pool y lo devuelve.

Anotado:

 if (freeObjects.isEmpty()) { // The pool is empty, create a new object. object = factory.createObject(); } else { // The pool is non-empty, retrieve an object from the pool and return it. object = freeObjects.remove(freeObjects.size() - 1); }

Y cuando devuelve un objeto a la memoria caché (a través del método free() ), sólo se colocará de nuevo en la agrupación si no se ha cumplido el tamaño máximo de la agrupación.

Anotado:

 public void free(T object) { // If the pool is not already at its maximum size. if (freeObjects.size() < maxSize) { // Then put the object into the pool. freeObjects.add(object); } // Otherwise, just ignore this call and let the object go out of scope. }

Si ya se ha alcanzado el tamaño máximo del grupo, el objeto que está liberando no se almacena y está (presumiblemente) sujeto a recolección de basura.

La idea de cualquier grupo está en crear un entorno controlado en el que (normalmente) no es necesario crear nuevas instancias (de evento) cuando algunas instancias libres no utilizadas pueden reutilizarse del grupo.

Cuando crea touchEventPool = new Pool<TouchEvent>(factory, 100); esperas que 100 instancias sean suficientes en cualquier momento particular del programa en vivo.

Por lo tanto, cuando quiera obtener 101'st evento el proceso probablemente liberará primero 5, 20 o incluso 99 eventos y la piscina será capaz de reutilizar cualquiera de ellos.

Si no habrá instancias libres entonces, dependiendo de la política de la piscina, se creará la nueva o el hilo solicitante esperará otros hilos para liberar uno y volver a la agrupación. En esta implementación particular se creará la nueva.

Creo que el concepto principal de pool de objetos es reducir la frecuencia de instanciaciones de objetos.

¿Significa esto que va a almacenar un Array de 100 eventos (y cuando el # 101 viene dentro, dispondrá el # 1, como first-in-first-out)? ¿Esto significa que va a almacenar un Array de 100 eventos y cuando # 101 viene adentro, dispondrá # 1, como first-in-first-out)?

No lo creo. El número máximo 100 significa que de freeObjects, pero de los objetos que se utilizan actualmente. Cuando ya no se usa un objeto, lo liberarás. Entonces el objeto liberado no será descarded sino ser almacenado como un freeObject (el número máximo significa que de estos objetos ahorrados). La próxima vez que necesites otro objeto nuevo, no tienes que instanciar un nuevo objeto. Todo lo que necesitas es reutilizar uno de los freeObjects.

Por lo tanto, puede evitar costosas instanciaciones de objetos. Puede mejorar en rendimiento.