X-Git-Url: https://feistymeow.org/gitweb/?a=blobdiff_plain;f=kona%2Fsrc%2Forg%2Ffeistymeow%2Fprocess%2Fethread.java;h=e23d7d89d33e0c1dedf940c63d8a1fd58b1f3e0e;hb=ef338226ccf699c8d8a149d9b74e9888175c7099;hp=6bd87ad726ddac183676f606fa84f2bdaa96eb76;hpb=1d6559648da40f18a476a7532ce1a85e381cfea6;p=feisty_meow.git

diff --git a/kona/src/org/feistymeow/process/ethread.java b/kona/src/org/feistymeow/process/ethread.java
index 6bd87ad7..e23d7d89 100644
--- 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;
+	}
 }
-