org.apache.lucene.facet.search
Class TemporaryObjectAllocator<T>

java.lang.Object
  org.apache.lucene.facet.search.TemporaryObjectAllocator<T>

Direct Known Subclasses:

FloatArrayAllocator, IntArrayAllocator

public abstract class TemporaryObjectAllocator<T>
extends Object

An TemporaryObjectAllocator is an object which manages large, reusable, temporary objects needed during multiple concurrent computations. The idea is to remember some of the previously allocated temporary objects, and reuse them if possible to avoid constant allocation and garbage-collection of these objects.

This technique is useful for temporary counter arrays in faceted search (see FacetsAccumulator), which can be reused across searches instead of being allocated afresh on every search.

A TemporaryObjectAllocator is thread-safe.

WARNING: This API is experimental and might change in incompatible ways in the next release.

Constructor Summary

TemporaryObjectAllocator(int maxObjects)
Construct an allocator for objects of a certain type, keeping around a pool of up to maxObjects old objects.

Method Summary

T	allocate() Allocate a new object.
protected abstract void	clear(T object) Subclasses must override this method to clear an existing object of the desired type, to prepare it for reuse.
protected abstract T	create() Subclasses must override this method to actually create a new object of the desired type.
void	free(T object) Return a no-longer-needed object back to the pool.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

TemporaryObjectAllocator

public TemporaryObjectAllocator(int maxObjects)

Construct an allocator for objects of a certain type, keeping around a pool of up to maxObjects old objects.

Note that the pool size only restricts the number of objects that hang around when not needed, but not the maximum number of objects that are allocated when actually is use: If a number of concurrent threads ask for an allocation, all of them will get an object, even if their number is greater than maxObjects. If an application wants to limit the number of concurrent threads making allocations, it needs to do so on its own - for example by blocking new threads until the existing ones have finished. If more than maxObjects are freed, only maxObjects of them will be kept in the pool - the rest will not and will eventually be garbage-collected by Java.

In particular, when maxObjects=0, this object behaves as a trivial allocator, always allocating a new array and never reusing an old one.

Method Detail

create

protected abstract T create()

Subclasses must override this method to actually create a new object of the desired type.

clear

protected abstract void clear(T object)

Subclasses must override this method to clear an existing object of the desired type, to prepare it for reuse. Note that objects will be cleared just before reuse (on allocation), not when freed.

allocate

public final T allocate()

Allocate a new object. If there's a previously allocated object in our pool, we return it immediately. Otherwise, a new object is allocated.

Don't forget to call free(Object) when you're done with the object, to return it to the pool. If you don't, memory is not leaked, but the pool will remain empty and a new object will be allocated each time (just like the maxArrays=0 case).

free

public final void free(T object)

Return a no-longer-needed object back to the pool. If we already have enough objects in the pool (maxObjects as specified in the constructor), the array will not be saved, and Java will eventually garbage collect it.

In particular, when maxArrays=0, the given array is never saved and free does nothing.