net.sf.javagimmicks.concurrent

Class BlockingSingletonRegistry

java.lang.Object

net.sf.javagimmicks.concurrent.BlockingSingletonRegistry

public class BlockingSingletonRegistry
extends Object

This class serves as a registry that allows (de-)registration of objects following the singleton pattern and provides blocking getter methods for them. This means that getter calls will not return until the desired singleton instance has been registered in this container (or a timeout or interruption has occurred).

This might be useful in server environments where the container (e.g. a CDI container) takes care about instantiation (at some time) but clients want or need to access the the instances from without the containers context (e.g. via plain old static getter calls).

The class can be directly instantiated using the default constructor or a static default instance can be used.

This class intensively uses BlockingObjectContainer internally

See Also:

BlockingObjectContainer

Constructor Summary

Constructors

Constructor and Description
BlockingSingletonRegistry()

Method Summary

Modifier and Type	Method and Description
<T> T	get(Class<T> clazz) Retrieves the singleton instance of the given class waiting uninterruptibly until it is registered (i.e. the waiting Thread will NOT react to Thread.interrupt() calls) Attention: this call blocks FOREVER - so you REALLY should take care that the requested instance is finally registered
<T> T	get(Class<T> clazz, long time, TimeUnit timeUnit) Retrieves the singleton instance of the given class waiting interruptibly (i.e. the waiting Thread will react to Thread.interrupt() calls) until it is registered or the given timeout has elapsed
static BlockingSingletonRegistry	getDefault() Returns a static default (singleton) instance of the BlockingSingletonRegistry
<T> T	getInterruptibly(Class<T> clazz) Retrieves the singleton instance of the given class waiting interruptibly until it is registered (i.e. the waiting Thread will react to Thread.interrupt() calls) Attention: this call block FOREVER (if not interrupted) - so you REALLY should take care that the requested instance is finally registered
<T> T	getNoWait(Class<T> clazz) Retrieves the singleton instance of the given class if currently registered without potentially waiting for it (i.e. the call will always return immediately)
<T> void	remove(Class<T> clazz) Removes the singleton of the given class from the registry
<T> void	remove(T instance) Remove the given singleton instance from the registry
<T> void	set(T instance) Registers a new singleton instance in the registry

Methods inherited from class java.lang.Object

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

Constructor Detail

BlockingSingletonRegistry

public BlockingSingletonRegistry()

Method Detail

getDefault

public static BlockingSingletonRegistry getDefault()

Returns a static default (singleton) instance of the BlockingSingletonRegistry

Returns:

the default instance

set

public <T> void set(T instance)
             throws IllegalStateException

Registers a new singleton instance in the registry

Type Parameters:

T - the type of the singleton object to register

Parameters:

instance - the singleton instance to register

Throws:

IllegalStateException - if there is already another instance of the given class registered (it's not a singleton)

remove

public <T> void remove(Class<T> clazz)

Removes the singleton of the given class from the registry

Type Parameters:

T - the type of the singleton object to remove

Parameters:

clazz - the singleton class whose instance should be removed

remove

public <T> void remove(T instance)

Remove the given singleton instance from the registry

Type Parameters:

T - the type of the singleton object to remove

Parameters:

instance - the singleton instance that should be removed

Throws:

IllegalArgumentException - if another one than the registered singleton instance should be removed

get

public <T> T get(Class<T> clazz)

Retrieves the singleton instance of the given class waiting uninterruptibly until it is registered (i.e. the waiting Thread will NOT react to Thread.interrupt() calls)

Attention: this call blocks FOREVER - so you REALLY should take care that the requested instance is finally registered

Type Parameters:

T - the type of the singleton object to retrieve

Parameters:

clazz - the class whose singleton instance should be retrieved

Returns:

the resulting singleton instance of the given class

getInterruptibly

public <T> T getInterruptibly(Class<T> clazz)
                       throws InterruptedException

Retrieves the singleton instance of the given class waiting interruptibly until it is registered (i.e. the waiting Thread will react to Thread.interrupt() calls)

Attention: this call block FOREVER (if not interrupted) - so you REALLY should take care that the requested instance is finally registered

Type Parameters:

T - the type of the singleton object to retrieve

Parameters:

clazz - the class whose singleton instance should be retrieved

Returns:

the resulting singleton instance of the given class

Throws:

InterruptedException - if the waiting Thread is interrupted while waiting

get

public <T> T get(Class<T> clazz,
                 long time,
                 TimeUnit timeUnit)
          throws InterruptedException

Retrieves the singleton instance of the given class waiting interruptibly (i.e. the waiting Thread will react to Thread.interrupt() calls) until it is registered or the given timeout has elapsed

Type Parameters:

T - the type of the singleton object to retrieve

Parameters:

clazz - the class whose singleton instance should be retrieved

time - the number of TimeUnits to wait at until the call returns

timeUnit - the TimeUnit of the given time amount to wait

Returns:

the resulting singleton instance of the given class

Throws:

InterruptedException - if the waiting Thread is interrupted while waiting

getNoWait

public <T> T getNoWait(Class<T> clazz)

Retrieves the singleton instance of the given class if currently registered without potentially waiting for it (i.e. the call will always return immediately)

Type Parameters:

T - the type of the singleton object to retrieve

Parameters:

clazz - the class whose singleton instance should be retrieved

Returns:

the registered singleton instance or null if non is registered