public StdServerSessionPool(Connection con,
    boolean transacted,
    int ack,
    boolean useLocalTX,
    MessageListener listener,
    int maxSession,
    XidFactoryMBean xidFactory) throws JMSException 
{
                                                                   
      this.con = con;
      this.ack = ack;
      this.listener = listener;
      this.transacted = transacted;
      this.poolSize = maxSession;
      this.sessionPool = new ArrayList(maxSession);
      this.useLocalTX = useLocalTX;
      this.xidFactory = xidFactory;
      // setup the worker pool
      executor = new PooledExecutor(poolSize);
      executor.setMinimumPoolSize(0);
      executor.setKeepAliveTime(1000 * 30);
      executor.waitWhenBlocked();
      executor.setThreadFactory(new DefaultThreadFactory());
      // finish initializing the session
      create();
      log.debug("Server Session pool set up");
}

Construct a StdServerSessionPool using the default pool size.

Parameters:

con - connection to get sessions from

transacted - transaction mode when not XA (

ack - ackmode when not XA

listener - the listener the sessions will call

maxSession - maximum number of sessions in the pool

isuseLocalTX - Description of Parameter

Throws:

JMSException - Description of Exception

exception: JMSException - Description of Exception

 public  void clear() 
{
      synchronized (sessionPool)
      {
         // FIXME - is there a runaway condition here. What if a
         // ServerSession are taken by a ConnecionConsumer? Should we set
         // a flag somehow so that no ServerSessions are recycled and the
         // ThreadPool won't leave any more threads out.
         closing = true;
         if (log.isDebugEnabled())
         {
            log.debug("Clearing " + sessionPool.size() +
                  " from ServerSessionPool");
         }
         Iterator iter = sessionPool.iterator();
         while (iter.hasNext())
         {
            StdServerSession ses = (StdServerSession)iter.next();
            // Should we do anything to the server session?
            ses.close();
            numServerSessions--;
         }
         sessionPool.clear();
         sessionPool.notifyAll();
      }
      //Must be outside synchronized block because of recycle method.
      executor.shutdownAfterProcessingCurrentlyQueuedTasks();
      //wait for all server sessions to be returned.
      synchronized (sessionPool)
      {
         while (numServerSessions  > 0)
         {
            try
            {
               sessionPool.wait();
            }
            catch (InterruptedException ignore)
            {
            }
         }
      }
}

Clear the pool, clear out both threads and ServerSessions, connection.stop() should be run before this method.

 Executor getExecutor() 
{
      return executor;
}

Get the executor we are using.

 public ServerSession getServerSession() throws JMSException 
{
      if( log.isTraceEnabled() )
         log.trace("getting a server session");
      ServerSession session = null;
      try
      {
         while (true)
         {
            synchronized (sessionPool)
            {
               if (closing)
               {
                  throw new JMSException("Cannot get session after pool has been closed down.");
               }
               else if (sessionPool.size()  > 0)
               {
                  session = (ServerSession)sessionPool.remove(0);
                  break;
               }
               else
               {
                  try
                  {
                     sessionPool.wait();
                  }
                  catch (InterruptedException ignore)
                  {
                  }
               }
            }
         }
      }
      catch (Exception e)
      {
         throw new JMSException("Failed to get a server session: " + e);
      }
      // assert session != null
      if( log.isTraceEnabled() )
         log.trace("using server session: " + session);
      return session;
}

Get a server session.

 boolean isTransacted() 
{
      return transacted;
}

Returns true if this server session is transacted.

  void recycle(StdServerSession session) 
{
      synchronized (sessionPool)
      {
         if (closing)
         {
            session.close();
            numServerSessions--;
            if (numServerSessions == 0)
            {
               //notify clear thread.
               sessionPool.notifyAll();
            }
         }
         else
         {
            sessionPool.add(session);
            sessionPool.notifyAll();
            if( log.isTraceEnabled() )
               log.trace("recycled server session: " + session);
         }
      }
}

Recycle a server session.