Package org.apache.tools.ant.util

# Class WorkerAnt

java.lang.Object
java.lang.Thread
org.apache.tools.ant.util.WorkerAnt

All Implemented Interfaces:
  `Runnable`

public class WorkerAnt extends Thread
A worker ant executes a single task in a background thread. After the run, any exception thrown is turned into a BuildException, which can be rethrown, the finished attribute is set, then notifyAll() is called, so that anyone waiting on the same notify object gets woken up.

This class is effectively a superset of `org.apache.tools.ant.taskdefs.Parallel.TaskRunnable`

Since:
  Ant 1.8

- ## Nested Class Summary

  ## Nested classes/interfaces inherited from class java.lang.Thread

  `Thread.BuilderPREVIEW, Thread.State, Thread.UncaughtExceptionHandler`

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `static final String`
  `ERROR_NO_TASK`
  Error message if invoked with no task

  ### Fields inherited from class java.lang.Thread

  `MAX_PRIORITY, MIN_PRIORITY, NORM_PRIORITY`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `WorkerAnt(Task task)`
  Create the worker, using the worker as the notification point.
  `WorkerAnt(Task task, Object notify)`
  Create the worker.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `BuildException`
  `getBuildException()`
  Get any build exception.
  `Throwable`
  `getException()`
  Get whatever was thrown, which may or may not be a buildException.
  `Task`
  `getTask()`
  Get the task
  `boolean`
  `isFinished()`
  Query the task/thread for being finished.
  `void`
  `rethrowAnyBuildException()`
  Raise an exception if one was caught
  `void`
  `run()`
  Run the task, which is skipped if null.
  `void`
  `waitUntilFinished(long timeout)`
  Block on the notify object and so wait until the thread is finished.

  ### Methods inherited from class java.lang.Thread

  `activeCount, checkAccess, clone, countStackFrames, currentThread, dumpStack, enumerate, getAllStackTraces, getContextClassLoader, getDefaultUncaughtExceptionHandler, getId, getName, getPriority, getStackTrace, getState, getThreadGroup, getUncaughtExceptionHandler, holdsLock, interrupt, interrupted, isAlive, isDaemon, isInterrupted, isVirtual, join, join, join, join, ofPlatform, ofVirtual, onSpinWait, resume, setContextClassLoader, setDaemon, setDefaultUncaughtExceptionHandler, setName, setPriority, setUncaughtExceptionHandler, sleep, sleep, sleep, start, startVirtualThread, stop, suspend, threadId, toString, yield`

  ### Methods inherited from class java.lang.Object

  `equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- ## Field Details

  - ### ERROR_NO_TASK

    public static final String ERROR_NO_TASK
    Error message if invoked with no task
    See Also:
      - Constant Field Values

- ## Constructor Details

  - ### WorkerAnt

    public WorkerAnt(Task task, Object notify)
    Create the worker.

    This does not start the thread, merely configures it.

    Parameters:
      `task` - the task
      `notify` - what to notify

  - ### WorkerAnt

    public WorkerAnt(Task task)
    Create the worker, using the worker as the notification point.

    This does not start the thread, merely configures it.

    Parameters:
      `task` - the task

- ## Method Details

  - ### getBuildException

    public BuildException getBuildException()
    Get any build exception. This would seem to be oversynchronised, but know that Java pre-1.5 can reorder volatile access. The synchronized attribute is to force an ordering.
    Returns:
      the exception or null

  - ### getException

    public Throwable getException()
    Get whatever was thrown, which may or may not be a buildException. Assertion: getException() instanceof BuildException <=> getBuildException()==getException()
    Returns:
      the exception.

  - ### getTask

    public Task getTask()
    Get the task
    Returns:
      the task

  - ### isFinished

    public boolean isFinished()
    Query the task/thread for being finished. This would seem to be oversynchronised, but know that Java pre-1.5 can reorder volatile access. The synchronized attribute is to force an ordering.
    Returns:
      true if the task is finished.

  - ### waitUntilFinished

    public void waitUntilFinished(long timeout) throws InterruptedException
    Block on the notify object and so wait until the thread is finished.
    Parameters:
      `timeout` - timeout in milliseconds
    Throws:
      `InterruptedException` - if the execution was interrupted

  - ### rethrowAnyBuildException

    public void rethrowAnyBuildException()
    Raise an exception if one was caught
    Throws:
      `BuildException` - if one has been picked up

  - ### run

    public void run()
    Run the task, which is skipped if null. When invoked again, the task is re-run.
    Specified by:
      `run` in interface `Runnable`
    Overrides:
      `run` in class `Thread`