net.sf.javagimmicks.concurrent

Class BlockingObjectContainer<E>

java.lang.Object

net.sf.javagimmicks.concurrent.BlockingObjectContainer<E>

Type Parameters:

E - the type of object the container can carry

All Implemented Interfaces:

Consumer<E>, Supplier<E>, WritableObjectContainer<E>

public class BlockingObjectContainer<E>
extends Object
implements WritableObjectContainer<E>

This class serves as a container that allows (de-)registration of objects of the specified type and provides blocking getter methods for them. This means that (depending on the concretely called 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).

Constructor Summary

Constructors

Constructor and Description
BlockingObjectContainer() Creates a new instance disallowing overwriting of an existing instance
BlockingObjectContainer(boolean allowOverwrite) Creates a new instance with given setting for overwriting an existing instance

Method Summary

Modifier and Type	Method and Description
void	accept(E instance)
E	get() Retrieves the instance 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
E	get(long time, TimeUnit timeUnit) Retrieves the registered instance waiting interruptibly (i.e. the waiting Thread will react to Thread.interrupt() calls) until it is registered or the given timeout has elapsed
E	getInterruptibly() Retrieves the registered instance 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
E	getNoWait() Retrieves the instance if currently registered without potentially waiting for it (i.e. the call will always return immediately)
boolean	isAllowOverwrite()
E	remove()

Methods inherited from class java.lang.Object

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

Constructor Detail

BlockingObjectContainer

public BlockingObjectContainer(boolean allowOverwrite)

Creates a new instance with given setting for overwriting an existing instance

Parameters:

allowOverwrite - the setting for overwriting an existing instance

See Also:

WritableObjectContainer.accept(Object), WritableObjectContainer.isAllowOverwrite()

BlockingObjectContainer

public BlockingObjectContainer()

Creates a new instance disallowing overwriting of an existing instance

Method Detail

isAllowOverwrite

public boolean isAllowOverwrite()

Specified by:

isAllowOverwrite in interface WritableObjectContainer<E>

accept

public void accept(E instance)
            throws IllegalStateException

Specified by:

accept in interface Consumer<E>

Specified by:

accept in interface WritableObjectContainer<E>

Throws:

IllegalStateException

remove

public E remove()

Specified by:

remove in interface WritableObjectContainer<E>

get

public E get()

Retrieves the instance 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

Specified by:

get in interface Supplier<E>

Returns:

the resulting instance

getInterruptibly

public E getInterruptibly()
                   throws InterruptedException

Retrieves the registered instance 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

Returns:

the resulting instance

Throws:

InterruptedException - if the waiting Thread is interrupted while waiting

get

public E get(long time,
             TimeUnit timeUnit)
      throws InterruptedException

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

Parameters:

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 instance

Throws:

InterruptedException - if the waiting Thread is interrupted while waiting

getNoWait

public E getNoWait()

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

Returns:

the registered singleton instance or null if non is registered