/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at legal-notices/CDDLv1_0.txt
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at legal-notices/CDDLv1_0.txt.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information:
* Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*
*
* Copyright 2006-2009 Sun Microsystems, Inc.
* Portions Copyright 2013-2014 ForgeRock AS
*/
/**
* This class defines a thread that will be used to execute a scheduled task
* within the server and provide appropriate notification that the task is
* complete.
*/
{
/** Indicates whether a request has been made for this thread to exit. */
private volatile boolean exitRequested;
/** The thread ID for this task thread. */
private int threadID;
/** The reference to the scheduler with which this thread is associated. */
/**
* The object that will be used for signaling the thread when there is new
* work to perform.
*/
/**
* Creates a new task thread with the provided information.
*
* @param taskScheduler The reference to the task scheduler with which this
* thread is associated.
* @param threadID The ID assigned to this task thread.
*/
{
super("Task Thread " + threadID);
this.taskScheduler = taskScheduler;
notifyLock = new Object();
exitRequested = false;
}
/**
* Retrieves the task currently being processed by this thread, if it is
* active.
*
* @return The task currently being processed by this thread, or
* <CODE>null</CODE> if it is not processing any task.
*/
{
return getAssociatedTask();
}
/**
* Provides a new task for processing by this thread. This does not do any
* check to ensure that no task is already in process.
*
* @param task The task to be processed.
*/
{
synchronized (notifyLock)
{
notifyLock.notify();
}
}
/**
* Attempts to interrupt processing on the task in progress.
*
* @param interruptState The state to use for the task if it is
* successfully interrupted.
* @param interruptReason The human-readable reason that the task is to be
* interrupted.
* @param exitThread Indicates whether this thread should exit when
* processing on the active task has completed.
*/
boolean exitThread)
{
if (getAssociatedTask() != null)
{
try
{
}
catch (Exception e)
{
logger.traceException(e);
}
}
if (exitThread)
{
exitRequested = true;
}
}
/**
* Operates in a loop, sleeping until there is no work to do, then
* processing the task and returning to the scheduler for more work.
*/
public void run()
{
while (! exitRequested)
{
if (getAssociatedTask() == null)
{
try
{
synchronized (notifyLock)
{
}
}
catch (InterruptedException ie)
{
}
continue;
}
try
{
{
}
}
catch (Exception e)
{
logger.traceException(e);
logger.error(ERR_TASK_EXECUTE_FAILED, task.getTaskEntry().getName(), stackTraceToSingleLineString(e));
}
{
exitRequested = true;
break;
}
}
if (getAssociatedTask() != null)
{
}
}
/**
* Retrieves any relevant debug information with which this tread is
* associated so they can be included in debug messages.
*
* @return debug information about this thread as a string.
*/
{
if (getAssociatedTask() != null)
{
}
return properties;
}
}