Logo
Distributed Genetic Programming Framework
print print

File org.sfc.parallel.Activity.java

Here you can find all the information about the file org.sfc.parallel.Activity.java. You may explore it here or download it onto your local disk.
/*
 * Copyright (c) 2006 Thomas Weise
 *
 * E-Mail           : tweise@gmx.de
 * Creation Date    : 2006-04-12 08:20:15
 * Original Filename: org.sfc.parallel.Activity.java
 * Version          : 2.1.0
 * Last modification: 2006-06-08
 *                by: Thomas Weise
 *
 * License          : GNU LESSER GENERAL PUBLIC LICENSE
 *                    Version 2.1, February 1999
 *                    You should have received a copy of this license along
 *                    with this library; if not, write to the Free Software
 *                    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *                    MA 02111-1307, USA or download the license under
 *                    http://www.gnu.org/copyleft/lesser.html.
 *
 * Warranty         : This software is provided "as is" without any
 *                    warranty; without even the implied warranty of
 *                    merchantability or fitness for a particular purpose.
 *                    See the Gnu Lesser General Public License for more
 *                    details.
 */


package org.sfc.parallel;

import org.sfc.events.EventPropagator;
import org.sfc.events.IEventListener;
import org.sfc.events.IEventSource;
import org.sfc.parallel.events.ParallelShutdownEvent;
import org.sfc.parallel.events.ParallelStateEvent;

/**
 * The class activity allows you to manage the lifetime of an activity
 * object. Its state transcents from inactive after creation, to running,
 * to stopped. It may be shut down, which is something special.
 * An activity throws parallel events when started or stopped.
 *
 * @author Thomas Weise
 */

public  abstract  class       Activity
                  implements  IStartable, IAbortable, IWaitable,
                              IEventSource
  {
/**
 * The event propagator to be used for the activity's events.
 */

          final     EventPropagator m_events  ;
/**
 * The current state of the activity.
 */

  private volatile  byte            m_state   ;
/**
 * The thread group.
 */

  private final     SfcThreadGroup  m_threads ;

/**
 * <code>true</code> if a no call to on-close is pending.
 */

  private volatile  boolean         m_no_on_close;
/**
 * The internal synchronization object.
 */

  private final     Object          m_sync  ;
  
  
/**
 * Create a new activity by providing an event propagator and a thread
 * group.
 * @param p_events    The event propagator to be used.
 * @param p_threads   The thread group to use.
 */

  public  Activity  (EventPropagator p_events,
                     SfcThreadGroup  p_threads )
    {
    ThreadGroup    l_tg;
    IEventListener l_o;

    if(p_threads == null)
      {
      l_tg = Thread.currentThread().getThreadGroup();
      if(l_tg instanceof SfcThreadGroup)
        {
        p_threads = ((SfcThreadGroup)l_tg);
        }
      }

    if( (p_events == null) && (p_threads != null) )
      {
      l_o = p_threads.get_propagator();
      if(l_o instanceof EventPropagator)
        {
        p_events = ((EventPropagator)l_o);
        }
      else
        {
        p_events = new EventPropagator();
        p_events.add_listener(l_o);
        }
      }

    this.m_threads     = p_threads;
    this.m_events      = p_events;
    this.m_no_on_close = (p_events != null);
    this.m_sync        = new Object();
    }


/**
 * Create a new activity by providing an event propagator only.
 * @param p_events    The event propagator to be used.
 */

  public  Activity  (final EventPropagator p_events)
    {
    this(p_events, null);
    }


/**
 * Create a new activity by providing a thread group only.
 * @param p_threads   The thread group to use.
 */

  public  Activity  (final SfcThreadGroup  p_threads )
    {
    this(null, p_threads);
    }

  
/**
 * Obtain the thread group used by this activity.
 * @return The thread group used by this activity.
 */

  protected final SfcThreadGroup  get_thread_group()
    {
    return this.m_threads;
    }


/**
 * Obtain the event propagator suitable for this activity.
 * @return The event propagator suitable for this activity.
 */

  protected final EventPropagator get_event_propagator  ()
    {
    return this.m_events;
    }

/**
 * Perform a shutdown. It is guaranteed to be called only once for shutdown.
 * This method should only perform the actions needed to shutdown the
 * network of activities. The closing of the activity itself will be done
 * by <code>do_abort</code>, which will subsequently be called
 * automatically.
 * @see #abort()
 * @see #shutdown()
 */

  protected void  do_shutdown ()
    {
    //
    }
  
/**
 * This method aborts the activity. It is guaranteed to be called only once
 * for aborting and once for shutdown.
 * @see #abort()
 * @see #shutdown()
 */

  protected void  do_abort  ()
    {
    //
    }


/**
 * <p>
 * Shuts down the activity globally, while <code>abort()</code> shuts down
 * the local activity. An activity might run distributed over a network.
 * If so, there two options for finishing: either we shutdown one node in
 * the network while the others continue working (<code>abort()</code>) or
 * we shutdown the whole network and stop the activity globally
 * (<code>shutdown()</code>).
 * </p>
 * <p>
 * The shutdown method usually deferes to <code>do_shutdown()</code> and
 * then to <code>do_abort()</code>.
 * </p>
 * @see #do_abort()
 * @see #do_shutdown()
 * @see #abort()
 */

  public  final void  shutdown  ()
    {
    synchronized(this.m_sync)
      {
      if(this.m_state > 1) return;
      this.m_state = 3;
      }
    
    this.m_events.receive(new ParallelShutdownEvent(this));

    if(this.m_no_on_close)
      {
      this.m_no_on_close = false;
      this.defer_on_close();
      }

    synchronized(this)
      {
      this.do_shutdown();
      this.do_abort();
      }
    }

/**
 * <p>
 * Abort this activity.
 * This method does not block.
 * </p>
 * <p>
 * The abort method usually deferes to <code>do_abort()</code>.
 * </p>
 * @see #do_abort()
 */

  public  final void  abort ()
    {
    synchronized(this.m_sync)
      {
      if(this.m_state > 1) return;
      this.m_state = 2;
      }
    
    if(this.m_no_on_close)
      {
      this.m_no_on_close = false;
      this.defer_on_close();
      }
            
    synchronized(this)
      {
      this.do_abort();
      }      
    }

/**
 * Tells the activity to stop its actions. This is the proper method to
 * allow the activity to terminate itself.
 * This method does block until the activity has finished.
 * @see #abort()
 */

  public  final void  abort_and_wait  ()
    {
    this.abort();
    this.wait_for();
    }


/**
 * Startup the activity. This method will be called by <code>start()</code>.
 * @see #start()
 */

  protected void  do_start  ()
    {
    //
    }

/**
 * This method checks if the activity has terminated (or just entered the
 * termination procedure).
 * @return  <code>true</code> if the activity has terminated (or just
 *          entered the termination procedure), <code>false</code> if it
 *          did not start yet or is still running.
 */

  public  final boolean has_terminated  ()
    {
    return (this.m_state >= 2);
    }

/**
 * <p>
 * Start this activity.
 * </p><p>
 * A call to this method will usually defere to <code>do_start()</code>.
 * </p>
 * @see #do_start()
 */

  public  final void  start ()
    {
    synchronized(this.m_sync)
      {
      if(this.m_state > 0) return;
      this.m_state = 1;
      }
//    if(this.m_state <= 0)
//      {
//      this.m_state = 1;

    this.m_events.receive(new ParallelStateEvent(this, true));

    synchronized(this)
      {
      this.do_start();
      }
    }


/**
 * Check wether this activity is currently running or not.
 * @return  <code>true</code> if and only if the activity is currently
 *          running, <code>false</code> otherwise.
 * @see #shutdown()
 * @see #abort()
 * @see #abort_and_wait()
 */

  public  final boolean is_running  ()
    { 
    return (this.m_state == 1);      
    }

/**
 * <p>
 * This method is used to defer a call to the <code>on_close()</code>-
 * method. The <code>on_close()</code>-method throws the final state event
 * and performs some cleanup for the activity. <code>on_close()</code>
 * is the last method that has to be called after a activity has been
 * performed. No other events must be created by the activity afterwards.
 * </p><p>
 * You may override <code>defer_on_close()</code> to provide an other
 * delaying method. The default implementation creates a thread that waits
 * for the engine and then calls <code>on_close()</code>.
 * </p>
 * @see #after_termination()
 */

  void  defer_on_close  ()
    {
    new Thread()
      {
      @Override
      public  final void  run()
        {
        Activity l_a;
        
        l_a = Activity.this;
        try
          {
          l_a.wait_for();
          }
        finally
          {
          try
            {          
            l_a.after_termination();
            }
          finally
            {
            l_a.m_events.receive(new ParallelStateEvent(l_a, false));
            }
          }
        }
      }.start();
    }

/**
 * This method is called after the search engine has terminated. It will be
 * called by <code>defer_on_close()</code> after all the engine's activities
 * have been finished. This method must not be called in any other way than
 * that.
 */

  protected void  after_termination  ()
    {    
    //
    }


/**
 * Attaches a new event sink to this event source. The events created by
 * this event source will be propagated to the sink from now on.
 * @param p_sink  The sink to be attached.
 * @see #remove_listener(IEventListener)
 */

  public  final void  add_listener  (final IEventListener p_sink)
    {
    if(this.m_events != null) this.m_events.add_listener(p_sink);
    }

/**
 * Removes a event sink from this event source. The events created by this
 * event source will no longer be propagated to the sink from now on.
 * @param p_sink  The sink to be removed.
 * @see #add_listener(IEventListener)
 */

  public final  void  remove_listener (final IEventListener p_sink)
    {
    if(this.m_events != null)this.m_events.remove_listener(p_sink);
    }


/**
 * Wait for this object.
 */

  public  void  wait_for  ()
    {
    //
    }

/**
 * The human readable name of the activity.
 * @return The human readable name of the activity.
 */

  @Override
  public  abstract String  toString  ();
  }

File Information:

file name:Activity.java
package:org.sfc.parallel
qualified name:org.sfc.parallel.Activity.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/sfc/parallel/Activity.java
size:10.593 KB (10848 B)
uploaded: 2015-07-22 04:11:12 GMT+0000
last update: 2006-06-08 02:49:27 GMT+0000
last access: 2018-01-24 01:17:45 GMT+0000

statistics online since 2006-01-02.   RSS Feed
Contact us by sending an email to tweise@gmx.de to receive further information, to report errors, or to join our project.
All content on this site (http://dgpf.sourceforge.net/) is LGPL-licensed.
http://dgpf.sourceforge.net/scripts/source/source.php last modified at 2015-07-22 04:10:53 GMT+0000 served at 2018-01-24 01:17:45 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo