GenericPool

java.lang.Object
- org.qbroker.common.GenericPool

```
public class GenericPool
extends java.lang.Object
```
GenericPool is a container to store multiple instances of the same object. The number of active instances ranges from the minimum to its capacity. The application is able to checkout an active instance from the pool. Once the application is done with the instance, it is supposed to check it back in the pool so that others may use it sooner or later. If all the active instances are checked out, GenericPool will create a new instance as long as the pool is not full. GenericPool will always try to maintain the minmum number of active instances. Therefore, in case there are more active instances than the minimum required number, any instance idled for too long may get closed to save resources.

GenericPool supports any concrete class or interface, as long as it is not any Java primary types. The argument of obj can be a String for the full Java classname or a Class of the object. Otherwise, GenericPool will treat the object as a factory generator for an interface object. In this case, you have to specify the name of the method to destroy the object and the name of the method to generate the object. The argument of initArgs is used to create the new instnances. It must not contain any nulls. In case there is a conflict with the class name and the argument, please specify the class name for the pTypes.

In case of a concrete class, it is up to the object itself to decide how to close an instance. If there is an instance method of close() or destroy(), GenericPool will invoke it to close the active instance. Otherwise, GenericPool simply resets its status and timestamp, as well as sets the instance object to null.

Author:

yannanlu@yahoo.com

Field Summary

Fields
Modifier and Type Field and Description

static int POOL_CHECKOUT

static int POOL_CLOSED

static int POOL_INVALID

static int POOL_OK

Fields
Modifier and Type	Field and Description
`static int`	`POOL_CHECKOUT`
`static int`	`POOL_CLOSED`
`static int`	`POOL_INVALID`
`static int`	`POOL_OK`

Constructor Summary

Constructors
Constructor and Description
`GenericPool(java.lang.String name, int minSize, int capacity, java.lang.Object obj, java.lang.Object[] initArgs)`
`GenericPool(java.lang.String name, int minSize, int capacity, java.lang.Object obj, java.lang.String closerName, java.lang.String createrName, java.lang.Object[] initArgs)`
`GenericPool(java.lang.String name, int minSize, int capacity, java.lang.Object obj, java.lang.String closerName, java.lang.String createrName, java.lang.Object[] initArgs, java.lang.Class[] pt)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`checkin(java.lang.Object obj, int s)` It checks in the used instance of the object.
`java.lang.Object`	`checkout(long milliSec)` returns an active instance of the object with the default args.
`java.lang.Object`	`checkout(long milliSec, java.lang.Object[] args)` It checks out an active instance of the object.
`void`	`close()`
`protected java.lang.Object`	`create(java.lang.Object[] initArgs)`
`protected void`	`destroy(int id)`
`protected void`	`finalize()`
`int`	`getCapacity()` returns capacity of the pool
`int`	`getCount()` returns number of active instances not in use
`int`	`getId(java.lang.Object obj)` returns the ID of the object or -1 if it has no such object
`java.lang.Object`	`getInitArg(int i)` It returns the i-th default init argument or null if out of range.
`java.lang.String`	`getName()`
`int`	`getNumberOfArgs()` returns the length of the default initArgs
`int`	`getSize()` returns number of active instances regardless it is used or not
`int`	`getStatus()` returns the mask of internal XQueue

Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - POOL_OK
```
public static final int POOL_OK
```
    See Also:
    
    Constant Field Values
  - POOL_CHECKOUT
```
public static final int POOL_CHECKOUT
```
    See Also:
    
    Constant Field Values
  - POOL_INVALID
```
public static final int POOL_INVALID
```
    See Also:
    
    Constant Field Values
  - POOL_CLOSED
```
public static final int POOL_CLOSED
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - GenericPool
```
public GenericPool(java.lang.String name,
                   int minSize,
                   int capacity,
                   java.lang.Object obj,
                   java.lang.String closerName,
                   java.lang.String createrName,
                   java.lang.Object[] initArgs,
                   java.lang.Class[] pt)
```
  - GenericPool
```
public GenericPool(java.lang.String name,
                   int minSize,
                   int capacity,
                   java.lang.Object obj,
                   java.lang.String closerName,
                   java.lang.String createrName,
                   java.lang.Object[] initArgs)
```
  - GenericPool
```
public GenericPool(java.lang.String name,
                   int minSize,
                   int capacity,
                   java.lang.Object obj,
                   java.lang.Object[] initArgs)
```
- Method Detail
  - checkout
```
public java.lang.Object checkout(long milliSec,
                                 java.lang.Object[] args)
```
    It checks out an active instance of the object. If there is no active instance available and there is no room for any new instance, it simply returns null to indicate no instance available. If the pool is not full yet, it will try to create a new instance. If you want to create a customized instance, you have to set minSize to ZERO and specify your customized initial arguments, args. Zero minSize will guarentee no instance gets recycled or reused. If minSize is none zero or args is null, the pool will use the default initArgs to create new instances. If the creation is sucessful, it returns the instance. Otherwise, the exception is returned to indicate failure. Therefore, applications are supposed to check the object before any use.
    
    Due to MT features, you have to provide milliSec as the waitinmg time.
  - checkout
```
public java.lang.Object checkout(long milliSec)
```
    returns an active instance of the object with the default args.
  - checkin
```
public void checkin(java.lang.Object obj,
                    int s)
```
    It checks in the used instance of the object. If the instance is not in working state, you have to specify the proper status to notify the pool. The pool will decide if to recycle the object or destroy it.
  - getName
```
public java.lang.String getName()
```
  - getCapacity
```
public int getCapacity()
```
    returns capacity of the pool
  - getSize
```
public int getSize()
```
    returns number of active instances regardless it is used or not
  - getCount
```
public int getCount()
```
    returns number of active instances not in use
  - getStatus
```
public int getStatus()
```
    returns the mask of internal XQueue
  - getNumberOfArgs
```
public int getNumberOfArgs()
```
    returns the length of the default initArgs
  - getInitArg
```
public java.lang.Object getInitArg(int i)
```
    It returns the i-th default init argument or null if out of range. It is for read-only purpose. Therefore, it is not MT-safe.
  - getId
```
public int getId(java.lang.Object obj)
```
    returns the ID of the object or -1 if it has no such object
  - close
```
public void close()
```
  - finalize
```
protected void finalize()
```
    Overrides:
    
    finalize in class java.lang.Object
  - create
```
protected java.lang.Object create(java.lang.Object[] initArgs)
```
  - destroy
```
protected void destroy(int id)
```

Class GenericPool

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

POOL_OK

POOL_CHECKOUT

POOL_INVALID

POOL_CLOSED

Constructor Detail

GenericPool

GenericPool

GenericPool

Method Detail

checkout

checkout

checkin

getName

getCapacity

getSize

getCount

getStatus

getNumberOfArgs

getInitArg

getId

close

finalize

create

destroy