diff --git a/README.md b/README.md
index 78ebaca..49374d7 100644
--- a/README.md
+++ b/README.md
@@ -62,7 +62,7 @@
 <dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-jcs</artifactId>
-  <version>2.1</version>
+  <version>2.0</version>
 </dependency>
 ```
 
diff --git a/commons-jcs-core/pom.xml b/commons-jcs-core/pom.xml
index ea02976..1b35a29 100644
--- a/commons-jcs-core/pom.xml
+++ b/commons-jcs-core/pom.xml
@@ -33,9 +33,9 @@
   <name>Apache Commons JCS :: Core</name>
 
   <scm>
-    <connection>scm:svn:http://svn.apache.org/repos/asf/commons/proper/jcs/branches/commons-jcs-2.1-RC/commons-jcs-core</connection>
-    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/commons/proper/jcs/branches/commons-jcs-2.1-RC/commons-jcs-core</developerConnection>
-    <url>http://svn.apache.org/viewvc/commons/proper/jcs/branches/commons-jcs-2.1-RC/commons-jcs-core</url>
+    <connection>scm:svn:http://svn.apache.org/repos/asf/commons/proper/jcs/trunk/commons-jcs-core</connection>
+    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/commons/proper/jcs/trunk/commons-jcs-core</developerConnection>
+    <url>http://svn.apache.org/viewvc/commons/proper/jcs/trunk/commons-jcs-core</url>
   </scm>
 
   <properties>
@@ -154,9 +154,6 @@
               <exclude>**/UDPDiscoveryUnitTest.java</exclude>
               <!-- Causes hang in Continuum -->
               <exclude>**/UDPDiscoverySenderUnitTest.java</exclude>
-              <!-- The ones that fail may be different for you. -->
-              <!-- <exclude>**/JDBCDiskCacheRemovalUnitTest.java</exclude> -->
-              <!-- <exclude>**/JDBCDiskCacheUnitTest.java</exclude> -->
             </excludes>
           </configuration>
         </plugin>
diff --git a/commons-jcs-core/src/main/java/org/apache/commons/jcs/JCS.java b/commons-jcs-core/src/main/java/org/apache/commons/jcs/JCS.java
index 304df37..a51da23 100644
--- a/commons-jcs-core/src/main/java/org/apache/commons/jcs/JCS.java
+++ b/commons-jcs-core/src/main/java/org/apache/commons/jcs/JCS.java
@@ -130,6 +130,22 @@
     }
 
     /**
+     * Shut down the cache manager and set the instance to null
+     */
+    public static void shutdown()
+    {
+        synchronized ( JCS.class )
+        {
+            if ( cacheMgr != null && cacheMgr.isInitialized())
+            {
+            	cacheMgr.shutDown();
+            }
+
+            cacheMgr = null;
+        }
+    }
+
+    /**
      * Helper method which checks to make sure the cacheMgr class field is set, and if not requests
      * an instance from CacheManagerFactory.
      *
diff --git a/commons-jcs-core/src/main/java/org/apache/commons/jcs/auxiliary/remote/AbstractRemoteAuxiliaryCache.java b/commons-jcs-core/src/main/java/org/apache/commons/jcs/auxiliary/remote/AbstractRemoteAuxiliaryCache.java
index 653220d..0b3d656 100644
--- a/commons-jcs-core/src/main/java/org/apache/commons/jcs/auxiliary/remote/AbstractRemoteAuxiliaryCache.java
+++ b/commons-jcs-core/src/main/java/org/apache/commons/jcs/auxiliary/remote/AbstractRemoteAuxiliaryCache.java
@@ -26,8 +26,8 @@
 import java.util.Set;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
-import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 
@@ -77,7 +77,7 @@
     private IRemoteCacheAttributes remoteCacheAttributes;
 
     /** A thread pool for gets if configured. */
-    private ThreadPoolExecutor pool = null;
+    private ExecutorService pool = null;
 
     /** Should we get asynchronously using a pool. */
     private boolean usePoolForGet = false;
@@ -113,15 +113,12 @@
 
         if ( getRemoteCacheAttributes().getGetTimeoutMillis() > 0 )
         {
-            pool = ThreadPoolManager.getInstance().getPool( getRemoteCacheAttributes().getThreadPoolName() );
+            pool = ThreadPoolManager.getInstance().getExecutorService( getRemoteCacheAttributes().getThreadPoolName() );
             if ( log.isDebugEnabled() )
             {
                 log.debug( "Thread Pool = " + pool );
             }
-            if ( pool != null )
-            {
-                usePoolForGet = true;
-            }
+            usePoolForGet = true;
         }
     }
 
@@ -145,7 +142,7 @@
                 getRemoteCacheListener().dispose();
             }
         }
-        catch ( Exception ex )
+        catch ( IOException ex )
         {
             log.error( "Couldn't dispose", ex );
             handleException( ex, "Failed to dispose [" + cacheName + "]", ICacheEventLogger.DISPOSE_EVENT );
@@ -573,8 +570,7 @@
 
         if ( pool != null )
         {
-            elems.add(new StatElement<Integer>( "Pool Size", Integer.valueOf(pool.getPoolSize()) ) );
-            elems.add(new StatElement<Integer>( "Maximum Pool Size", Integer.valueOf(pool.getMaximumPoolSize()) ) );
+            elems.add(new StatElement<ExecutorService>( "Pool", pool ) );
         }
 
         if ( getRemoteCacheService() instanceof ZombieCacheServiceNonLocal )
diff --git a/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/AbstractCacheEventQueue.java b/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/AbstractCacheEventQueue.java
index 216a94d..9f37b0c 100644
--- a/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/AbstractCacheEventQueue.java
+++ b/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/AbstractCacheEventQueue.java
@@ -64,9 +64,6 @@
     /** in milliseconds */
     private int waitBeforeRetry;
 
-    /** this is true if there is any worker thread. */
-    private final AtomicBoolean alive = new AtomicBoolean(false);
-
     /**
      * This means that the queue is functional. If we reached the max number of failures, the queue
      * is marked as non functional and will never work again.
@@ -108,21 +105,27 @@
      * If they queue has an active thread it is considered alive.
      * <p>
      * @return The alive value
+     * 
+     * @deprecated The alive-logic is not used 
      */
-    @Override
+    @Deprecated
+	@Override
     public boolean isAlive()
     {
-        return alive.get();
+        return true;
     }
 
     /**
      * Sets whether the queue is actively processing -- if there are working threads.
      * <p>
      * @param aState
+     * 
+     * @deprecated The alive-logic is not used 
      */
-    public void setAlive( boolean aState )
+    @Deprecated
+	public void setAlive( boolean aState )
     {
-        alive.set(aState);
+        // do nothing
     }
 
     /**
@@ -179,17 +182,9 @@
      * @throws IOException
      */
     @Override
-    public synchronized void addPutEvent( ICacheElement<K, V> ce )
-        throws IOException
+    public void addPutEvent( ICacheElement<K, V> ce )
     {
-        if ( isWorking() )
-        {
-            put( new PutEvent( ce ) );
-        }
-        else if ( log.isWarnEnabled() )
-        {
-            log.warn( "Not enqueuing Put Event for [" + this + "] because it's non-functional." );
-        }
+        put( new PutEvent( ce ) );
     }
 
     /**
@@ -200,54 +195,28 @@
      * @throws IOException
      */
     @Override
-    public synchronized void addRemoveEvent( K key )
-        throws IOException
+    public void addRemoveEvent( K key )
     {
-        if ( isWorking() )
-        {
-            put( new RemoveEvent( key ) );
-        }
-        else if ( log.isWarnEnabled() )
-        {
-            log.warn( "Not enqueuing Remove Event for [" + this + "] because it's non-functional." );
-        }
+        put( new RemoveEvent( key ) );
     }
 
     /**
      * This adds a remove all event to the queue. When it is processed, all elements will be removed
      * from the cache.
-     * <p>
-     * @throws IOException
      */
     @Override
-    public synchronized void addRemoveAllEvent()
-        throws IOException
+    public void addRemoveAllEvent()
     {
-        if ( isWorking() )
-        {
-            put( new RemoveAllEvent() );
-        }
-        else if ( log.isWarnEnabled() )
-        {
-            log.warn( "Not enqueuing RemoveAll Event for [" + this + "] because it's non-functional." );
-        }
+        put( new RemoveAllEvent() );
     }
 
     /**
-     * @throws IOException
+     * This adds a dispose event to the queue. When it is processed, the cache is shut down
      */
     @Override
-    public synchronized void addDisposeEvent()
-        throws IOException
+    public void addDisposeEvent()
     {
-        if ( isWorking() )
-        {
-            put( new DisposeEvent() );
-        }
-        else if ( log.isWarnEnabled() )
-        {
-            log.warn( "Not enqueuing Dispose Event for [" + this + "] because it's non-functional." );
-        }
+        put( new DisposeEvent() );
     }
 
     /**
@@ -293,8 +262,7 @@
                         log.warn( "Error while running event from Queue: " + this
                             + ". Dropping Event and marking Event Queue as non-functional." );
                     }
-                    setWorking( false );
-                    setAlive( false );
+                    destroy();
                     return;
                 }
                 if ( log.isInfoEnabled() )
@@ -312,10 +280,7 @@
                     {
                         log.warn( "Interrupted while sleeping for retry on event " + this + "." );
                     }
-                    // TODO consider if this is best. maybe we should just
-                    // destroy
-                    setWorking( false );
-                    setAlive( false );
+                    destroy();
                 }
             }
         }
@@ -342,10 +307,8 @@
          * Constructor for the PutEvent object.
          * <p>
          * @param ice
-         * @throws IOException
          */
         PutEvent( ICacheElement<K, V> ice )
-            throws IOException
         {
             this.ice = ice;
         }
@@ -391,10 +354,8 @@
          * Constructor for the RemoveEvent object
          * <p>
          * @param key
-         * @throws IOException
          */
         RemoveEvent( K key )
-            throws IOException
         {
             this.key = key;
         }
diff --git a/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/CacheEventQueue.java b/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/CacheEventQueue.java
index 58fc27b..bf2758f 100644
--- a/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/CacheEventQueue.java
+++ b/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/CacheEventQueue.java
@@ -1,9 +1,5 @@
 package org.apache.commons.jcs.engine;
 
-import java.util.ArrayList;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.TimeUnit;
-
 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
@@ -24,35 +20,19 @@
  */
 
 import org.apache.commons.jcs.engine.behavior.ICacheListener;
-import org.apache.commons.jcs.engine.stats.StatElement;
-import org.apache.commons.jcs.engine.stats.Stats;
-import org.apache.commons.jcs.engine.stats.behavior.IStatElement;
-import org.apache.commons.jcs.engine.stats.behavior.IStats;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.apache.commons.jcs.utils.threadpool.PoolConfiguration;
+import org.apache.commons.jcs.utils.threadpool.PoolConfiguration.WhenBlockedPolicy;
+import org.apache.commons.jcs.utils.threadpool.ThreadPoolManager;
 
 /**
  * An event queue is used to propagate ordered cache events to one and only one target listener.
- * <p>
- * This is a modified version of the experimental version. It should lazy initialize the processor
- * thread, and kill the thread if the queue goes empty for a specified period, now set to 1 minute.
- * If something comes in after that a new processor thread should be created.
  */
 public class CacheEventQueue<K, V>
-    extends AbstractCacheEventQueue<K, V>
+    extends PooledCacheEventQueue<K, V>
 {
-    /** The logger. */
-    private static final Log log = LogFactory.getLog( CacheEventQueue.class );
-
     /** The type of queue -- there are pooled and single */
     private static final QueueType queueType = QueueType.SINGLE;
 
-    /** the thread that works the queue. */
-    private Thread processorThread;
-
-    /** Queue implementation */
-    private LinkedBlockingQueue<AbstractCacheEvent> queue = new LinkedBlockingQueue<AbstractCacheEvent>();
-
     /**
      * Constructs with the specified listener and the cache name.
      * <p>
@@ -77,7 +57,29 @@
     public CacheEventQueue( ICacheListener<K, V> listener, long listenerId, String cacheName, int maxFailure,
                             int waitBeforeRetry )
     {
-        initialize( listener, listenerId, cacheName, maxFailure, waitBeforeRetry );
+        super( listener, listenerId, cacheName, maxFailure, waitBeforeRetry, null );
+    }
+
+    /**
+     * Initializes the queue.
+     * <p>
+     * @param listener
+     * @param listenerId
+     * @param cacheName
+     * @param maxFailure
+     * @param waitBeforeRetry
+     * @param threadPoolName
+     */
+    @Override
+    protected void initialize( ICacheListener<K, V> listener, long listenerId, String cacheName, int maxFailure,
+                            int waitBeforeRetry, String threadPoolName )
+    {
+        super.initialize(listener, listenerId, cacheName, maxFailure, waitBeforeRetry);
+
+        // create a default pool with one worker thread to mimic the SINGLE queue behavior
+        pool = ThreadPoolManager.getInstance().createPool(
+        		new PoolConfiguration(false, 0, 1, 0, getWaitToDieMillis(), WhenBlockedPolicy.RUN, 0),
+        		"CacheEventQueue.QProcessor-" + getCacheName());
     }
 
     /**
@@ -90,192 +92,4 @@
     {
         return queueType;
     }
-
-    /**
-     * Kill the processor thread and indicate that the queue is destroyed and no longer alive, but it
-     * can still be working.
-     */
-    protected void stopProcessing()
-    {
-        setAlive(false);
-        processorThread = null;
-    }
-
-    /**
-     * Event Q is empty.
-     * <p>
-     * Calling destroy interrupts the processor thread.
-     */
-    @Override
-    public void destroy()
-    {
-        if ( isAlive() )
-        {
-            setAlive(false);
-
-            if ( log.isInfoEnabled() )
-            {
-                log.info( "Destroying queue, stats =  " + getStatistics() );
-            }
-
-            if ( processorThread != null )
-            {
-                processorThread.interrupt();
-                processorThread = null;
-            }
-
-            if ( log.isInfoEnabled() )
-            {
-                log.info( "Cache event queue destroyed: " + this );
-            }
-        }
-        else
-        {
-            if ( log.isInfoEnabled() )
-            {
-                log.info( "Destroy was called after queue was destroyed. Doing nothing. Stats =  " + getStatistics() );
-            }
-        }
-    }
-
-    /**
-     * Adds an event to the queue.
-     * <p>
-     * @param event
-     */
-    @Override
-    protected void put( AbstractCacheEvent event )
-    {
-        if ( log.isDebugEnabled() )
-        {
-            log.debug( "Event entering Queue for " + getCacheName() + ": " + event );
-        }
-
-        queue.offer(event);
-
-        if ( isWorking() )
-        {
-            if ( !isAlive() )
-            {
-                setAlive(true);
-                processorThread = new QProcessor();
-                processorThread.start();
-                if ( log.isInfoEnabled() )
-                {
-                    log.info( "Cache event queue created: " + this );
-                }
-            }
-        }
-    }
-
-    // /////////////////////////// Inner classes /////////////////////////////
-
-    /**
-     * This is the thread that works the queue.
-     * <p>
-     * @author asmuts
-     * @created January 15, 2002
-     */
-    protected class QProcessor
-        extends Thread
-    {
-        /**
-         * Constructor for the QProcessor object
-         * <p>
-         * @param aQueue the event queue to take items from.
-         */
-        QProcessor()
-        {
-            super( "CacheEventQueue.QProcessor-" + getCacheName() );
-            setDaemon( true );
-        }
-
-        /**
-         * Main processing method for the QProcessor object.
-         * <p>
-         * Waits for a specified time (waitToDieMillis) for something to come in and if no new
-         * events come in during that period the run method can exit and the thread is dereferenced.
-         */
-        @Override
-        public void run()
-        {
-
-            while ( CacheEventQueue.this.isAlive() )
-            {
-                AbstractCacheEvent event = null;
-
-                try
-                {
-                    event = queue.poll(getWaitToDieMillis(), TimeUnit.MILLISECONDS);
-                }
-                catch (InterruptedException e)
-                {
-                    // is ok
-                }
-
-                if ( log.isDebugEnabled() )
-                {
-                    log.debug( "Event from queue = " + event );
-                }
-
-                if ( event == null )
-                {
-                    stopProcessing();
-                }
-
-                if ( event != null && isWorking() && CacheEventQueue.this.isAlive() )
-                {
-                    event.run();
-                }
-            }
-            if ( log.isDebugEnabled() )
-            {
-                log.debug( "QProcessor exiting for " + getCacheName() );
-            }
-        }
-    }
-
-    /**
-     * This method returns semi-structured data on this queue.
-     * <p>
-     * @see org.apache.commons.jcs.engine.behavior.ICacheEventQueue#getStatistics()
-     * @return information on the status and history of the queue
-     */
-    @Override
-    public IStats getStatistics()
-    {
-        IStats stats = new Stats();
-        stats.setTypeName( "Cache Event Queue" );
-
-        ArrayList<IStatElement<?>> elems = new ArrayList<IStatElement<?>>();
-
-        elems.add(new StatElement<Boolean>( "Working", Boolean.valueOf(this.isWorking()) ) );
-        elems.add(new StatElement<Boolean>( "Alive", Boolean.valueOf(this.isAlive()) ) );
-        elems.add(new StatElement<Boolean>( "Empty", Boolean.valueOf(this.isEmpty()) ) );
-        elems.add(new StatElement<Integer>( "Size", Integer.valueOf(this.size()) ) );
-
-        stats.setStatElements( elems );
-
-        return stats;
-    }
-
-    /**
-     * @return whether there are any items in the queue.
-     */
-    @Override
-    public boolean isEmpty()
-    {
-        return queue.isEmpty();
-    }
-
-    /**
-     * Returns the number of elements in the queue.
-     * <p>
-     * @return number of items in the queue.
-     */
-    @Override
-    public int size()
-    {
-        return queue.size();
-    }
 }
diff --git a/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/PooledCacheEventQueue.java b/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/PooledCacheEventQueue.java
index 81dfe23..e4b1089 100644
--- a/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/PooledCacheEventQueue.java
+++ b/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/PooledCacheEventQueue.java
@@ -2,6 +2,7 @@
 
 import java.util.ArrayList;
 import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.ExecutorService;
 import java.util.concurrent.ThreadPoolExecutor;
 
 /*
@@ -52,7 +53,10 @@
     private static final QueueType queueType = QueueType.POOLED;
 
     /** The Thread Pool to execute events with. */
-    private ThreadPoolExecutor pool = null;
+    protected ExecutorService pool = null;
+
+    /** The Thread Pool queue */
+    protected BlockingQueue<Runnable> queue = null;
 
     /**
      * Constructor for the CacheEventQueue object
@@ -86,8 +90,13 @@
         super.initialize(listener, listenerId, cacheName, maxFailure, waitBeforeRetry);
 
         // this will share the same pool with other event queues by default.
-        pool = ThreadPoolManager.getInstance().getPool(
+        pool = ThreadPoolManager.getInstance().getExecutorService(
                 (threadPoolName == null) ? "cache_event_queue" : threadPoolName );
+        
+        if (pool instanceof ThreadPoolExecutor)
+        {
+        	queue = ((ThreadPoolExecutor) pool).getQueue();
+        }
     }
 
     /**
@@ -105,9 +114,9 @@
     @Override
     public synchronized void destroy()
     {
-        if ( isAlive() )
+        if ( isWorking() )
         {
-            setAlive(false);
+            setWorking(false);
             pool.shutdownNow();
             if ( log.isInfoEnabled() )
             {
@@ -138,20 +147,15 @@
 
         ArrayList<IStatElement<?>> elems = new ArrayList<IStatElement<?>>();
 
-        elems.add(new StatElement<Boolean>( "Working", Boolean.valueOf(super.isWorking()) ) );
-        elems.add(new StatElement<Boolean>( "Alive", Boolean.valueOf(this.isAlive()) ) );
+        elems.add(new StatElement<Boolean>( "Working", Boolean.valueOf(isWorking()) ) );
         elems.add(new StatElement<Boolean>( "Empty", Boolean.valueOf(this.isEmpty()) ) );
 
-        if ( pool.getQueue() != null )
+        if ( queue != null )
         {
-            BlockingQueue<Runnable> bb = pool.getQueue();
-            elems.add(new StatElement<Integer>( "Queue Size", Integer.valueOf(bb.size()) ) );
-            elems.add(new StatElement<Integer>( "Queue Capacity", Integer.valueOf(bb.remainingCapacity()) ) );
+            elems.add(new StatElement<Integer>( "Queue Size", Integer.valueOf(queue.size()) ) );
+            elems.add(new StatElement<Integer>( "Queue Capacity", Integer.valueOf(queue.remainingCapacity()) ) );
         }
 
-        elems.add(new StatElement<Integer>( "Pool Size", Integer.valueOf(pool.getPoolSize()) ) );
-        elems.add(new StatElement<Integer>( "Maximum Pool Size", Integer.valueOf(pool.getMaximumPoolSize()) ) );
-
         stats.setStatElements( elems );
 
         return stats;
@@ -166,32 +170,25 @@
     @Override
     public boolean isEmpty()
     {
-        if ( pool.getQueue() == null )
-        {
-            return true;
-        }
-        else
-        {
-            return pool.getQueue().size() == 0;
-        }
+        return size() == 0;
     }
 
     /**
      * Returns the number of elements in the queue. If the queue cannot determine the size
-     * accurately it will return 1.
+     * accurately it will return 0.
      * <p>
      * @return number of items in the queue.
      */
     @Override
     public int size()
     {
-        if ( pool.getQueue() == null )
+        if ( queue == null )
         {
             return 0;
         }
         else
         {
-            return pool.getQueue().size();
+            return queue.size();
         }
     }
 }
diff --git a/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/control/event/ElementEventQueue.java b/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/control/event/ElementEventQueue.java
index 1a6e9bd..44ab573 100644
--- a/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/control/event/ElementEventQueue.java
+++ b/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/control/event/ElementEventQueue.java
@@ -20,14 +20,14 @@
  */
 
 import java.io.IOException;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.ThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
+import java.util.concurrent.ExecutorService;
 
 import org.apache.commons.jcs.engine.control.event.behavior.IElementEvent;
 import org.apache.commons.jcs.engine.control.event.behavior.IElementEventHandler;
 import org.apache.commons.jcs.engine.control.event.behavior.IElementEventQueue;
-import org.apache.commons.jcs.utils.threadpool.DaemonThreadFactory;
+import org.apache.commons.jcs.utils.threadpool.PoolConfiguration;
+import org.apache.commons.jcs.utils.threadpool.PoolConfiguration.WhenBlockedPolicy;
+import org.apache.commons.jcs.utils.threadpool.ThreadPoolManager;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
@@ -45,20 +45,16 @@
     /** shutdown or not */
     private boolean destroyed = false;
 
-    /** The event queue */
-    private LinkedBlockingQueue<Runnable> queue;
-
     /** The worker thread pool. */
-    private ThreadPoolExecutor queueProcessor;
+    private ExecutorService queueProcessor;
 
     /**
      * Constructor for the ElementEventQueue object
      */
     public ElementEventQueue()
     {
-        queue = new LinkedBlockingQueue<Runnable>();
-        queueProcessor = new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS,
-                queue, new DaemonThreadFactory(THREAD_PREFIX));
+        queueProcessor = ThreadPoolManager.getInstance().createPool(
+        		new PoolConfiguration(false, 0, 1, 1, 0, WhenBlockedPolicy.RUN, 1), THREAD_PREFIX);
 
         if ( log.isDebugEnabled() )
         {
diff --git a/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/memory/AbstractDoubleLinkedListMemoryCache.java b/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/memory/AbstractDoubleLinkedListMemoryCache.java
index b5523d7..5f85104 100644
--- a/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/memory/AbstractDoubleLinkedListMemoryCache.java
+++ b/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/memory/AbstractDoubleLinkedListMemoryCache.java
@@ -20,15 +20,10 @@
  */
 
 import java.io.IOException;
-import java.util.Iterator;
-import java.util.LinkedHashSet;
 import java.util.List;
-import java.util.Map;
-import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 
-import org.apache.commons.jcs.engine.CacheConstants;
 import org.apache.commons.jcs.engine.behavior.ICacheElement;
 import org.apache.commons.jcs.engine.control.CompositeCache;
 import org.apache.commons.jcs.engine.control.group.GroupAttrName;
@@ -199,74 +194,6 @@
     }
 
     /**
-     * Get an item from the cache If the item is found, it is removed from the list and added first.
-     * <p>
-     *
-     * @param key
-     *            Identifies item to find
-     * @return ICacheElement&lt;K, V&gt; if found, else null
-     * @throws IOException
-     */
-    @Override
-    public final ICacheElement<K, V> get(K key) throws IOException
-    {
-        ICacheElement<K, V> ce = null;
-
-        if (log.isDebugEnabled())
-        {
-            log.debug(getCacheName() + ": getting item for key " + key);
-        }
-
-        MemoryElementDescriptor<K, V> me = map.get(key);
-
-        if (me != null)
-        {
-            hitCnt.incrementAndGet();
-
-            lock.lock();
-            try
-            {
-                ce = me.getCacheElement();
-                // ABSTRACT
-                adjustListForGet(me);
-            }
-            finally
-            {
-                lock.unlock();
-            }
-
-            if (log.isDebugEnabled())
-            {
-                log.debug(getCacheName() + ": LRUMemoryCache hit for " + key);
-            }
-        }
-        else
-        {
-            missCnt.incrementAndGet();
-
-            if (log.isDebugEnabled())
-            {
-                log.debug(getCacheName() + ": LRUMemoryCache miss for " + key);
-            }
-        }
-
-        if (log.isDebugEnabled())
-        {
-            verifyCache();
-        }
-
-        return ce;
-    }
-
-    /**
-     * Adjust the list as needed for a get. This allows children to control the algorithm
-     * <p>
-     *
-     * @param me
-     */
-    protected abstract void adjustListForGet(MemoryElementDescriptor<K, V> me);
-
-    /**
      * This instructs the memory cache to remove the <i>numberToFree</i> according to its eviction
      * policy. For example, the LRUMemoryCache will remove the <i>numberToFree</i> least recently
      * used items. These will be spooled to disk if a disk auxiliary is available.
@@ -343,116 +270,61 @@
     }
 
     /**
-     * Removes an item from the cache. This method handles hierarchical removal. If the key is a
-     * String and ends with the CacheConstants.NAME_COMPONENT_DELIMITER, then all items with keys
-     * starting with the argument String will be removed.
-     * <p>
-     *
-     * @param key
-     * @return true if the removal was successful
-     * @throws IOException
+     * @see org.apache.commons.jcs.engine.memory.AbstractMemoryCache#get(java.lang.Object)
      */
     @Override
-    public boolean remove(K key) throws IOException
+    public ICacheElement<K, V> get(K key) throws IOException
     {
+        ICacheElement<K, V> ce = super.get(key);
+
         if (log.isDebugEnabled())
         {
-            log.debug("removing item for key: " + key);
+            verifyCache();
         }
 
-        boolean removed = false;
-
-        // handle partial removal
-        if (key instanceof String && ((String) key).endsWith(CacheConstants.NAME_COMPONENT_DELIMITER))
-        {
-            // remove all keys of the same name hierarchy.
-            for (Iterator<Map.Entry<K, MemoryElementDescriptor<K, V>>> itr = map.entrySet().iterator(); itr.hasNext();)
-            {
-                Map.Entry<K, MemoryElementDescriptor<K, V>> entry = itr.next();
-                K k = entry.getKey();
-
-                if (k instanceof String && ((String) k).startsWith(key.toString()))
-                {
-                    lock.lock();
-                    try
-                    {
-                        list.remove(entry.getValue());
-                        itr.remove();
-                        removed = true;
-                    }
-                    finally
-                    {
-                        lock.unlock();
-                    }
-                }
-            }
-        }
-        else if (key instanceof GroupAttrName && ((GroupAttrName<?>) key).attrName == null)
-        {
-            // remove all keys of the same name hierarchy.
-            for (Iterator<Map.Entry<K, MemoryElementDescriptor<K, V>>> itr = map.entrySet().iterator(); itr.hasNext();)
-            {
-                Map.Entry<K, MemoryElementDescriptor<K, V>> entry = itr.next();
-                K k = entry.getKey();
-
-                if (k instanceof GroupAttrName && ((GroupAttrName<?>) k).groupId.equals(((GroupAttrName<?>) key).groupId))
-                {
-                    lock.lock();
-                    try
-                    {
-                        list.remove(entry.getValue());
-                        itr.remove();
-                        removed = true;
-                    }
-                    finally
-                    {
-                        lock.unlock();
-                    }
-                }
-            }
-        }
-        else
-        {
-            // remove single item.
-            lock.lock();
-            try
-            {
-                MemoryElementDescriptor<K, V> me = map.remove(key);
-                if (me != null)
-                {
-                    list.remove(me);
-                    removed = true;
-                }
-            }
-            finally
-            {
-                lock.unlock();
-            }
-        }
-
-        return removed;
+        return ce;
     }
 
     /**
-     * Remove all of the elements from both the Map and the linked list implementation. Overrides
-     * base class.
+     * Adjust the list as needed for a get. This allows children to control the algorithm
      * <p>
      *
-     * @throws IOException
+     * @param me
+     */
+    protected abstract void adjustListForGet(MemoryElementDescriptor<K, V> me);
+
+    /**
+     * Update control structures after get
+     * (guarded by the lock)
+     *
+     * @param me the memory element descriptor
      */
     @Override
-    public void removeAll() throws IOException
+    protected void lockedGetElement(MemoryElementDescriptor<K, V> me)
     {
-        lock.lock();
-        try
-        {
-            list.removeAll();
-            map.clear();
-        }
-        finally
-        {
-            lock.unlock();
-        }
+        adjustListForGet(me);
+    }
+
+    /**
+     * Remove element from control structure
+     * (guarded by the lock)
+     *
+     * @param me the memory element descriptor
+     */
+    @Override
+    protected void lockedRemoveElement(MemoryElementDescriptor<K, V> me)
+    {
+        list.remove(me);
+    }
+
+    /**
+     * Removes all cached items from the cache control structures.
+     * (guarded by the lock)
+     */
+    @Override
+    protected void lockedRemoveAll()
+    {
+        list.removeAll();
     }
 
     // --------------------------- internal methods (linked list implementation)
@@ -631,17 +503,6 @@
     }
 
     /**
-     * Get an Array of the keys for all elements in the memory cache
-     *
-     * @return An Object[]
-     */
-    @Override
-    public Set<K> getKeySet()
-    {
-        return new LinkedHashSet<K>(map.keySet());
-    }
-
-    /**
      * This returns semi-structured information on the memory cache, such as the size, put count,
      * hit count, and miss count.
      * <p>
diff --git a/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/memory/AbstractMemoryCache.java b/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/memory/AbstractMemoryCache.java
index 87929fa..dc4bf5c 100644
--- a/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/memory/AbstractMemoryCache.java
+++ b/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/memory/AbstractMemoryCache.java
@@ -22,16 +22,19 @@
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 
-import org.apache.commons.jcs.engine.CacheStatus;
+import org.apache.commons.jcs.engine.CacheConstants;
 import org.apache.commons.jcs.engine.behavior.ICacheElement;
 import org.apache.commons.jcs.engine.behavior.ICompositeCacheAttributes;
 import org.apache.commons.jcs.engine.control.CompositeCache;
+import org.apache.commons.jcs.engine.control.group.GroupAttrName;
 import org.apache.commons.jcs.engine.memory.behavior.IMemoryCache;
 import org.apache.commons.jcs.engine.memory.util.MemoryElementDescriptor;
 import org.apache.commons.jcs.engine.stats.StatElement;
@@ -43,9 +46,6 @@
 
 /**
  * This base includes some common code for memory caches.
- * <p>
- * This keeps a static reference to a memory shrinker clock daemon. If this region is configured to
- * use the shrinker, the clock daemon will be setup to run the shrinker on this region.
  */
 public abstract class AbstractMemoryCache<K, V>
     implements IMemoryCache<K, V>
@@ -59,9 +59,6 @@
     /** The cache region this store is associated with */
     private CompositeCache<K, V> cache;
 
-    /** status */
-    private CacheStatus status;
-
     /** How many to spool at a time. */
     protected int chunkSize;
 
@@ -96,8 +93,6 @@
         this.cache = hub;
 
         this.map = createMap();
-
-        this.status = CacheStatus.ALIVE;
     }
 
     /**
@@ -109,28 +104,6 @@
     public abstract Map<K, MemoryElementDescriptor<K, V>> createMap();
 
     /**
-     * Removes an item from the cache
-     * <p>
-     * @param key Identifies item to be removed
-     * @return Description of the Return Value
-     * @throws IOException Description of the Exception
-     */
-    @Override
-    public abstract boolean remove( K key )
-        throws IOException;
-
-    /**
-     * Get an item from the cache
-     * <p>
-     * @param key Description of the Parameter
-     * @return Description of the Return Value
-     * @throws IOException Description of the Exception
-     */
-    @Override
-    public abstract ICacheElement<K, V> get( K key )
-        throws IOException;
-
-    /**
      * Gets multiple items from the cache based on the given set of keys.
      * <p>
      * @param keys
@@ -203,26 +176,32 @@
         throws IOException;
 
     /**
-     * Get a set of the keys for all elements in the memory cache
-     * <p>
-     * @return A set of the key type
-     */
-    @Override
-    public abstract Set<K> getKeySet();
-
-    /**
      * Removes all cached items from the cache.
      * <p>
      * @throws IOException
      */
     @Override
-    public void removeAll()
-        throws IOException
+    public void removeAll() throws IOException
     {
-        map.clear();
+        lock.lock();
+        try
+        {
+            lockedRemoveAll();
+            map.clear();
+        }
+        finally
+        {
+            lock.unlock();
+        }
     }
 
     /**
+     * Removes all cached items from the cache control structures.
+     * (guarded by the lock)
+     */
+    protected abstract void lockedRemoveAll();
+
+    /**
      * Prepares for shutdown. Reset statistics
      * <p>
      * @throws IOException
@@ -270,16 +249,6 @@
     }
 
     /**
-     * Returns the cache status.
-     * <p>
-     * @return The status value
-     */
-    public CacheStatus getStatus()
-    {
-        return this.status;
-    }
-
-    /**
      * Returns the cache (aka "region") name.
      * <p>
      * @return The cacheName value
@@ -351,4 +320,204 @@
     {
         return this.cache;
     }
+
+    /**
+     * Remove all keys of the same group hierarchy.
+     * @param key the key
+     * @return true if something has been removed
+     */
+    protected boolean removeByGroup(K key)
+    {
+        boolean removed = false;
+
+        // remove all keys of the same group hierarchy.
+        for (Iterator<Map.Entry<K, MemoryElementDescriptor<K, V>>> itr = map.entrySet().iterator(); itr.hasNext();)
+        {
+            Map.Entry<K, MemoryElementDescriptor<K, V>> entry = itr.next();
+            K k = entry.getKey();
+
+            if (k instanceof GroupAttrName && ((GroupAttrName<?>) k).groupId.equals(((GroupAttrName<?>) key).groupId))
+            {
+                lock.lock();
+                try
+                {
+                    itr.remove();
+                    lockedRemoveElement(entry.getValue());
+                    removed = true;
+                }
+                finally
+                {
+                    lock.unlock();
+                }
+            }
+        }
+
+        return removed;
+    }
+
+    /**
+     * Remove all keys of the same name hierarchy.
+     *
+     * @param key the key
+     * @return true if something has been removed
+     */
+    protected boolean removeByHierarchy(K key)
+    {
+        boolean removed = false;
+
+        // remove all keys of the same name hierarchy.
+        for (Iterator<Map.Entry<K, MemoryElementDescriptor<K, V>>> itr = map.entrySet().iterator(); itr.hasNext();)
+        {
+            Map.Entry<K, MemoryElementDescriptor<K, V>> entry = itr.next();
+            K k = entry.getKey();
+
+            if (k instanceof String && ((String) k).startsWith(key.toString()))
+            {
+                lock.lock();
+                try
+                {
+                    itr.remove();
+                    lockedRemoveElement(entry.getValue());
+                    removed = true;
+                }
+                finally
+                {
+                    lock.unlock();
+                }
+            }
+        }
+
+        return removed;
+    }
+
+    /**
+     * Remove element from control structure
+     * (guarded by the lock)
+     *
+     * @param me the memory element descriptor
+     */
+    protected abstract void lockedRemoveElement(MemoryElementDescriptor<K, V> me);
+
+    /**
+     * Removes an item from the cache. This method handles hierarchical removal. If the key is a
+     * String and ends with the CacheConstants.NAME_COMPONENT_DELIMITER, then all items with keys
+     * starting with the argument String will be removed.
+     * <p>
+     *
+     * @param key
+     * @return true if the removal was successful
+     * @throws IOException
+     */
+    @Override
+    public boolean remove(K key) throws IOException
+    {
+        if (log.isDebugEnabled())
+        {
+            log.debug("removing item for key: " + key);
+        }
+
+        boolean removed = false;
+
+        // handle partial removal
+        if (key instanceof String && ((String) key).endsWith(CacheConstants.NAME_COMPONENT_DELIMITER))
+        {
+            removed = removeByHierarchy(key);
+        }
+        else if (key instanceof GroupAttrName && ((GroupAttrName<?>) key).attrName == null)
+        {
+            removed = removeByGroup(key);
+        }
+        else
+        {
+            // remove single item.
+            lock.lock();
+            try
+            {
+                MemoryElementDescriptor<K, V> me = map.remove(key);
+                if (me != null)
+                {
+                    lockedRemoveElement(me);
+                    removed = true;
+                }
+            }
+            finally
+            {
+                lock.unlock();
+            }
+        }
+
+        return removed;
+    }
+
+    /**
+     * Get an Array of the keys for all elements in the memory cache
+     *
+     * @return An Object[]
+     */
+    @Override
+    public Set<K> getKeySet()
+    {
+        return new LinkedHashSet<K>(map.keySet());
+    }
+
+    /**
+     * Get an item from the cache.
+     * <p>
+     *
+     * @param key Identifies item to find
+     * @return ICacheElement&lt;K, V&gt; if found, else null
+     * @throws IOException
+     */
+    @Override
+    public ICacheElement<K, V> get(K key) throws IOException
+    {
+        ICacheElement<K, V> ce = null;
+
+        if (log.isDebugEnabled())
+        {
+            log.debug(getCacheName() + ": getting item for key " + key);
+        }
+
+        MemoryElementDescriptor<K, V> me = map.get(key);
+
+        if (me != null)
+        {
+            hitCnt.incrementAndGet();
+            ce = me.getCacheElement();
+
+            lock.lock();
+            try
+            {
+                lockedGetElement(me);
+            }
+            finally
+            {
+                lock.unlock();
+            }
+
+            if (log.isDebugEnabled())
+            {
+                log.debug(getCacheName() + ": MemoryCache hit for " + key);
+            }
+        }
+        else
+        {
+            missCnt.incrementAndGet();
+
+            if (log.isDebugEnabled())
+            {
+                log.debug(getCacheName() + ": MemoryCache miss for " + key);
+            }
+        }
+
+        return ce;
+    }
+
+    /**
+     * Update control structures after get
+     * (guarded by the lock)
+     *
+     * @param me the memory element descriptor
+     */
+    protected abstract void lockedGetElement(MemoryElementDescriptor<K, V> me);
 }
diff --git a/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/memory/lru/LHMLRUMemoryCache.java b/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/memory/lru/LHMLRUMemoryCache.java
index b6ff779..2679fb7 100644
--- a/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/memory/lru/LHMLRUMemoryCache.java
+++ b/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/memory/lru/LHMLRUMemoryCache.java
@@ -21,15 +21,10 @@
 
 import java.io.IOException;
 import java.util.Collections;
-import java.util.Iterator;
-import java.util.LinkedHashSet;
 import java.util.Map;
-import java.util.Set;
 
-import org.apache.commons.jcs.engine.CacheConstants;
 import org.apache.commons.jcs.engine.behavior.ICacheElement;
 import org.apache.commons.jcs.engine.control.CompositeCache;
-import org.apache.commons.jcs.engine.control.group.GroupAttrName;
 import org.apache.commons.jcs.engine.memory.AbstractMemoryCache;
 import org.apache.commons.jcs.engine.memory.util.MemoryElementDescriptor;
 import org.apache.commons.jcs.engine.stats.behavior.IStats;
@@ -83,124 +78,37 @@
     }
 
     /**
-     * Get an item from the cache
-     * <p>
-     * @param key Identifies item to find
-     * @return ICacheElement&lt;K, V&gt; if found, else null
-     * @throws IOException
+     * Update control structures after get
+     * (guarded by the lock)
+     *
+     * @param me the memory element descriptor
      */
     @Override
-    public ICacheElement<K, V> get( K key )
-        throws IOException
+    protected void lockedGetElement(MemoryElementDescriptor<K, V> me)
     {
-        if ( log.isDebugEnabled() )
-        {
-            log.debug( "getting item from cache " + getCacheName() + " for key " + key );
-        }
-
-        MemoryElementDescriptor<K, V> me = map.get( key );
-
-        if ( me != null )
-        {
-            hitCnt.incrementAndGet();
-            if ( log.isDebugEnabled() )
-            {
-                log.debug( getCacheName() + ": LHMLRUMemoryCache hit for " + key );
-            }
-            return me.getCacheElement();
-        }
-        else
-        {
-            missCnt.incrementAndGet();
-            if ( log.isDebugEnabled() )
-            {
-                log.debug( getCacheName() + ": LHMLRUMemoryCache miss for " + key );
-            }
-        }
-
-        return null;
+        // empty
     }
 
     /**
-     * Removes an item from the cache. This method handles hierarchical removal. If the key is a
-     * String and ends with the CacheConstants.NAME_COMPONENT_DELIMITER, then all items with keys
-     * starting with the argument String will be removed.
-     * <p>
-     * @param key
-     * @return true if removed
-     * @throws IOException
+     * Remove element from control structure
+     * (guarded by the lock)
+     *
+     * @param me the memory element descriptor
      */
     @Override
-    public boolean remove( K key )
-        throws IOException
+    protected void lockedRemoveElement(MemoryElementDescriptor<K, V> me)
     {
-        if ( log.isDebugEnabled() )
-        {
-            log.debug( "removing item for key: " + key );
-        }
-
-        boolean removed = false;
-
-        // handle partial removal
-        if ( key instanceof String && ( (String) key ).endsWith( CacheConstants.NAME_COMPONENT_DELIMITER ) )
-        {
-            // remove all keys of the same name hierarchy.
-            synchronized ( map )
-            {
-                for (Iterator<Map.Entry<K, MemoryElementDescriptor<K, V>>> itr = map.entrySet().iterator(); itr.hasNext(); )
-                {
-                    Map.Entry<K, MemoryElementDescriptor<K, V>> entry = itr.next();
-                    K k = entry.getKey();
-
-                    if ( k instanceof String && ( (String) k ).startsWith( key.toString() ) )
-                    {
-                        itr.remove();
-                        removed = true;
-                    }
-                }
-            }
-        }
-        else if ( key instanceof GroupAttrName && ((GroupAttrName<?>)key).attrName == null )
-        {
-            // remove all keys of the same name hierarchy.
-            synchronized ( map )
-            {
-                for (Iterator<Map.Entry<K, MemoryElementDescriptor<K, V>>> itr = map.entrySet().iterator(); itr.hasNext(); )
-                {
-                    Map.Entry<K, MemoryElementDescriptor<K, V>> entry = itr.next();
-                    K k = entry.getKey();
-
-                    if ( k instanceof GroupAttrName &&
-                        ((GroupAttrName<?>)k).groupId.equals(((GroupAttrName<?>)key).groupId) )
-                    {
-                        itr.remove();
-                        removed = true;
-                    }
-                }
-            }
-        }
-        else
-        {
-            // remove single item.
-            MemoryElementDescriptor<K, V> me = map.remove( key );
-            if ( me != null )
-            {
-                removed = true;
-            }
-        }
-
-        return removed;
+        // empty
     }
 
     /**
-     * Get an Array of the keys for all elements in the memory cache
-     * <p>
-     * @return An Object[]
+     * Removes all cached items from the cache control structures.
+     * (guarded by the lock)
      */
     @Override
-    public Set<K> getKeySet()
+    protected void lockedRemoveAll()
     {
-        return new LinkedHashSet<K>(map.keySet());
+        // empty
     }
 
     /**
diff --git a/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/memory/soft/SoftReferenceMemoryCache.java b/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/memory/soft/SoftReferenceMemoryCache.java
index 5108c66..b5c703b 100644
--- a/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/memory/soft/SoftReferenceMemoryCache.java
+++ b/commons-jcs-core/src/main/java/org/apache/commons/jcs/engine/memory/soft/SoftReferenceMemoryCache.java
@@ -22,7 +22,6 @@
 import java.io.IOException;
 import java.lang.ref.SoftReference;
 import java.util.HashSet;
-import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -30,11 +29,9 @@
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.LinkedBlockingQueue;
 
-import org.apache.commons.jcs.engine.CacheConstants;
 import org.apache.commons.jcs.engine.behavior.ICacheElement;
 import org.apache.commons.jcs.engine.behavior.ICompositeCacheAttributes;
 import org.apache.commons.jcs.engine.control.CompositeCache;
-import org.apache.commons.jcs.engine.control.group.GroupAttrName;
 import org.apache.commons.jcs.engine.memory.AbstractMemoryCache;
 import org.apache.commons.jcs.engine.memory.util.MemoryElementDescriptor;
 import org.apache.commons.jcs.engine.memory.util.SoftReferenceElementDescriptor;
@@ -147,107 +144,41 @@
     }
 
     /**
-     * Removes an item from the cache. This method handles hierarchical removal. If the key is a
-     * String and ends with the CacheConstants.NAME_COMPONENT_DELIMITER, then all items with keys
-     * starting with the argument String will be removed.
-     * <p>
+     * Update control structures after get
+     * (guarded by the lock)
      *
-     * @param key
-     * @return true if the removal was successful
-     * @throws IOException
+     * @param me the memory element descriptor
      */
     @Override
-    public boolean remove(K key) throws IOException
+    protected void lockedGetElement(MemoryElementDescriptor<K, V> me)
     {
-        if (log.isDebugEnabled())
-        {
-            log.debug("removing item for key: " + key);
-        }
+        ICacheElement<K, V> val = me.getCacheElement();
+        val.getElementAttributes().setLastAccessTimeNow();
 
-        boolean removed = false;
-
-        // handle partial removal
-        if (key instanceof String && ((String) key).endsWith(CacheConstants.NAME_COMPONENT_DELIMITER))
-        {
-            // remove all keys of the same name hierarchy.
-            for (Iterator<Map.Entry<K, MemoryElementDescriptor<K, V>>> itr = map.entrySet().iterator();
-                    itr.hasNext();)
-            {
-                Map.Entry<K, MemoryElementDescriptor<K, V>> entry = itr.next();
-                K k = entry.getKey();
-
-                if (k instanceof String && ((String) k).startsWith(key.toString()))
-                {
-                    lock.lock();
-                    try
-                    {
-                        strongReferences.remove(entry.getValue().getCacheElement());
-                        itr.remove();
-                        removed = true;
-                    }
-                    finally
-                    {
-                        lock.unlock();
-                    }
-                }
-            }
-        }
-        else if (key instanceof GroupAttrName && ((GroupAttrName<?>) key).attrName == null)
-        {
-            // remove all keys of the same name hierarchy.
-            for (Iterator<Map.Entry<K, MemoryElementDescriptor<K, V>>> itr = map.entrySet().iterator();
-                    itr.hasNext();)
-            {
-                Map.Entry<K, MemoryElementDescriptor<K, V>> entry = itr.next();
-                K k = entry.getKey();
-
-                if (k instanceof GroupAttrName && ((GroupAttrName<?>) k).groupId.equals(((GroupAttrName<?>) key).groupId))
-                {
-                    lock.lock();
-                    try
-                    {
-                        strongReferences.remove(entry.getValue().getCacheElement());
-                        itr.remove();
-                        removed = true;
-                    }
-                    finally
-                    {
-                        lock.unlock();
-                    }
-                }
-            }
-        }
-        else
-        {
-            // remove single item.
-            lock.lock();
-            try
-            {
-                MemoryElementDescriptor<K, V> me = map.remove(key);
-                if (me != null)
-                {
-                    strongReferences.remove(me.getCacheElement());
-                    removed = true;
-                }
-            }
-            finally
-            {
-                lock.unlock();
-            }
-        }
-
-        return removed;
+        // update the ordering of the strong references
+        strongReferences.add(val);
+        trimStrongReferences();
     }
 
     /**
-     * Removes all cached items from the cache.
-     * <p>
-     * @throws IOException
+     * Remove element from control structure
+     * (guarded by the lock)
+     *
+     * @param me the memory element descriptor
      */
     @Override
-    public void removeAll() throws IOException
+    protected void lockedRemoveElement(MemoryElementDescriptor<K, V> me)
     {
-        super.removeAll();
+        strongReferences.remove(me.getCacheElement());
+    }
+
+    /**
+     * Removes all cached items from the cache control structures.
+     * (guarded by the lock)
+     */
+    @Override
+    protected void lockedRemoveAll()
+    {
         strongReferences.clear();
     }
 
@@ -294,48 +225,6 @@
     }
 
     /**
-     * Get an item from the cache
-     * <p>
-     * @param key Description of the Parameter
-     * @return Description of the Return Value
-     * @throws IOException Description of the Exception
-     */
-    @Override
-    public ICacheElement<K, V> get(K key) throws IOException
-    {
-        ICacheElement<K, V> val = null;
-        lock.lock();
-
-        try
-        {
-            val = getQuiet(key);
-            if (val != null)
-            {
-                val.getElementAttributes().setLastAccessTimeNow();
-
-                // update the ordering of the strong references
-                strongReferences.add(val);
-                trimStrongReferences();
-            }
-        }
-        finally
-        {
-            lock.unlock();
-        }
-
-        if (val == null)
-        {
-            missCnt.incrementAndGet();
-        }
-        else
-        {
-            hitCnt.incrementAndGet();
-        }
-
-        return val;
-    }
-
-    /**
      * This can't be implemented.
      * <p>
      * @param numberToFree
diff --git a/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/discovery/UDPDiscoveryReceiver.java b/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/discovery/UDPDiscoveryReceiver.java
index e8f9cba..07a6687 100644
--- a/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/discovery/UDPDiscoveryReceiver.java
+++ b/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/discovery/UDPDiscoveryReceiver.java
@@ -25,14 +25,15 @@
 import java.net.DatagramPacket;
 import java.net.InetAddress;
 import java.net.MulticastSocket;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.ExecutorService;
 
 import org.apache.commons.jcs.engine.CacheInfo;
 import org.apache.commons.jcs.engine.behavior.IShutdownObserver;
 import org.apache.commons.jcs.io.ObjectInputStreamClassLoaderAware;
 import org.apache.commons.jcs.utils.discovery.UDPDiscoveryMessage.BroadcastType;
-import org.apache.commons.jcs.utils.threadpool.DaemonThreadFactory;
+import org.apache.commons.jcs.utils.threadpool.PoolConfiguration;
+import org.apache.commons.jcs.utils.threadpool.PoolConfiguration.WhenBlockedPolicy;
+import org.apache.commons.jcs.utils.threadpool.ThreadPoolManager;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
@@ -56,7 +57,7 @@
     private static final int maxPoolSize = 2;
 
     /** The processor */
-    private ThreadPoolExecutor pooledExecutor = null;
+    private ExecutorService pooledExecutor = null;
 
     /** number of messages received. For debugging and testing. */
     private int cnt = 0;
@@ -91,10 +92,9 @@
         this.multicastPort = multicastPort;
 
         // create a small thread pool to handle a barrage
-        pooledExecutor = (ThreadPoolExecutor)Executors.newFixedThreadPool(maxPoolSize,
-                new DaemonThreadFactory("JCS-UDPDiscoveryReceiver-", Thread.MIN_PRIORITY));
-        pooledExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardOldestPolicy());
-        //pooledExecutor.setMinimumPoolSize(1);
+        pooledExecutor = ThreadPoolManager.getInstance().createPool(
+        		new PoolConfiguration(false, 0, maxPoolSize, maxPoolSize, 0, WhenBlockedPolicy.DISCARDOLDEST, maxPoolSize), 
+        		"JCS-UDPDiscoveryReceiver-", Thread.MIN_PRIORITY);
 
         if ( log.isInfoEnabled() )
         {
diff --git a/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/struct/AbstractLRUMap.java b/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/struct/AbstractLRUMap.java
index c747f4c..9effd97 100644
--- a/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/struct/AbstractLRUMap.java
+++ b/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/struct/AbstractLRUMap.java
@@ -64,22 +64,20 @@
     private final DoubleLinkedList<LRUElementDescriptor<K, V>> list;
 
     /** Map where items are stored by key. */
-    private Map<K, LRUElementDescriptor<K, V>> map;
+    private final Map<K, LRUElementDescriptor<K, V>> map;
 
-    /** stats */
-    int hitCnt = 0;
-
-    /** stats */
-    int missCnt = 0;
-
-    /** stats */
-    int putCnt = 0;
-
-    /** make configurable */
-    private int chunkSize = 1;
-
+    /** lock to keep map and list synchronous */
     private final Lock lock = new ReentrantLock();
 
+    /** stats */
+    private long hitCnt = 0;
+
+    /** stats */
+    private long missCnt = 0;
+
+    /** stats */
+    private long putCnt = 0;
+
     /**
      * This creates an unbounded version. Setting the max objects will result in spooling on
      * subsequent puts.
@@ -196,7 +194,7 @@
     @Override
     public V get( Object key )
     {
-        V retVal = null;
+        V retVal;
 
         if ( log.isDebugEnabled() )
         {
@@ -205,22 +203,28 @@
 
         LRUElementDescriptor<K, V> me = map.get( key );
 
-        if ( me != null )
+        if ( me == null )
         {
-            hitCnt++;
-            if ( log.isDebugEnabled() )
-            {
-                log.debug( "LRUMap hit for " + key );
-            }
-
-            retVal = me.getPayload();
-
-            list.makeFirst( me );
+            missCnt++;
+            retVal = null;
         }
         else
         {
-            missCnt++;
-            log.debug( "LRUMap miss for " + key );
+            hitCnt++;
+            retVal = me.getPayload();
+            list.makeFirst( me );
+        }
+
+        if ( log.isDebugEnabled() )
+        {
+            if ( me == null )
+            {
+                log.debug( "LRUMap miss for " + key );
+            }
+            else
+            {
+                log.debug( "LRUMap hit for " + key );
+            }
         }
 
         // verifyCache();
@@ -238,20 +242,23 @@
     public V getQuiet( Object key )
     {
         V ce = null;
-
         LRUElementDescriptor<K, V> me = map.get( key );
+
         if ( me != null )
         {
-            if ( log.isDebugEnabled() )
+            ce = me.getPayload();
+        }
+
+        if ( log.isDebugEnabled() )
+        {
+            if ( me == null )
+            {
+                log.debug( "LRUMap quiet miss for " + key );
+            }
+            else
             {
                 log.debug( "LRUMap quiet hit for " + key );
             }
-
-            ce = me.getPayload();
-        }
-        else if ( log.isDebugEnabled() )
-        {
-            log.debug( "LRUMap quiet miss for " + key );
         }
 
         return ce;
@@ -300,17 +307,16 @@
         putCnt++;
 
         LRUElementDescriptor<K, V> old = null;
+        LRUElementDescriptor<K, V> me = new LRUElementDescriptor<K, V>(key, value);
+
         lock.lock();
         try
         {
-            // TODO address double synchronization of addFirst, use write lock
-            addFirst( key, value );
-            // this must be synchronized
-            LRUElementDescriptor<K, V> first = list.getFirst();
-            old = map.put(first.getKey(), first);
+            list.addFirst( me );
+            old = map.put(key, me);
 
             // If the node was the same as an existing node, remove it.
-            if ( old != null && first.getKey().equals(old.getKey()))
+            if ( old != null && key.equals(old.getKey()))
             {
                 list.remove( old );
             }
@@ -321,7 +327,6 @@
         }
 
         // If the element limit is reached, we need to spool
-
         if (shouldRemove())
         {
             if (log.isDebugEnabled())
@@ -332,7 +337,6 @@
             // The spool will put them in a disk event queue, so there is no
             // need to pre-queue the queuing. This would be a bit wasteful
             // and wouldn't save much time in this synchronous call.
-
             while ( shouldRemove() )
             {
                 lock.lock();
@@ -366,10 +370,10 @@
             {
                 log.debug( "update: After spool map size: " + map.size() );
             }
-            if ( map.size() != dumpCacheSize() )
+            if ( map.size() != list.size() )
             {
-                log.error("update: After spool, size mismatch: map.size() = " + map.size() + ", linked list size = "
-                        + dumpCacheSize());
+                log.error("update: After spool, size mismatch: map.size() = " + map.size() +
+                        ", linked list size = " + list.size());
             }
         }
 
@@ -382,37 +386,6 @@
 
     protected abstract boolean shouldRemove();
 
-
-    /**
-     * Adds a new node to the start of the link list.
-     * <p>
-     * @param key
-     * @param val The feature to be added to the First
-     */
-    private void addFirst(K key, V val)
-    {
-        lock.lock();
-        try
-        {
-            LRUElementDescriptor<K, V> me = new LRUElementDescriptor<K, V>(key, val);
-            list.addFirst( me );
-        }
-        finally
-        {
-            lock.unlock();
-        }
-    }
-
-    /**
-     * Returns the size of the list.
-     * <p>
-     * @return int
-     */
-    private int dumpCacheSize()
-    {
-        return list.size();
-    }
-
     /**
      * Dump the cache entries from first to list for debugging.
      */
@@ -458,8 +431,8 @@
         }
 
         boolean found = false;
-        log.debug( "verifycache: mapContains " + map.size() + " elements, linked list contains " + dumpCacheSize()
-            + " elements" );
+        log.debug( "verifycache: mapContains " + map.size() +
+                " elements, linked list contains " + list.size() + " elements" );
         log.debug( "verifycache: checking linked list by key " );
         for (LRUElementDescriptor<K, V> li = list.getFirst(); li != null; li = (LRUElementDescriptor<K, V>) li.next )
         {
@@ -537,37 +510,6 @@
     }
 
     /**
-     * Logs an error is an element that should be in the cache is not.
-     * <p>
-     * @param key
-     */
-    @SuppressWarnings("unchecked") // No generics for public fields
-    protected void verifyCache( Object key )
-    {
-        if ( !log.isDebugEnabled() )
-        {
-            return;
-        }
-
-        boolean found = false;
-
-        // go through the linked list looking for the key
-        for (LRUElementDescriptor<K, V> li = list.getFirst(); li != null; li = (LRUElementDescriptor<K, V>) li.next )
-        {
-            if ( li.getKey() == key )
-            {
-                found = true;
-                log.debug( "verifycache(key) key match: " + key );
-                break;
-            }
-        }
-        if ( !found )
-        {
-            log.error( "verifycache(key), couldn't find key! : " + key );
-        }
-    }
-
-    /**
      * This is called when an item is removed from the LRU. We just log some information.
      * <p>
      * Children can implement this method for special behavior.
@@ -584,24 +526,6 @@
     }
 
     /**
-     * The chunk size is the number of items to remove when the max is reached. By default it is 1.
-     * <p>
-     * @param chunkSize The chunkSize to set.
-     */
-    public void setChunkSize( int chunkSize )
-    {
-        this.chunkSize = chunkSize;
-    }
-
-    /**
-     * @return Returns the chunkSize.
-     */
-    public int getChunkSize()
-    {
-        return chunkSize;
-    }
-
-    /**
      * @return IStats
      */
     public IStats getStatistics()
@@ -613,9 +537,9 @@
 
         elems.add(new StatElement<Integer>( "List Size", Integer.valueOf(list.size()) ) );
         elems.add(new StatElement<Integer>( "Map Size", Integer.valueOf(map.size()) ) );
-        elems.add(new StatElement<Integer>( "Put Count", Integer.valueOf(putCnt) ) );
-        elems.add(new StatElement<Integer>( "Hit Count", Integer.valueOf(hitCnt) ) );
-        elems.add(new StatElement<Integer>( "Miss Count", Integer.valueOf(missCnt) ) );
+        elems.add(new StatElement<Long>( "Put Count", Long.valueOf(putCnt) ) );
+        elems.add(new StatElement<Long>( "Hit Count", Long.valueOf(hitCnt) ) );
+        elems.add(new StatElement<Long>( "Miss Count", Long.valueOf(missCnt) ) );
 
         stats.setStatElements( elems );
 
diff --git a/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/struct/LRUMap.java b/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/struct/LRUMap.java
index fa100b2..84ff231 100644
--- a/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/struct/LRUMap.java
+++ b/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/struct/LRUMap.java
@@ -19,8 +19,6 @@
  * under the License.
  */
 
-import java.util.concurrent.atomic.AtomicInteger;
-
 /**
  *
  * @author Wiktor Niesiobędzki
@@ -32,10 +30,8 @@
  */
 public class LRUMap<K, V> extends AbstractLRUMap<K, V>
 {
-
     /** if the max is less than 0, there is no limit! */
-    int maxObjects = -1;
-    AtomicInteger counter = new AtomicInteger(0);
+    private int maxObjects = -1;
 
     public LRUMap()
     {
@@ -49,7 +45,7 @@
      */
     public LRUMap(int maxObjects)
     {
-        super();
+        this();
         this.maxObjects = maxObjects;
     }
 
@@ -58,9 +54,4 @@
     {
         return maxObjects > 0 && this.size() > maxObjects;
     }
-
-    public Object getMaxCounter()
-    {
-        return maxObjects;
-    }
 }
diff --git a/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/threadpool/PoolConfiguration.java b/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/threadpool/PoolConfiguration.java
index 05f17e7..f4e886d 100644
--- a/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/threadpool/PoolConfiguration.java
+++ b/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/threadpool/PoolConfiguration.java
@@ -27,23 +27,46 @@
 public final class PoolConfiguration
     implements Cloneable
 {
+    /**
+     * DEFAULT SETTINGS
+     */
+    private static final boolean DEFAULT_USE_BOUNDARY = true;
+
+    /** Default queue size limit */
+    private static final int DEFAULT_BOUNDARY_SIZE = 2000;
+
+    /** Default max size */
+    private static final int DEFAULT_MAXIMUM_POOL_SIZE = 150;
+
+    /** Default min */
+    private static final int DEFAULT_MINIMUM_POOL_SIZE = Runtime.getRuntime().availableProcessors();
+
+    /** Default keep alive */
+    private static final int DEFAULT_KEEPALIVE_TIME = 1000 * 60 * 5;
+
+    /** Default when blocked */
+    private static final WhenBlockedPolicy DEFAULT_WHEN_BLOCKED_POLICY = WhenBlockedPolicy.RUN;
+
+    /** Default startup size */
+    private static final int DEFAULT_STARTUP_SIZE = DEFAULT_MINIMUM_POOL_SIZE;
+
     /** Should we bound the queue */
-    private boolean useBoundary = true;
+    private boolean useBoundary = DEFAULT_USE_BOUNDARY;
 
     /** If the queue is bounded, how big can it get */
-    private int boundarySize = 2000;
+    private int boundarySize = DEFAULT_BOUNDARY_SIZE;
 
     /** only has meaning if a boundary is used */
-    private int maximumPoolSize = 150;
+    private int maximumPoolSize = DEFAULT_MAXIMUM_POOL_SIZE;
 
     /**
      * the exact number that will be used in a boundless queue. If the queue has a boundary, more
      * will be created if the queue fills.
      */
-    private int minimumPoolSize = 4;
+    private int minimumPoolSize = DEFAULT_MINIMUM_POOL_SIZE;
 
     /** How long idle threads above the minimum should be kept alive. */
-    private int keepAliveTime = 1000 * 60 * 5;
+    private int keepAliveTime = DEFAULT_KEEPALIVE_TIME;
 
     public enum WhenBlockedPolicy {
         /** abort when queue is full and max threads is reached. */
@@ -63,10 +86,10 @@
     }
 
     /** should be ABORT, BLOCK, RUN, WAIT, DISCARDOLDEST, */
-    private WhenBlockedPolicy whenBlockedPolicy = WhenBlockedPolicy.RUN;
+    private WhenBlockedPolicy whenBlockedPolicy = DEFAULT_WHEN_BLOCKED_POLICY;
 
     /** The number of threads to create on startup */
-    private int startUpSize = 4;
+    private int startUpSize = DEFAULT_MINIMUM_POOL_SIZE;
 
     /**
      * @param useBoundary The useBoundary to set.
@@ -89,7 +112,9 @@
      */
     public PoolConfiguration()
     {
-        // nop
+        this( DEFAULT_USE_BOUNDARY, DEFAULT_BOUNDARY_SIZE, DEFAULT_MAXIMUM_POOL_SIZE,
+              DEFAULT_MINIMUM_POOL_SIZE, DEFAULT_KEEPALIVE_TIME,
+              DEFAULT_WHEN_BLOCKED_POLICY, DEFAULT_STARTUP_SIZE );
     }
 
     /**
diff --git a/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/threadpool/ThreadPoolManager.java b/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/threadpool/ThreadPoolManager.java
index 0c9346c..93ca842 100644
--- a/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/threadpool/ThreadPoolManager.java
+++ b/commons-jcs-core/src/main/java/org/apache/commons/jcs/utils/threadpool/ThreadPoolManager.java
@@ -23,11 +23,14 @@
 import java.util.Properties;
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 
-import org.apache.commons.jcs.utils.threadpool.PoolConfiguration.WhenBlockedPolicy;
+import org.apache.commons.jcs.utils.config.PropertySetter;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
@@ -39,30 +42,12 @@
  * This manager forces you to use a bounded queue. By default it uses the current thread for
  * execution when the buffer is full and no free threads can be created.
  * <p>
- * You can specify the props file to use or pass in a properties object prior to configuration. By
- * default it looks for configuration information in thread_pool.properties.
+ * You can specify the props file to use or pass in a properties object prior to configuration.
  * <p>
  * If set, the Properties object will take precedence.
  * <p>
- * If a value is not set for a particular pool, the hard coded defaults will be used.
- *
- * <pre>
- * int boundarySize_DEFAULT = 2000;
- *
- * int maximumPoolSize_DEFAULT = 150;
- *
- * int minimumPoolSize_DEFAULT = 4;
- *
- * int keepAliveTime_DEFAULT = 1000 * 60 * 5;
- *
- * boolean abortWhenBlocked = false;
- *
- * String whenBlockedPolicy_DEFAULT = IPoolConfiguration.POLICY_RUN;
- *
- * int startUpSize_DEFAULT = 4;
- * </pre>
- *
- * You can configure default settings by specifying a default pool in the properties, ie "cache.ccf"
+ * If a value is not set for a particular pool, the hard coded defaults in <code>PoolConfiguration</code> will be used.
+ * You can configure default settings by specifying <code>thread_pool.default</code> in the properties, ie "cache.ccf"
  * <p>
  * @author Aaron Smuts
  */
@@ -71,31 +56,8 @@
     /** The logger */
     private static final Log log = LogFactory.getLog( ThreadPoolManager.class );
 
-    /**
-     * DEFAULT SETTINGS, these are not final since they can be set via the properties file or object
-     */
-    private static boolean useBoundary_DEFAULT = true;
-
-    /** Default queue size limit */
-    private static int boundarySize_DEFAULT = 2000;
-
-    /** Default max size */
-    private static int maximumPoolSize_DEFAULT = 150;
-
-    /** Default min */
-    private static int minimumPoolSize_DEFAULT = 4;
-
-    /** Default keep alive */
-    private static int keepAliveTime_DEFAULT = 1000 * 60 * 5;
-
-    /** Default when blocked */
-    private static WhenBlockedPolicy whenBlockedPolicy_DEFAULT = WhenBlockedPolicy.RUN;
-
-    /** Default startup size */
-    private static int startUpSize_DEFAULT = 4;
-
     /** The default config, created using property defaults if present, else those above. */
-    private static PoolConfiguration defaultConfig;
+    private PoolConfiguration defaultConfig;
 
     /** the root property name */
     private static final String PROP_NAME_ROOT = "thread_pool";
@@ -103,7 +65,13 @@
     /** default property file name */
     private static final String DEFAULT_PROP_NAME_ROOT = "thread_pool.default";
 
-    /**
+    /** the scheduler root property name */
+    private static final String PROP_NAME_SCHEDULER_ROOT = "scheduler_pool";
+
+    /** default scheduler property file name */
+    private static final String DEFAULT_PROP_NAME_SCHEDULER_ROOT = "scheduler_pool.default";
+
+   /**
      * You can specify the properties to be used to configure the thread pool. Setting this post
      * initialization will have no effect.
      */
@@ -113,24 +81,42 @@
     private static ThreadPoolManager INSTANCE = null;
 
     /** Map of names to pools. */
-    private ConcurrentHashMap<String, ThreadPoolExecutor> pools;
+    private ConcurrentHashMap<String, ExecutorService> pools;
+
+    /** Map of names to scheduler pools. */
+    private ConcurrentHashMap<String, ScheduledExecutorService> schedulerPools;
 
     /**
      * No instances please. This is a singleton.
      */
     private ThreadPoolManager()
     {
-        this.pools = new ConcurrentHashMap<String, ThreadPoolExecutor>();
+        this.pools = new ConcurrentHashMap<String, ExecutorService>();
+        this.schedulerPools = new ConcurrentHashMap<String, ScheduledExecutorService>();
         configure();
     }
 
     /**
      * Creates a pool based on the configuration info.
      * <p>
-     * @param config
-     * @return A ThreadPoll wrapper
+     * @param config the pool configuration
+     * @param threadNamePrefix prefix for the thread names of the pool
+     * @return A ThreadPool wrapper
      */
-    private ThreadPoolExecutor createPool( PoolConfiguration config )
+    public ExecutorService createPool( PoolConfiguration config, String threadNamePrefix)
+    {
+    	return createPool(config, threadNamePrefix, Thread.NORM_PRIORITY);
+    }
+    
+    /**
+     * Creates a pool based on the configuration info.
+     * <p>
+     * @param config the pool configuration
+     * @param threadNamePrefix prefix for the thread names of the pool
+     * @param threadPriority the priority of the created threads
+     * @return A ThreadPool wrapper
+     */
+    public ExecutorService createPool( PoolConfiguration config, String threadNamePrefix, int threadPriority )
     {
         BlockingQueue<Runnable> queue = null;
         if ( config.isUseBoundary() )
@@ -157,7 +143,7 @@
             config.getKeepAliveTime(),
             TimeUnit.MILLISECONDS,
             queue,
-            new DaemonThreadFactory("JCS-ThreadPoolManager-"));
+            new DaemonThreadFactory(threadNamePrefix, threadPriority));
 
         // when blocked policy
         switch (config.getWhenBlockedPolicy())
@@ -187,6 +173,23 @@
     }
 
     /**
+     * Creates a scheduler pool based on the configuration info.
+     * <p>
+     * @param config the pool configuration
+     * @param threadNamePrefix prefix for the thread names of the pool
+     * @param threadPriority the priority of the created threads
+     * @return A ScheduledExecutorService
+     */
+    public ScheduledExecutorService createSchedulerPool( PoolConfiguration config, String threadNamePrefix, int threadPriority )
+    {
+    	ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(
+    			config.getMaximumPoolSize(), 
+    			new DaemonThreadFactory(threadNamePrefix, threadPriority));
+
+        return scheduler;
+    }
+    
+    /**
      * Returns a configured instance of the ThreadPoolManger To specify a configuration file or
      * Properties object to use call the appropriate setter prior to calling getInstance.
      * <p>
@@ -208,34 +211,46 @@
     {
         if ( INSTANCE != null )
         {
-            for ( String poolName : INSTANCE.getPoolNames())
+            for ( ExecutorService pool : INSTANCE.pools.values() )
             {
                 try
                 {
-                    INSTANCE.getPool(poolName).shutdownNow();
+                    pool.shutdownNow();
                 }
                 catch (Throwable t)
                 {
-                    log.warn("Failed to close pool " + poolName, t);
+                    log.warn("Failed to close pool " + pool, t);
                 }
             }
-
+            
+            for ( ScheduledExecutorService pool : INSTANCE.schedulerPools.values() )
+            {
+                try
+                {
+                    pool.shutdownNow();
+                }
+                catch (Throwable t)
+                {
+                    log.warn("Failed to close pool " + pool, t);
+                }
+            }
+            
             INSTANCE = null;
         }
     }
 
     /**
-     * Returns a pool by name. If a pool by this name does not exist in the configuration file or
+     * Returns an executor service by name. If a service by this name does not exist in the configuration file or
      * properties, one will be created using the default values.
      * <p>
-     * Pools are lazily created.
+     * Services are lazily created.
      * <p>
      * @param name
-     * @return The thread pool configured for the name.
+     * @return The executor service configured for the name.
      */
-    public ThreadPoolExecutor getPool( String name )
+    public ExecutorService getExecutorService( String name )
     {
-        ThreadPoolExecutor pool = pools.get( name );
+    	ExecutorService pool = pools.get( name );
 
         if ( pool == null )
         {
@@ -245,12 +260,17 @@
             }
 
             PoolConfiguration config = loadConfig( PROP_NAME_ROOT + "." + name );
-            pool = createPool( config );
-            ThreadPoolExecutor _pool = pools.putIfAbsent( name, pool );
-            if (_pool != null)
+            ExecutorService _pool = createPool( config, "JCS-ThreadPoolManager-" + name + "-" );
+            pool = pools.putIfAbsent( name, _pool );
+            if (pool == null)
             {
                 pool = _pool;
             }
+            else
+            {
+            	// already created in another thread
+            	_pool.shutdownNow();
+            }
 
             if ( log.isDebugEnabled() )
             {
@@ -260,6 +280,61 @@
 
         return pool;
     }
+    
+    /**
+     * Returns a pool by name. If a pool by this name does not exist in the configuration file or
+     * properties, one will be created using the default values.
+     * <p>
+     * Pools are lazily created.
+     * <p>
+     * @param name
+     * @return The thread pool configured for the name.
+     * 
+     * @deprecated Use getExecutorService() instead
+     */
+    @Deprecated
+	public ThreadPoolExecutor getPool( String name )
+    {
+    	return (ThreadPoolExecutor) getExecutorService(name);
+    }
+
+    /**
+     * Returns a scheduler pool by name. If a pool by this name does not exist in the configuration file or
+     * properties, one will be created using the default values.
+     * <p>
+     * Pools are lazily created.
+     * <p>
+     * @param name
+     * @return The scheduler pool configured for the name.
+     */
+    public ScheduledExecutorService getSchedulerPool( String name )
+    {
+    	ScheduledExecutorService pool = schedulerPools.get( name );
+
+        if ( pool == null )
+        {
+            if ( log.isDebugEnabled() )
+            {
+                log.debug( "Creating scheduler pool for name [" + name + "]" );
+            }
+
+            PoolConfiguration defaultSchedulerConfig = loadConfig( DEFAULT_PROP_NAME_SCHEDULER_ROOT );
+            PoolConfiguration config = loadConfig( PROP_NAME_SCHEDULER_ROOT + "." + name, defaultSchedulerConfig );
+            ScheduledExecutorService _pool = createSchedulerPool( config, "JCS-ThreadPoolManager-" + name + "-", Thread.NORM_PRIORITY );
+            pool = schedulerPools.putIfAbsent( name, _pool );
+            if (pool == null)
+            {
+                pool = _pool;
+            }
+            else
+            {
+            	// already created in another thread
+            	_pool.shutdownNow();
+            }
+        }
+
+        return pool;
+    }
 
     /**
      * Returns the names of all configured pools.
@@ -285,7 +360,7 @@
     /**
      * Initialize the ThreadPoolManager and create all the pools defined in the configuration.
      */
-    private static void configure()
+    private void configure()
     {
         if ( log.isDebugEnabled() )
         {
@@ -300,88 +375,36 @@
 
         // set intial default and then override if new
         // settings are available
-        defaultConfig = new PoolConfiguration( useBoundary_DEFAULT, boundarySize_DEFAULT, maximumPoolSize_DEFAULT,
-                                               minimumPoolSize_DEFAULT, keepAliveTime_DEFAULT,
-                                               whenBlockedPolicy_DEFAULT, startUpSize_DEFAULT );
-
+        defaultConfig = new PoolConfiguration();
         defaultConfig = loadConfig( DEFAULT_PROP_NAME_ROOT );
     }
 
     /**
-     * Configures the default PoolConfiguration settings.
+     * Configures the PoolConfiguration settings.
      * <p>
-     * @param root
+     * @param root the configuration key prefix
      * @return PoolConfiguration
      */
-    private static PoolConfiguration loadConfig( String root )
+    private PoolConfiguration loadConfig( String root )
     {
-        PoolConfiguration config = defaultConfig.clone();
+    	return loadConfig(root, defaultConfig);
+    }
+    
+    /**
+     * Configures the PoolConfiguration settings.
+     * <p>
+     * @param root the configuration key prefix
+     * @param defaultPoolConfiguration the default configuration
+     * @return PoolConfiguration
+     */
+    private PoolConfiguration loadConfig( String root, PoolConfiguration defaultPoolConfiguration )
+    {
+        PoolConfiguration config = defaultPoolConfiguration.clone();
+        PropertySetter.setProperties( config, props, root + "." );
 
-        try
+        if ( log.isDebugEnabled() )
         {
-            config.setUseBoundary( Boolean.parseBoolean( props.getProperty( root + ".useBoundary", "false" ) ) );
-        }
-        catch ( NumberFormatException nfe )
-        {
-            log.error( "useBoundary not a boolean.", nfe );
-        }
-
-        // load default if they exist
-        try
-        {
-            config.setBoundarySize( Integer.parseInt( props.getProperty( root + ".boundarySize", "2000" ) ) );
-        }
-        catch ( NumberFormatException nfe )
-        {
-            log.error( "boundarySize not a number.", nfe );
-        }
-
-        // maximum pool size
-        try
-        {
-            config.setMaximumPoolSize( Integer.parseInt( props.getProperty( root + ".maximumPoolSize", "150" ) ) );
-        }
-        catch ( NumberFormatException nfe )
-        {
-            log.error( "maximumPoolSize not a number.", nfe );
-        }
-
-        // minimum pool size
-        try
-        {
-            config.setMinimumPoolSize( Integer.parseInt( props.getProperty( root + ".minimumPoolSize", "4" ) ) );
-        }
-        catch ( NumberFormatException nfe )
-        {
-            log.error( "minimumPoolSize not a number.", nfe );
-        }
-
-        // keep alive
-        try
-        {
-            config.setKeepAliveTime( Integer.parseInt( props.getProperty( root + ".keepAliveTime", "300000" ) ) );
-        }
-        catch ( NumberFormatException nfe )
-        {
-            log.error( "keepAliveTime not a number.", nfe );
-        }
-
-        // when blocked
-        config.setWhenBlockedPolicy( props.getProperty( root + ".whenBlockedPolicy", "RUN" ) );
-
-        // startupsize
-        try
-        {
-            config.setStartUpSize( Integer.parseInt( props.getProperty( root + ".startUpSize", "4" ) ) );
-        }
-        catch ( NumberFormatException nfe )
-        {
-            log.error( "startUpSize not a number.", nfe );
-        }
-
-        if ( log.isInfoEnabled() )
-        {
-            log.info( root + " PoolConfiguration = " + config );
+            log.debug( root + " PoolConfiguration = " + config );
         }
 
         return config;
diff --git a/commons-jcs-core/src/test/java/org/apache/commons/jcs/auxiliary/disk/indexed/IndexedDiskCacheOptimizationUnitTest.java b/commons-jcs-core/src/test/java/org/apache/commons/jcs/auxiliary/disk/indexed/IndexedDiskCacheOptimizationUnitTest.java
index 77df909..8317505 100644
--- a/commons-jcs-core/src/test/java/org/apache/commons/jcs/auxiliary/disk/indexed/IndexedDiskCacheOptimizationUnitTest.java
+++ b/commons-jcs-core/src/test/java/org/apache/commons/jcs/auxiliary/disk/indexed/IndexedDiskCacheOptimizationUnitTest.java
@@ -65,8 +65,8 @@
 
         Thread.sleep( 1000 );
         long sizeBeforeRemove = disk.getDataFileSize();
-        System.out.println( "file sizeBeforeRemove " + sizeBeforeRemove );
-        System.out.println( "totalSize inserted " + DiskTestObjectUtil.totalSize( elements, numberToInsert ) );
+        // System.out.println( "file sizeBeforeRemove " + sizeBeforeRemove );
+        // System.out.println( "totalSize inserted " + DiskTestObjectUtil.totalSize( elements, numberToInsert ) );
 
         // DO WORK
         for ( int i = 0; i < removeCount; i++ )
diff --git a/commons-jcs-core/src/test/java/org/apache/commons/jcs/auxiliary/remote/RemoteCacheNoWaitUnitTest.java b/commons-jcs-core/src/test/java/org/apache/commons/jcs/auxiliary/remote/RemoteCacheNoWaitUnitTest.java
index fe671ae..231841a 100644
--- a/commons-jcs-core/src/test/java/org/apache/commons/jcs/auxiliary/remote/RemoteCacheNoWaitUnitTest.java
+++ b/commons-jcs-core/src/test/java/org/apache/commons/jcs/auxiliary/remote/RemoteCacheNoWaitUnitTest.java
@@ -1,5 +1,16 @@
 package org.apache.commons.jcs.auxiliary.remote;
 
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.commons.jcs.engine.CacheElement;
+import org.apache.commons.jcs.engine.CacheStatus;
+import org.apache.commons.jcs.engine.behavior.ICacheElement;
+import org.apache.commons.jcs.engine.behavior.ICacheEventQueue;
+import org.apache.commons.jcs.utils.timing.SleepUtil;
+
 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
@@ -20,16 +31,6 @@
  */
 
 import junit.framework.TestCase;
-import org.apache.commons.jcs.engine.CacheElement;
-import org.apache.commons.jcs.engine.CacheStatus;
-import org.apache.commons.jcs.engine.behavior.ICacheElement;
-import org.apache.commons.jcs.engine.behavior.ICacheEventQueue;
-import org.apache.commons.jcs.utils.timing.SleepUtil;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
 
 /**
  * Unit tests for the remote cache no wait. The no wait manages a queue on top of the client.
@@ -198,7 +199,7 @@
         // DO WORK
         noWait.update( element );
         SleepUtil.sleepAtLeast( 10 );
-        ICacheEventQueue<String, String> originalQueue = noWait.getCacheEventQueue();
+        // ICacheEventQueue<String, String> originalQueue = noWait.getCacheEventQueue();
 
         noWait.fixCache( service );
 
@@ -208,7 +209,7 @@
 
         // VERIFY
         assertEquals( "Wrong status", service, client.fixed );
-        assertFalse( "Original queue should not alive", originalQueue.isAlive() );
+        // assertFalse( "Original queue should not alive", originalQueue.isAlive() );
         assertTrue( "New queue should be alive." + newQueue, newQueue.isAlive() );
     }
 }
diff --git a/commons-jcs-core/src/test/java/org/apache/commons/jcs/engine/CacheEventQueueFactoryUnitTest.java b/commons-jcs-core/src/test/java/org/apache/commons/jcs/engine/CacheEventQueueFactoryUnitTest.java
index 3925b63..60b72f3 100644
--- a/commons-jcs-core/src/test/java/org/apache/commons/jcs/engine/CacheEventQueueFactoryUnitTest.java
+++ b/commons-jcs-core/src/test/java/org/apache/commons/jcs/engine/CacheEventQueueFactoryUnitTest.java
@@ -1,5 +1,10 @@
 package org.apache.commons.jcs.engine;
 
+import org.apache.commons.jcs.auxiliary.remote.MockRemoteCacheListener;
+import org.apache.commons.jcs.engine.behavior.ICacheEventQueue;
+import org.apache.commons.jcs.engine.behavior.ICacheEventQueue.QueueType;
+import org.apache.commons.jcs.engine.behavior.ICacheListener;
+
 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
@@ -20,10 +25,6 @@
  */
 
 import junit.framework.TestCase;
-import org.apache.commons.jcs.auxiliary.remote.MockRemoteCacheListener;
-import org.apache.commons.jcs.engine.behavior.ICacheEventQueue;
-import org.apache.commons.jcs.engine.behavior.ICacheEventQueue.QueueType;
-import org.apache.commons.jcs.engine.behavior.ICacheListener;
 
 /** Unit tests for the CacheEventQueueFactory */
 public class CacheEventQueueFactoryUnitTest
@@ -44,7 +45,7 @@
 
         // VERIFY
         assertNotNull( "Should have a result", result );
-        assertTrue( "Wrong type", result instanceof CacheEventQueue );
+        assertTrue( "Wrong type", result.getQueueType() == QueueType.SINGLE );
     }
 
     /** Test create */
@@ -62,6 +63,6 @@
 
         // VERIFY
         assertNotNull( "Should have a result", result );
-        assertTrue( "Wrong type", result instanceof PooledCacheEventQueue );
+        assertTrue( "Wrong type", result.getQueueType() == QueueType.POOLED );
     }
 }
diff --git a/commons-jcs-core/src/test/java/org/apache/commons/jcs/engine/EventQueueConcurrentLoadTest.java b/commons-jcs-core/src/test/java/org/apache/commons/jcs/engine/EventQueueConcurrentLoadTest.java
index 8aa4bb8..799ebf4 100644
--- a/commons-jcs-core/src/test/java/org/apache/commons/jcs/engine/EventQueueConcurrentLoadTest.java
+++ b/commons-jcs-core/src/test/java/org/apache/commons/jcs/engine/EventQueueConcurrentLoadTest.java
@@ -21,13 +21,13 @@
 
 import java.io.IOException;
 
+import org.apache.commons.jcs.engine.behavior.ICacheElement;
+import org.apache.commons.jcs.engine.behavior.ICacheListener;
+
 import junit.extensions.ActiveTestSuite;
 import junit.framework.Test;
 import junit.framework.TestCase;
 
-import org.apache.commons.jcs.engine.behavior.ICacheElement;
-import org.apache.commons.jcs.engine.behavior.ICacheListener;
-
 /**
  * This test case is designed to makes sure there are no deadlocks in the event queue. The time to
  * live should be set to a very short interval to make a deadlock more likely.
@@ -109,16 +109,6 @@
             }
         } );
 
-        suite.addTest( new EventQueueConcurrentLoadTest( "testStopProcessing1" )
-        {
-            @Override
-            public void runTest()
-                throws Exception
-            {
-                this.runStopProcessingTest();
-            }
-        } );
-
         suite.addTest( new EventQueueConcurrentLoadTest( "testRunPutTest4" )
         {
             @Override
@@ -139,16 +129,6 @@
             }
         } );
 
-        suite.addTest( new EventQueueConcurrentLoadTest( "testStopProcessing2" )
-        {
-            @Override
-            public void runTest()
-                throws Exception
-            {
-                this.runStopProcessingTest();
-            }
-        } );
-
         suite.addTest( new EventQueueConcurrentLoadTest( "testRunPutDelayTest" )
         {
             @Override
@@ -222,16 +202,6 @@
     }
 
     /**
-     * Add remove events to the event queue.
-     * @throws Exception
-     */
-    public void runStopProcessingTest()
-        throws Exception
-    {
-        queue.stopProcessing();
-    }
-
-    /**
      * Test putting and a delay. Waits until queue is empty to start.
      * @param end
      * @param expectedPutCount
diff --git a/commons-jcs-core/src/test/java/org/apache/commons/jcs/utils/struct/LRUMapConcurrentUnitTest.java b/commons-jcs-core/src/test/java/org/apache/commons/jcs/utils/struct/LRUMapConcurrentUnitTest.java
index 09b6005..6ce5625 100644
--- a/commons-jcs-core/src/test/java/org/apache/commons/jcs/utils/struct/LRUMapConcurrentUnitTest.java
+++ b/commons-jcs-core/src/test/java/org/apache/commons/jcs/utils/struct/LRUMapConcurrentUnitTest.java
@@ -1,5 +1,7 @@
 package org.apache.commons.jcs.utils.struct;
 
+import java.util.Iterator;
+
 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
@@ -23,8 +25,6 @@
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
 
-import java.util.Iterator;
-
 /**
  * Tests the LRUMap
  *
@@ -150,7 +150,6 @@
     {
         int total = 10;
         LRUMap<String, String> map = new LRUMap<String, String>( total );
-        map.setChunkSize( 1 );
 
         // put the max in
         for ( int i = 0; i < total; i++ )
@@ -189,7 +188,6 @@
     {
         int total = 10000;
         LRUMap<String, String> map = new LRUMap<String, String>( total );
-        map.setChunkSize( 1 );
 
         // put the max in
         for ( int i = 0; i < total * 2; i++ )
@@ -201,7 +199,6 @@
         for ( int i = total - 1; i >= 0; i-- )
         {
             assertNull( map.get( i + ":key" ) );
-
         }
 
         // get the total to total *2 items out, these should be found.
@@ -212,7 +209,6 @@
         }
 
 //        System.out.println( map.getStatistics() );
-
     }
 
     /**
diff --git a/commons-jcs-core/src/test/java/org/apache/commons/jcs/utils/struct/LRUMapPerformanceTest.java b/commons-jcs-core/src/test/java/org/apache/commons/jcs/utils/struct/LRUMapPerformanceTest.java
index bbf851f..e11d7ab 100644
--- a/commons-jcs-core/src/test/java/org/apache/commons/jcs/utils/struct/LRUMapPerformanceTest.java
+++ b/commons-jcs-core/src/test/java/org/apache/commons/jcs/utils/struct/LRUMapPerformanceTest.java
@@ -1,5 +1,9 @@
 package org.apache.commons.jcs.utils.struct;
 
+import java.util.Map;
+
+import org.apache.commons.jcs.JCSvsHashtablePerformanceTest;
+
 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
@@ -22,9 +26,6 @@
 import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
-import org.apache.commons.jcs.JCSvsHashtablePerformanceTest;
-
-import java.util.Map;
 
 /**
  * This ensures that the jcs version of the LRU map is as fast as the commons
@@ -106,7 +107,7 @@
 
         try
         {
-            Map<String, String> cache = new LRUMap<String, String>( tries );
+            LRUMap<String, String> cache = new LRUMap<String, String>( tries );
 
             for ( int j = 0; j < loops; j++ )
             {
@@ -134,9 +135,12 @@
                 System.out.println( name + " get time for " + tries + " = " + time + "; millis per = " + tPer );
 
                 ///////////////////////////////////////////////////////////////
-                cache2Name = "LRUMapJCS (commons)";
+                cache2Name = "LRUMap (commons)";
                 //or LRUMapJCS
                 Map<String, String> cache2 = new org.apache.commons.collections4.map.LRUMap<String, String>( tries );
+//                Map<String, String> cache2 = new ConcurrentLinkedHashMap.Builder<String, String>()
+//                        .maximumWeightedCapacity( tries )
+//                        .build();
                 //cache2Name = "Hashtable";
                 //Hashtable cache2 = new Hashtable();
                 start = System.currentTimeMillis();
diff --git a/commons-jcs-core/src/test/java/org/apache/commons/jcs/utils/threadpool/ThreadPoolManagerUnitTest.java b/commons-jcs-core/src/test/java/org/apache/commons/jcs/utils/threadpool/ThreadPoolManagerUnitTest.java
index e2210a1..1c89cc5 100644
--- a/commons-jcs-core/src/test/java/org/apache/commons/jcs/utils/threadpool/ThreadPoolManagerUnitTest.java
+++ b/commons-jcs-core/src/test/java/org/apache/commons/jcs/utils/threadpool/ThreadPoolManagerUnitTest.java
@@ -21,12 +21,14 @@
 
 import java.util.ArrayList;
 import java.util.Properties;
+import java.util.concurrent.RejectedExecutionHandler;
 import java.util.concurrent.ThreadPoolExecutor;
-
-import junit.framework.TestCase;
+import java.util.concurrent.TimeUnit;
 
 import org.apache.commons.jcs.utils.props.PropertyLoader;
 
+import junit.framework.TestCase;
+
 /**
  * Verify that the manager can create pools as intended by the default and
  * specified file names.
@@ -63,6 +65,39 @@
     }
 
     /**
+     * Make sure it can load a certain configuration
+     */
+    public void testSpecialConfig()
+    {
+        Properties props = PropertyLoader.loadProperties( "thread_pool.properties" );
+        ThreadPoolManager.setProps( props );
+        ThreadPoolManager mgr = ThreadPoolManager.getInstance();
+        assertNotNull( mgr );
+
+        ThreadPoolExecutor pool = mgr.getPool( "aborttest" );
+        assertNotNull( pool );
+
+        int poolSize = pool.getCorePoolSize();
+        int expectedPoolSize = Integer.parseInt( props.getProperty( "thread_pool.aborttest.startUpSize" ) );
+        assertEquals( expectedPoolSize, poolSize);
+
+        int minPoolSize = pool.getPoolSize();
+        int expectedMinPoolSize = Integer.parseInt( props.getProperty( "thread_pool.aborttest.minimumPoolSize" ) );
+        assertEquals( expectedMinPoolSize, minPoolSize );
+
+        int maxPoolSize = pool.getMaximumPoolSize();
+        int expectedMaxPoolSize = Integer.parseInt( props.getProperty( "thread_pool.aborttest.maximumPoolSize" ) );
+        assertEquals( expectedMaxPoolSize, maxPoolSize );
+
+        long keepAliveTime = pool.getKeepAliveTime(TimeUnit.MILLISECONDS);
+        long expectedKeepAliveTime = Long.parseLong( props.getProperty( "thread_pool.aborttest.keepAliveTime" ) );
+        assertEquals( expectedKeepAliveTime, keepAliveTime );
+        
+        RejectedExecutionHandler whenBlockedPolicy = pool.getRejectedExecutionHandler();
+        assertTrue( whenBlockedPolicy instanceof ThreadPoolExecutor.AbortPolicy );
+    }
+    
+    /**
      * Try to get an undefined pool from an existing default file.
      */
     public void testDefaultConfigUndefinedPool()
@@ -91,10 +126,10 @@
         assertNotNull( mgr );
 
         String poolName1 = "testGetPoolNames1";
-        mgr.getPool( poolName1 );
+        mgr.getExecutorService( poolName1 );
 
         String poolName2 = "testGetPoolNames2";
-        mgr.getPool( poolName2 );
+        mgr.getExecutorService( poolName2 );
 
         ArrayList<String> names = mgr.getPoolNames();
         assertTrue( "Should have name in list.", names.contains( poolName1 ) );
diff --git a/commons-jcs-core/src/test/test-conf/thread_pool.properties b/commons-jcs-core/src/test/test-conf/thread_pool.properties
index cbf5284..b6a3326 100644
--- a/commons-jcs-core/src/test/test-conf/thread_pool.properties
+++ b/commons-jcs-core/src/test/test-conf/thread_pool.properties
@@ -44,13 +44,13 @@
 thread_pool.maxtest.whenBlockedPolicy=RUN
 thread_pool.maxtest.startUpSize=5
 
-# wait test thread pool config
-thread_pool.waittest.boundarySize=1
-thread_pool.waittest.maximumPoolSize=11
-thread_pool.waittest.minimumPoolSize=1
-thread_pool.waittest.keepAliveTime=1
-thread_pool.waittest.whenBlockedPolicy=WAIT
-thread_pool.waittest.startUpSize=1
+# abort test thread pool config
+thread_pool.aborttest.boundarySize=1
+thread_pool.aborttest.maximumPoolSize=11
+thread_pool.aborttest.minimumPoolSize=1
+thread_pool.aborttest.keepAliveTime=1
+thread_pool.aborttest.whenBlockedPolicy=ABORT
+thread_pool.aborttest.startUpSize=1
 
 # with boundary test thread pool config
 thread_pool.withbound.useBoundary=true
@@ -58,7 +58,7 @@
 thread_pool.withbound.maximumPoolSize=11
 thread_pool.withbound.minimumPoolSize=1
 thread_pool.withbound.keepAliveTime=1
-thread_pool.withbound.whenBlockedPolicy=WAIT
+thread_pool.withbound.whenBlockedPolicy=ABORT
 thread_pool.withbound.startUpSize=1
 
 
@@ -68,5 +68,5 @@
 thread_pool.nobound.maximumPoolSize=11
 thread_pool.nobound.minimumPoolSize=1
 thread_pool.nobound.keepAliveTime=1
-thread_pool.nobound.whenBlockedPolicy=WAIT
+thread_pool.nobound.whenBlockedPolicy=ABORT
 thread_pool.nobound.startUpSize=1
diff --git a/commons-jcs-dist/pom.xml b/commons-jcs-dist/pom.xml
index 0991542..559b600 100644
--- a/commons-jcs-dist/pom.xml
+++ b/commons-jcs-dist/pom.xml
@@ -32,9 +32,9 @@
   <description>Creates the Apache Commons JCS multimodule distribution.</description>
 
   <scm>
-    <connection>scm:svn:http://svn.apache.org/repos/asf/commons/proper/jcs/branches/commons-jcs-2.1-RC/commons-jcs-dist</connection>
-    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/commons/proper/jcs/branches/commons-jcs-2.1-RC/commons-jcs-dist</developerConnection>
-    <url>http://svn.apache.org/viewvc/commons/proper/jcs/branches/commons-jcs-2.1-RC/commons-jcs-dist</url>
+    <connection>scm:svn:http://svn.apache.org/repos/asf/commons/proper/jcs/trunk/commons-jcs-dist</connection>
+    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/commons/proper/jcs/trunk/commons-jcs-dist</developerConnection>
+    <url>http://svn.apache.org/viewvc/commons/proper/jcs/trunk/commons-jcs-dist</url>
   </scm>
 
   <!-- NOTE: These dependency declarations are only required to sort this project to the 
diff --git a/commons-jcs-jcache-extras/pom.xml b/commons-jcs-jcache-extras/pom.xml
index 741923f..091cbea 100644
--- a/commons-jcs-jcache-extras/pom.xml
+++ b/commons-jcs-jcache-extras/pom.xml
@@ -30,9 +30,9 @@
   <name>Apache Commons JCS :: JCache Extras</name>
 
   <scm>
-    <connection>scm:svn:http://svn.apache.org/repos/asf/commons/proper/jcs/branches/commons-jcs-2.1-RC/commons-jcs-jcache-extras</connection>
-    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/commons/proper/jcs/branches/commons-jcs-2.1-RC/commons-jcs-jcache-extras</developerConnection>
-    <url>http://svn.apache.org/viewvc/commons/proper/jcs/branches/commons-jcs-2.1-RC/commons-jcs-jcache-extras</url>
+    <connection>scm:svn:http://svn.apache.org/repos/asf/commons/proper/jcs/trunk/commons-jcs-jcache-extras</connection>
+    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/commons/proper/jcs/trunk/commons-jcs-jcache-extras</developerConnection>
+    <url>http://svn.apache.org/viewvc/commons/proper/jcs/trunk/commons-jcs-jcache-extras</url>
   </scm>
 
   <dependencies>
diff --git a/commons-jcs-jcache-openjpa/pom.xml b/commons-jcs-jcache-openjpa/pom.xml
index b7efa57..a83133b 100644
--- a/commons-jcs-jcache-openjpa/pom.xml
+++ b/commons-jcs-jcache-openjpa/pom.xml
@@ -30,9 +30,9 @@
   <name>Apache Commons JCS :: JCache OpenJPA</name>
 
   <scm>
-    <connection>scm:svn:http://svn.apache.org/repos/asf/commons/proper/jcs/branches/commons-jcs-2.1-RC/commons-jcs-jcache-openjpa</connection>
-    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/commons/proper/jcs/branches/commons-jcs-2.1-RC/commons-jcs-jcache-openjpa</developerConnection>
-    <url>http://svn.apache.org/viewvc/commons/proper/jcs/branches/commons-jcs-2.1-RC/commons-jcs-jcache-openjpa</url>
+    <connection>scm:svn:http://svn.apache.org/repos/asf/commons/proper/jcs/trunk/commons-jcs-jcache-openjpa</connection>
+    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/commons/proper/jcs/trunk/commons-jcs-jcache-openjpa</developerConnection>
+    <url>http://svn.apache.org/viewvc/commons/proper/jcs/trunk/commons-jcs-jcache-openjpa</url>
   </scm>
 
   <dependencies>
diff --git a/commons-jcs-jcache/pom.xml b/commons-jcs-jcache/pom.xml
index b6fb71e..15d2c8d 100644
--- a/commons-jcs-jcache/pom.xml
+++ b/commons-jcs-jcache/pom.xml
@@ -32,9 +32,9 @@
   <name>Apache Commons JCS :: JCache</name>
 
   <scm>
-    <connection>scm:svn:http://svn.apache.org/repos/asf/commons/proper/jcs/branches/commons-jcs-2.1-RC/commons-jcs-jcache</connection>
-    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/commons/proper/jcs/branches/commons-jcs-2.1-RC/commons-jcs-jcache</developerConnection>
-    <url>http://svn.apache.org/viewvc/commons/proper/jcs/branches/commons-jcs-2.1-RC/commons-jcs-jcache</url>
+    <connection>scm:svn:http://svn.apache.org/repos/asf/commons/proper/jcs/trunk/commons-jcs-jcache</connection>
+    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/commons/proper/jcs/trunk/commons-jcs-jcache</developerConnection>
+    <url>http://svn.apache.org/viewvc/commons/proper/jcs/trunk/commons-jcs-jcache</url>
   </scm>
 
   <dependencies>
diff --git a/commons-jcs-tck-tests/pom.xml b/commons-jcs-tck-tests/pom.xml
index 4e61e0b..7ecb150 100644
--- a/commons-jcs-tck-tests/pom.xml
+++ b/commons-jcs-tck-tests/pom.xml
@@ -39,9 +39,9 @@
   <name>Apache Commons JCS :: JCache TCK</name>
 
   <scm>
-    <connection>scm:svn:http://svn.apache.org/repos/asf/commons/proper/jcs/branches/commons-jcs-2.1-RC/commons-jcs-tck-tests</connection>
-    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/commons/proper/jcs/branches/commons-jcs-2.1-RC/commons-jcs-tck-tests</developerConnection>
-    <url>http://svn.apache.org/viewvc/commons/proper/jcs/branches/commons-jcs-2.1-RC/commons-jcs-tck-tests</url>
+    <connection>scm:svn:http://svn.apache.org/repos/asf/commons/proper/jcs/trunk/commons-jcs-tck-tests</connection>
+    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/commons/proper/jcs/trunk/commons-jcs-tck-tests</developerConnection>
+    <url>http://svn.apache.org/viewvc/commons/proper/jcs/trunk/commons-jcs-tck-tests</url>
   </scm>
 
   <properties>
diff --git a/pom.xml b/pom.xml
index 094c6b2..c51c573 100644
--- a/pom.xml
+++ b/pom.xml
@@ -51,9 +51,9 @@
   </issueManagement>
 
   <scm>
-    <connection>scm:svn:http://svn.apache.org/repos/asf/commons/proper/jcs/branches/commons-jcs-2.1-RC</connection>
-    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/commons/proper/jcs/branches/commons-jcs-2.1-RC</developerConnection>
-    <url>http://svn.apache.org/viewvc/commons/proper/jcs/branches/commons-jcs-2.1-RC</url>
+    <connection>scm:svn:http://svn.apache.org/repos/asf/commons/proper/jcs/trunk</connection>
+    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/commons/proper/jcs/trunk</developerConnection>
+    <url>http://svn.apache.org/viewvc/commons/proper/jcs/trunk</url>
   </scm>
 
   <mailingLists>
@@ -519,8 +519,8 @@
     <maven.compiler.target>1.6</maven.compiler.target>
 
     <commons.componentid>jcs</commons.componentid>
-    <commons.release.version>2.1</commons.release.version>
-    <commons.release.name>commons-jcs-dist-2.1</commons.release.name>
+    <commons.release.version>2.0</commons.release.version>
+    <commons.release.name>commons-jcs-dist-2.0</commons.release.name>
     <commons.release.desc>(Java 6.0+)</commons.release.desc>
     <!-- The RC version used in the staging repository URL. -->
     <commons.rc.version>RC1</commons.rc.version>