Package org.apache.tools.ant.util

# Class WorkerAnt

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

All Implemented Interfaces:
  `java.lang.Runnable`

    public class WorkerAnt
    extends java.lang.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

  `java.lang.Thread.State, java.lang.Thread.UncaughtExceptionHandler`

- ## Field Summary

  Fields
  Modifier and Type | Field | Description
  --- | --- | ---
  `static java.lang.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, java.lang.Object notify)` | Create the worker.

- ## Method Summary

  Modifier and Type | Method | Description
  --- | --- | ---
  `BuildException` | `getBuildException()` | Get any build exception.
  `java.lang.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, join, join, join, onSpinWait, resume, setContextClassLoader, setDaemon, setDefaultUncaughtExceptionHandler, setName, setPriority, setUncaughtExceptionHandler, sleep, sleep, start, stop, suspend, 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 java.lang.String ERROR_NO_TASK
    Error message if invoked with no task
    See Also:
      Constant Field Values

- ## Constructor Details

  - ### WorkerAnt

    public WorkerAnt​(Task task, java.lang.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 java.lang.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 java.lang.InterruptedException
    Block on the notify object and so wait until the thread is finished.
    Parameters:
      `timeout` - timeout in milliseconds
    Throws:
      `java.lang.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 `java.lang.Runnable`
    Overrides:
      `run` in class `java.lang.Thread`