Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source
   * Copyright 2006, Red Hat Middleware LLC, and individual contributors
   * as indicated by the @author tags.
   * See the copyright.txt in the distribution for a full listing
   * of individual contributors.
   * This copyrighted material is made available to anyone wishing to use,
   * modify, copy, or redistribute it subject to the terms and conditions
   * of the GNU Lesser General Public License, v. 2.1.
  * This program is distributed in the hope that it will be useful, but WITHOUT A
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
  * PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
  * You should have received a copy of the GNU Lesser General Public License,
  * v.2.1 along with this distribution; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  * MA  02110-1301, USA.
  *
  * (C) 2005-2006,
  * @author JBoss Inc.
  */
 /*
  * Copyright (C) 2002,
  *
  * Arjuna Technologies Limited,
  * Newcastle upon Tyne,
  * Tyne and Wear,
  * UK.
  *
  * $Id: ActivityReaper.java,v 1.6 2005/05/19 12:13:18 nmcl Exp $
  */
 
 package com.arjuna.mwlabs.wsas.activity;
 
 
 
 
Class to record activities with non-zero timeout values, and class to implement a activity reaper thread which terminates these activities once their timeout elapses.

Author(s):
Mark Little (mark@arjuna.com)
Version:
$Id: ActivityReaper.java,v 1.6 2005/05/19 12:13:18 nmcl Exp $
Since:
1.0.
 
 
 public class ActivityReaper
 {
 
     public final long sleepPeriod ()
     {
         synchronized () {
             if (.isEmpty()) {
                 // sleep until a wakeup is notified
                 return 0;
             } else {
                 long currentTime = System.currentTimeMillis();
                 long firstTimeout = .first().;
                 if (currentTime >= firstTimeout) {
                     // don't sleep just start work now
                     return -1;
                 } else {
                     // sleep for required number of milliseconds
                     return (firstTimeout - currentTime);
                 }
             }
         }
     }
 
     /*
      * Should be no need to protect with a mutex since only one thread
      * is ever doing the work.
      */

    
Only check for one at a time to prevent starvation. Timeout is given in millisecon>ds.
 
 
     public final boolean check (long timeout)
     {
         ReaperElement element = null;
 
         synchronized() {
             if (.isEmpty()) {
                 return false;
             }
 
             element = .first();
            if (timeout < element._absoluteTimeout) {
                return false;
            }
        }
	    /*
	     * Only force rollback if the activity is still running.
	     */
	    Status status = com.arjuna.mw.wsas.status.Unknown.instance();
	    try
	    {
		status = element._activity.status();
	    }
	    catch (Exception ex)
	    {
	    }
	    if (status instanceof Active)
	    {
		/*
		 * If this is a local activity, then we can roll it
		 * back completely. Otherwise, just mark it as rollback only.
		 */
		boolean problem = false;
		    try
		    {
			/*
			 * TODO
			 *
			 * Everything works on thread-to-activity association
			 * so we can't just tell an activity to end: we have
			 * to resume it and then tell it to end. The reason
			 * is that all HLS-es assume that the invoking thread
			 * has the current context on it.
			 */
			//			e._activity.end(Failure.instance());
			UserActivityFactory.userActivity().resume(new ActivityHierarchyImple(element._activity));
			UserActivityFactory.userActivity().end(Failure.instance());
			UserActivityFactory.userActivity().suspend();
		    }
		    catch (Exception ex)
		    {
			problem = true;
		    }
		if (problem)
		{
		    boolean error = false;
		    try
		    {
			element._activity.setCompletionStatus(FailureOnly.instance());
		    }
		    catch (Exception ex3)
		    {
			error = true;
		    }
		    if (error)
		    {
                ..warn_activity_ActivityReaper_1();
		    }
		}
	    }
        synchronized () {
            .remove(element);
        }
	return true;
    }

    

Returns:
the number of items in the reaper's list.
    public final long numberOfActivities ()
    {
        synchronized() {
            return .size();
        }
    }

    
timeout is given in seconds, but we work in milliseconds.
    public final boolean insert (ActivityImple activityint timeout)
    {
	/*
	 * Ignore if the timeout is zero, since this means the activity
	 * should never timeout.
	 */
	if (timeout == 0)
	    return true;
	ReaperElement e = new ReaperElement(activitytimeout);
        synchronized () {
            .add(e);
        }
        // notify the reaper thread that the list has changed
        synchronized () {
            .notify();
        }
        return true;
    }
    public final boolean remove (ActivityImple act)
    {
        if (act == null) {
            return false;
        }
        boolean found = false;
        synchronized () {
            Iterator<ReaperElementiter = .iterator();
            ReaperElement e = null;
            while (iter.hasNext() && !found) {
                e = iter.next();
                if (e._activity.equals(act)) {
                    .remove(e);
                    found = true;
                }
            }
        }
        if (found) {
            // notify the reaper thread that the list has changed
            synchronized () {
                .notify();
            }
        }
        return false;
    }

    
Currently we let the reaper thread run at same priority as other threads. Could get priority from environment.
    public static synchronized ActivityReaper create ()
    {
        // TODO -- problem here because nothing calls shutdown
	if ( == null)
	{
	    //	    _reaperThread.setPriority(Thread.MIN_PRIORITY);
	    .setDaemon(true);
	}
	return ;
    }
    public static synchronized ActivityReaper activityReaper ()
    {
	return activityReaper(false);
    }
    /*
     * If parameter is true then do a create.
     */
    public static synchronized ActivityReaper activityReaper (boolean createReaper)
    {
	if (createReaper)
	    return create();
	else
	    return ;
    }

    
make sure the reaper thread exits
    public static synchronized void shutdown()
    {
        if ( != null) {
            .shutdown();
        }
    }
    ActivityReaper ()
    {
         = new TreeSet<ReaperElement>();
    }
    static final void reset ()
    {
	 = null;
    }
    private SortedSet<ReaperElement_list;
    private static ActivityReaper _theReaper = null;
    private static ReaperThread   _reaperThread = null;
New to GrepCode? Check out our FAQ X