ethread.java

Go to the documentation of this file.

package org.feistymeow.process;
 
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
 
public abstract class ethread implements Runnable
{
  private static Log c_logger = LogFactory.getLog(ethread.class);
 
  // the actual java thread object.
  private volatile Thread c_RealThread = null;
  // provides synchronization for the thread.
  private volatile Object c_lock = new Object();
  // this is the timing period, for a timed thread. if zero, then this is a single shot thread.
  private long c_period = 0;
  // records whether the thread should shut down or not.
  private boolean c_stopThread = false;
  // snooze between checks on the stop timer.
  final long SNOOZE_PERIOD = 20;
 
  public ethread()
  {
  }
 
  public ethread(long period)
  {
    c_period = period;
  }
 
  abstract public boolean performActivity();
 
  public void start()
  {
    synchronized (c_lock) {
      if (null == this.c_RealThread) {
        this.c_RealThread = new Thread(this);
        c_logger.debug("starting thread " + c_RealThread.getId());
        this.c_RealThread.start();
      }
    }
  }
 
  public void stop()
  {
    cancel();
    while (true) {
      if (threadAlive()) {
        try {
          Thread.sleep(40);
        } catch (InterruptedException e) {
          // ignoring this since we'll keep snoozing as needed.
        }
      } else {
        break;
      }
    }
  }
 
  void cancel()
  {
    synchronized (c_lock) {
      c_stopThread = true;
      Thread goAway = c_RealThread;
      c_RealThread = null;
      if (null != goAway) {
        goAway.interrupt();
      }
    }
  }
 
  public boolean threadAlive()
  {
    synchronized (c_lock) {
      return this.c_RealThread != null;
    }
  }
 
  public boolean shouldStop()
  {
    synchronized (c_lock) {
      return c_stopThread;
    }
  }
 
  @Override
  public void run()
  {
    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;
          }
          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);
    }
    // reset the thread held since we're leaving right now.
    c_stopThread = true;
    c_RealThread = null;
  }
}