bug fixes for ethread's periodic mode.

[feisty_meow.git] / kona / src / org / feistymeow / process / ethread.java

diff --git a/kona/src/org/feistymeow/process/ethread.java b/kona/src/org/feistymeow/process/ethread.java
index 6bd87ad726ddac183676f606fa84f2bdaa96eb76..e23d7d89d33e0c1dedf940c63d8a1fd58b1f3e0e 100644 (file)
--- a/kona/src/org/feistymeow/process/ethread.java
+++ b/kona/src/org/feistymeow/process/ethread.java
@@ -8,8 +8,8 @@ import org.apache.commons.logging.LogFactory;
  * 
  * @author Chris Koeritz
  * @copyright Copyright (c) 2010-$now By Feisty Meow Concerns Ltd.
- * @license This file is free software; you can modify and redistribute it under the terms of the
- *          Apache License v2.0: http://www.apache.org/licenses/LICENSE-2.0
+ * @license This file is free software; you can modify and redistribute it under the terms of the Apache License v2.0:
+ *          http://www.apache.org/licenses/LICENSE-2.0
  */
 public abstract class ethread implements Runnable
 {
@@ -27,16 +27,15 @@ public abstract class ethread implements Runnable
        final long SNOOZE_PERIOD = 20;
 
        /**
-        * creates a new single-shot ethread without starting it. this type of thread will run just
-        * once.
+        * creates a new single-shot ethread without starting it. this type of thread will run just once.
         */
        public ethread()
        {
        }
 
        /**
-        * creates a new periodic ethread without starting it. this type of thread runs every "period"
-        * milliseconds until stopped or until the performActivity method returns false.
+        * creates a new periodic ethread without starting it. this type of thread runs every "period" milliseconds until stopped or until the
+        * performActivity method returns false.
         */
        public ethread(long period)
        {
@@ -44,14 +43,12 @@ public abstract class ethread implements Runnable
        }
 
        /**
-        * this is the main function that derived classes must implement. it does the actual work that
-        * the thread is intended to perform. note that the derived version must not do anything to
-        * cause the thread to be ripped out while performActivity is still being invoked. the return
-        * value should be true if the thread can continue executing. this is meaningless for single
-        * shot threads executed via runOnce, but matters for the periodic threads started with
-        * runPeriodic.
+        * this is the main function that derived classes must implement. it does the actual work that the thread is intended to perform. note
+        * that the derived version must not do anything to cause the thread to be ripped out while performActivity is still being invoked. the
+        * return value should be true if the thread can continue executing. this is meaningless for single shot threads executed via runOnce, but
+        * matters for the periodic threads started with runPeriodic.
         */
-       abstract boolean performActivity();
+       abstract public boolean performActivity();
 
        /**
         * Begins execution of the thread.
@@ -74,7 +71,7 @@ public abstract class ethread implements Runnable
        {
                cancel();
                while (true) {
-                       if (threadRunning()) {
+                       if (threadAlive()) {
                                try {
                                        Thread.sleep(40);
                                } catch (InterruptedException e) {
@@ -102,9 +99,9 @@ public abstract class ethread implements Runnable
        }
 
        /**
-        * Returns true if the thread isn't null.
+        * Returns true if the thread object is still alive. this does not necessarily mean it is currently active.
         */
-       public boolean threadRunning()
+       public boolean threadAlive()
        {
                synchronized (c_lock) {
                        return this.c_RealThread != null;
@@ -122,41 +119,43 @@ public abstract class ethread implements Runnable
        }
 
        /**
-        * this is the override from Runnable that allows us to call our own performActivity method.
-        * implementors should not override this; they should override performActivity instead.
+        * this is the override from Runnable that allows us to call our own performActivity method. implementors should not override this; they
+        * should override performActivity instead.
         */
        @Override
        public void run()
        {
-                       if (!threadRunning()) {
-                               return; // stopped before it ever started. how can this be? we just got invoked.
-                       }
-                       try {
-                               while (true) {
-                                       boolean keepGoing = performActivity();
-                                       if (!keepGoing) {
-                                               c_logger.debug("thread returned false for single shot thread.  just saying.");
-                                       }
-                                       if (c_period == 0) {
-                                               // not a periodic thread, so we're done now.
+               if (!threadAlive()) {
+                       return; // stopped before it ever started. how can this be? we just got invoked.
+               }
+               try {
+                       while (true) {
+                               boolean keepGoing = performActivity();
+                               if (!keepGoing) {
+                                       c_logger.debug("thread returned false, signifying it wants to exit.  now dropping it.");
+                                       break;
+                               }
+                               if (c_period == 0) {
+                                       // not a periodic thread, so we're done now.
+                                       break;
+                               }
+                               long nextRun = System.currentTimeMillis() + c_period;
+                               while (System.currentTimeMillis() < nextRun) {
+                                       if (shouldStop()) {
                                                break;
                                        }
-                                       long nextRun = System.currentTimeMillis() + c_period;
-                                       while (System.currentTimeMillis() < nextRun) {
-                                               if (shouldStop()) {
-                                                       break;
-                                               }
-                                               try {
-                                                       Thread.sleep(SNOOZE_PERIOD);
-                                               } catch (InterruptedException e) {
-                                                       // well, we'll hit it again soon.
-                                               }
+                                       try {
+                                               Thread.sleep(SNOOZE_PERIOD);
+                                       } catch (InterruptedException e) {
+                                               // well, we'll hit it again soon.
                                        }
                                }
-                       } catch (Throwable t) {
-                               c_logger.info("exception thrown from performActivity: " + t.getLocalizedMessage(), t);
                        }
+               } catch (Throwable t) {
+                       c_logger.info("exception thrown from performActivity: " + t.getLocalizedMessage(), t);
                }
-       
+               // reset the thread held since we're leaving right now.
+               c_stopThread = true;
+               c_RealThread = null;
+       }
 }
-