WorkerAnt (Apache Ant API)
Date: 2016-04-24

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 `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 and 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 and 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

    Methods
    Modifier and Type | Method and 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, destroy, dumpStack, enumerate, getAllStackTraces, getContextClassLoader, getDefaultUncaughtExceptionHandler, getId, getName, getPriority, getStackTrace, getState, getThreadGroup, getUncaughtExceptionHandler, holdsLock, interrupt, interrupted, isAlive, isDaemon, isInterrupted, join, join, join, resume, setContextClassLoader, setDaemon, setDefaultUncaughtExceptionHandler, setName, setPriority, setUncaughtExceptionHandler, sleep, sleep, start, stop, stop, suspend, toString, yield`

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

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

- - ### Field Detail

    - #### 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 Detail

    - #### 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 Detail

    - #### 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`