[Jboss-cvs] JBossAS SVN: r56114 - branches/JBoss_4_0_3_SP1_JBAS_3511/server/src/main/org/jboss/jms/asf

[jboss-cvs-commits at lists.jboss.org]

Author: weston.price at jboss.com
Date: 2006-08-21 11:57:05 -0400 (Mon, 21 Aug 2006)
New Revision: 56114

Modified:
   branches/JBoss_4_0_3_SP1_JBAS_3511/server/src/main/org/jboss/jms/asf/JmsServerSessionReaper.java
Log:
[JBAS-3511] Adding removal feature to reaper.

Modified: branches/JBoss_4_0_3_SP1_JBAS_3511/server/src/main/org/jboss/jms/asf/JmsServerSessionReaper.java
===================================================================
--- branches/JBoss_4_0_3_SP1_JBAS_3511/server/src/main/org/jboss/jms/asf/JmsServerSessionReaper.java	2006-08-21 15:25:05 UTC (rev 56113)
+++ branches/JBoss_4_0_3_SP1_JBAS_3511/server/src/main/org/jboss/jms/asf/JmsServerSessionReaper.java	2006-08-21 15:57:05 UTC (rev 56114)
@@ -1,16 +1,126 @@
 package org.jboss.jms.asf;
 
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+
+import org.jboss.logging.Logger;
+
+/**
+ * A JmsServerSessionReaper.
+ * 
+ * @author <a href="adrian at jboss.com">Adrian Brock</a>
+ * @version $Revision: 1.1 $
+ */
 public class JmsServerSessionReaper
 {
    
+   private static final Logger logger = Logger.getLogger(JmsServerSessionReaper.class);
+   private static final Collection pools = new ArrayList();
+   private long interval = Long.MAX_VALUE;
+   private long next = Long.MAX_VALUE;
+   private Thread reaperThread;
+   
+   private static final JmsServerSessionReaper reaper = new JmsServerSessionReaper();
+   
    public static void registerSessionPool(StdServerSessionPool pool, long interval)
    {
-      
+      reaper.internalRegisterPool(pool, interval);
    }
    
    public static void unregisterSessionPool(StdServerSessionPool pool)
+   {     
+      reaper.internalUnregisterPool(pool);
+   }
+
+   private JmsServerSessionReaper()
    {
+      reaperThread = new Thread(
+            new Runnable() {
+
+               public void run()
+               {
+                  synchronized (pools)
+                  {
+                     while (true)
+                     {
+                        try 
+                        {
+                           pools.wait(interval);
+                           logger.debug("run: IdleRemover notifying pools, interval: " + interval);
+                           
+                           for (Iterator i = pools.iterator(); i.hasNext(); ) 
+                           {
+                             StdServerSessionPool pool = (StdServerSessionPool)i.next();
+                             pool.removeTimedOut();
+                           } 
+                           next = System.currentTimeMillis() + interval;
+                           
+                           if (next < 0) 
+                           {
+                              next = Long.MAX_VALUE;      
+                           } 
+                           
+                        }
+                        catch (InterruptedException ie)
+                        {
+                           logger.info("run: IdleRemover has been interrupted, returning");
+                           return;  
+                        } // end of try-catch
+                        catch (RuntimeException e)
+                        {
+                           logger.warn("run: IdleRemover ignored unexpected runtime exception", e);
+                        }
+                        catch (Error e)
+                        {
+                           logger.warn("run: IdleRemover ignored unexpected error", e);
+                        }
+                           
+                     } 
+                     
+                  }
+               }
+            }, "IdleRemover");
+         reaperThread.setDaemon(true);
+         reaperThread.start();
       
+   }
+   private void internalRegisterPool(StdServerSessionPool pool, long interval)
+   {
+      logger.debug("Registering StdServerSessionPool with interval " + interval);
       
+      synchronized (pools)
+      {
+         pools.add(pool);
+         
+         if (interval > 1 && interval/2 < this.interval) 
+         {
+            this.interval = interval/2;
+            long maybeNext = System.currentTimeMillis() + this.interval;
+            if (next > maybeNext && maybeNext > 0) 
+            {
+               next = maybeNext;
+               logger.debug("internalRegisterPool: about to notify thread: old next: " + next + ", new next: " + maybeNext);
+               pools.notify();
+
+            } 
+            
+         } 
+      }
+      
    }
+   
+   private void internalUnregisterPool(StdServerSessionPool pool)
+   {
+      synchronized (pools)
+      {
+         pools.remove(pool);
+         if (pools.size() == 0) 
+         {
+            logger.debug("internalUnregisterPool: setting interval to Long.MAX_VALUE");
+            interval = Long.MAX_VALUE;
+         } 
+         
+      }
+   }
 }